#ifndef DATA_TYPES_IDL
#define DATA_TYPES_IDL
#pragma prefix "org.omg.uml.Foundation"
#include "Reflective.idl"

module DataTypes
{
   interface MultiplicityClass;
   interface Multiplicity;
   typedef sequence<Multiplicity> MultiplicitySet;
   interface MultiplicityRangeClass;
   interface MultiplicityRange;
   typedef sequence<MultiplicityRange> MultiplicityRangeSet;
   interface ExpressionClass;
   interface Expression;
   typedef sequence<Expression> ExpressionSet;
   interface BooleanExpressionClass;
   interface BooleanExpression;
   typedef sequence<BooleanExpression> BooleanExpressionSet;
   interface TypeExpressionClass;
   interface TypeExpression;
   typedef sequence<TypeExpression> TypeExpressionSet;
   interface MappingExpressionClass;
   interface MappingExpression;
   typedef sequence<MappingExpression> MappingExpressionSet;
   interface TimeExpressionClass;
   interface TimeExpression;
   typedef sequence<TimeExpression> TimeExpressionSet;
   interface ArgListsExpressionClass;
   interface ArgListsExpression;
   typedef sequence<ArgListsExpression> ArgListsExpressionSet;
   interface ProcedureExpressionClass;
   interface ProcedureExpression;
   typedef sequence<ProcedureExpression> ProcedureExpressionSet;
   interface DataTypesPackage;
   typedef long UnlimitedInteger;
   enum AggregationKind {ak_none, ak_aggregate, ak_composite};
   enum CallConcurrencyKind {cck_sequential, cck_guarded, cck_concurrent};
   enum ChangeableKind {ck_changeable, ck_frozen, ck_addOnly};
   enum OrderingKind {ok_unordered, ok_ordered};
   enum ParameterDirectionKind {pdk_in, pdk_inout, pdk_out, pdk_return};
   enum ScopeKind {sk_instance, sk_classifier};
   enum VisibilityKind {vk_public, vk_protected, vk_private, vk_package};
   typedef string Name;
   typedef sequence<Name> NameSet;  // Added by hand

   typedef string LocationReference;
   enum PseudostateKind {pk_choice, pk_deepHistory, pk_fork, pk_initial, pk_join, pk_junction, pk_shallowHistory};
   typedef string Geometry;

   interface MultiplicityClass : Reflective::RefObject
   {
      readonly attribute MultiplicitySet all_of_type_multiplicity;
      readonly attribute MultiplicitySet all_of_class_multiplicity;
      Multiplicity create_multiplicity ()
         raises (Reflective::MofError);
   };

   interface Multiplicity : MultiplicityClass
   {
      MultiplicityRangeSet range ()
         raises (Reflective::MofError);
      void set_range (in MultiplicityRangeSet new_value)
         raises (Reflective::MofError);
      void add_range (in MultiplicityRange new_element)
         raises (Reflective::MofError);
      void modify_range (
         in MultiplicityRange old_element,
         in MultiplicityRange new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_range (in MultiplicityRange old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Multiplicity

   interface MultiplicityRangeClass : Reflective::RefObject
   {
      readonly attribute MultiplicityRangeSet all_of_type_multiplicity_range;
      readonly attribute MultiplicityRangeSet all_of_class_multiplicity_range;
      MultiplicityRange create_multiplicity_range (
         in long lower,
         in UnlimitedInteger upper)
         raises (Reflective::MofError);
   };

   interface MultiplicityRange : MultiplicityRangeClass
   {
      long lower ()
         raises (Reflective::MofError);
      void set_lower (in long new_value)
         raises (Reflective::MofError);
      UnlimitedInteger upper ()
         raises (Reflective::MofError);
      void set_upper (in UnlimitedInteger new_value)
         raises (Reflective::MofError);
      DataTypes::Multiplicity multiplicity ()
         raises (Reflective::MofError);
      void set_multiplicity (in DataTypes::Multiplicity new_value)
         raises (Reflective::MofError);
   }; // end of interface MultiplicityRange

   interface ExpressionClass : Reflective::RefObject
   {
      readonly attribute ExpressionSet all_of_type_expression;
      readonly attribute ExpressionSet all_of_class_expression;
      Expression create_expression (
         in Name language,
         in string body)
         raises (Reflective::MofError);
   };

   interface Expression : ExpressionClass
   {
      Name language ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_language (in Name new_value)
         raises (Reflective::MofError);
      void unset_language ()
         raises (Reflective::MofError);
      string body ()
         raises (Reflective::MofError);
      void set_body (in string new_value)
         raises (Reflective::MofError);
   }; // end of interface Expression

   interface BooleanExpressionClass : ExpressionClass
   {
      readonly attribute BooleanExpressionSet all_of_type_boolean_expression;
      readonly attribute BooleanExpressionSet all_of_class_boolean_expression;
      BooleanExpression create_boolean_expression (
         in Name language,
         in string body)
         raises (Reflective::MofError);
   };

   interface BooleanExpression : BooleanExpressionClass, Expression
   {
   }; // end of interface BooleanExpression

   interface TypeExpressionClass : ExpressionClass
   {
      readonly attribute TypeExpressionSet all_of_type_type_expression;
      readonly attribute TypeExpressionSet all_of_class_type_expression;
      TypeExpression create_type_expression (
         in Name language,
         in string body)
         raises (Reflective::MofError);
   };

   interface TypeExpression : TypeExpressionClass, Expression
   {
   }; // end of interface TypeExpression

   interface MappingExpressionClass : ExpressionClass
   {
      readonly attribute MappingExpressionSet all_of_type_mapping_expression;
      readonly attribute MappingExpressionSet all_of_class_mapping_expression;
      MappingExpression create_mapping_expression (
         in Name language,
         in string body)
         raises (Reflective::MofError);
   };

   interface MappingExpression : MappingExpressionClass, Expression
   {
   }; // end of interface MappingExpression

   interface TimeExpressionClass : ExpressionClass
   {
      readonly attribute TimeExpressionSet all_of_type_time_expression;
      readonly attribute TimeExpressionSet all_of_class_time_expression;
      TimeExpression create_time_expression (
         in Name language,
         in string body)
         raises (Reflective::MofError);
   };

   interface TimeExpression : TimeExpressionClass, Expression
   {
   }; // end of interface TimeExpression

   interface ArgListsExpressionClass : ExpressionClass
   {
      readonly attribute ArgListsExpressionSet all_of_type_arg_lists_expression;
      readonly attribute ArgListsExpressionSet all_of_class_arg_lists_expression;
      ArgListsExpression create_arg_lists_expression (
         in Name language,
         in string body)
         raises (Reflective::MofError);
   };

   interface ArgListsExpression : ArgListsExpressionClass, Expression
   {
   }; // end of interface ArgListsExpression

   interface ProcedureExpressionClass : ExpressionClass
   {
      readonly attribute ProcedureExpressionSet all_of_type_procedure_expression;
      readonly attribute ProcedureExpressionSet all_of_class_procedure_expression;
      ProcedureExpression create_procedure_expression (
         in Name language,
         in string body)
         raises (Reflective::MofError);
   };

   interface ProcedureExpression : ProcedureExpressionClass, Expression
   {
   }; // end of interface ProcedureExpression

   struct AMultiplicityRangeLink
   {
      DataTypes::Multiplicity multiplicity;
      MultiplicityRange range;
   };
   typedef sequence<AMultiplicityRangeLink> AMultiplicityRangeLinkSet;

   interface AMultiplicityRange : Reflective::RefAssociation
   {
      AMultiplicityRangeLinkSet all_a_multiplicity_range_links()
         raises (Reflective::MofError);
      boolean exists (
         in DataTypes::Multiplicity multiplicity,
         in MultiplicityRange range)
         raises (Reflective::MofError);
      DataTypes::Multiplicity multiplicity (in MultiplicityRange range)
         raises (Reflective::MofError);
      MultiplicityRangeSet range (in DataTypes::Multiplicity multiplicity)
         raises (Reflective::MofError);
      void add (
         in DataTypes::Multiplicity multiplicity,
         in MultiplicityRange range)
         raises (Reflective::MofError);
      void modify_multiplicity (
         in DataTypes::Multiplicity multiplicity,
         in MultiplicityRange range,
         in DataTypes::Multiplicity new_multiplicity)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_range (
         in DataTypes::Multiplicity multiplicity,
         in MultiplicityRange range,
         in MultiplicityRange new_range)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in DataTypes::Multiplicity multiplicity,
         in MultiplicityRange range)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AMultiplicityRange

   interface DataTypesPackageFactory
   {
      DataTypesPackage create_data_types_package ()
         raises (Reflective::MofError);
   };

   interface DataTypesPackage : Reflective::RefPackage
   {
      readonly attribute MultiplicityClass multiplicity_ref;
      readonly attribute MultiplicityRangeClass multiplicity_range_ref;
      readonly attribute ExpressionClass expression_ref;
      readonly attribute BooleanExpressionClass boolean_expression_ref;
      readonly attribute TypeExpressionClass type_expression_ref;
      readonly attribute MappingExpressionClass mapping_expression_ref;
      readonly attribute TimeExpressionClass time_expression_ref;
      readonly attribute ArgListsExpressionClass arg_lists_expression_ref;
      readonly attribute ProcedureExpressionClass procedure_expression_ref;
      readonly attribute AMultiplicityRange a_multiplicity_range_ref;
   };
};

#endif