#ifndef Model_IDL
#define Model_IDL

#include <orb.idl>
#include "Reflective.idl"

module Model {
   typedef sequence <any> AnyBag;
   typedef sequence <::Reflective::ConstraintViolation> ConstraintViolationSet;
   interface ModelPackage;
   interface ModelElementClass;
   interface ModelElement;
   typedef sequence <::Model::ModelElement> ModelElementSet;
   typedef sequence <::Model::ModelElement> ModelElementUList;
   interface NamespaceClass;
   interface Namespace;
   typedef sequence <::Model::Namespace> NamespaceUList;
   interface GeneralizableElementClass;
   interface GeneralizableElement;
   typedef sequence <::Model::GeneralizableElement> GeneralizableElementUList;
   typedef sequence <::Model::GeneralizableElement> GeneralizableElementSet;
   interface TypedElementClass;
   interface TypedElement;
   typedef sequence <::Model::TypedElement> TypedElementSet;
   typedef sequence <::Model::TypedElement> TypedElementUList;
   interface ClassifierClass;
   interface Classifier;
   typedef sequence <::Model::Classifier> ClassifierUList;
   interface ClassClass;
   interface Class;
   typedef sequence <::Model::Class> ClassUList;
   interface DataTypeClass;
   interface DataType;
   typedef sequence <::Model::DataType> DataTypeUList;
   interface TypeAliasClass;
   interface TypeAlias;
   typedef sequence <::Model::TypeAlias> TypeAliasUList;
   interface FeatureClass;
   interface Feature;
   typedef sequence <::Model::Feature> FeatureUList;
   interface StructuralFeatureClass;
   interface StructuralFeature;
   typedef sequence <::Model::StructuralFeature> StructuralFeatureUList;
   interface MofAttributeClass;
   interface MofAttribute;
   typedef sequence <::Model::MofAttribute> MofAttributeUList;
   interface ReferenceClass;
   interface Reference;
   typedef sequence <::Model::Reference> ReferenceUList;
   interface BehaviouralFeatureClass;
   interface BehaviouralFeature;
   typedef sequence <::Model::BehaviouralFeature> BehaviouralFeatureUList;
   interface OperationClass;
   interface Operation;
   typedef sequence <::Model::Operation> OperationSet;
   typedef sequence <::Model::Operation> OperationUList;
   interface MofExceptionClass;
   interface MofException;
   typedef sequence <::Model::MofException> MofExceptionUList;
   interface AssociationClass;
   interface Association;
   typedef sequence <::Model::Association> AssociationUList;
   interface AssociationEndClass;
   interface AssociationEnd;
   typedef sequence <::Model::AssociationEnd> AssociationEndUList;
   interface PackageClass;
   interface Package;
   typedef sequence <::Model::Package> PackageUList;
   interface ImportClass;
   interface Import;
   typedef sequence <::Model::Import> ImportSet;
   typedef sequence <::Model::Import> ImportUList;
   interface ParameterClass;
   interface Parameter;
   typedef sequence <::Model::Parameter> ParameterUList;
   interface ConstraintClass;
   interface Constraint;
   typedef sequence <::Model::Constraint> ConstraintSet;
   typedef sequence <::Model::Constraint> ConstraintUList;
   interface ConstantClass;
   interface Constant;
   typedef sequence <::Model::Constant> ConstantUList;
   interface TagClass;
   interface Tag;
   typedef sequence <::Model::Tag> TagUList;
   typedef string NameType;
   typedef sequence <::Model::NameType> NameTypeList;
   typedef string AnnotationType;

   interface ModelElementClass : Reflective::RefObject {
      readonly attribute ModelElementUList all_of_kind_model_element;

      const string name_must_be_corba_compliant =
        "::Model::ModelElement::name_must_be_corba_compliant";
      const string must_be_contained_unless_package =
        "::Model::ModelElement::must_be_contained_unless_package";
      const string update_to_frozen_model_element =
        "::Model::ModelElement::update_to_frozen_model_element";
      const string containment_dep = "containment";
      const string signature_dep = "signature";
      const string constraint_dep = "constraint";
      const string specialization_dep = "specialization";
      const string typedefinition_dep = "type definition";
      const string indirect_dep = "indirect";

      typedef string DependencyKind;
      typedef sequence <::Model::ModelElementClass::DependencyKind>
        DependencyKindSet;
      enum VerifyResultKind { valid, published, invalid };
      enum DepthKind { shallow, deep };

   }; // end of interface ModelElementClass

   interface ModelElement : ModelElementClass {
      NameType name ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      NameTypeList qualified_name ()
         raises (Reflective::SemanticError);
      void set_name (in NameType new_name)
         raises (Reflective::SemanticError);
      AnnotationType annotation ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_annotation (in AnnotationType new_value)
         raises (Reflective::SemanticError);
      ModelElementSet required_elements ()
         raises (Reflective::SemanticError);
      void set_required_elements (in ModelElementSet new_values)
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void add_required_elements (in ModelElement new_value)
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void modify_required_elements (in ModelElement old_value,
                                     in ModelElement new_value)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void remove_required_elements (in ModelElement old_value)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      ModelElementSet find_required_elements (
                               in ModelElementClass::DependencyKindSet kinds,
                               in boolean recursive)
         raises (Reflective::SemanticError);
      boolean is_required_because (in ModelElement other,
                                   out ModelElementClass::DependencyKind kind)
         raises (Reflective::SemanticError);
      Namespace container ()
         raises (Reflective::NotSet, Reflective::SemanticError);
      void set_container (in Namespace new_value)
         raises (Reflective::SemanticError);
      void unset_container ()
         raises (Reflective::SemanticError);
      ConstraintSet constraints ()
         raises (Reflective::SemanticError);
      void set_constraints (in ConstraintSet new_values)
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void add_constraints (in Constraint new_value)
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void modify_constraints (in Constraint old_value, in Constraint new_value)
      raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void remove_constraints (in Constraint old_value)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      ModelElementClass::VerifyResultKind verify (
                                in ModelElementClass::DepthKind depth,
                                out ::Model::ConstraintViolationSet problems)
         raises (Reflective::SemanticError);
      boolean is_frozen ()
         raises (Reflective::SemanticError);
      boolean is_visible (in ModelElement other_element)
         raises (Reflective::SemanticError);
   }; // end of interface ModelElement

   enum VisibilityKind { public_vis, protected_vis, private_vis };

   interface NamespaceClass : ModelElementClass {
      readonly attribute NamespaceUList all_of_kind_namespace;

      const string namespace_does_not_contain_itself =
        "::Model::Namespace::namespace_does_not_contain_itself";
      const string namespace_contents_have_unique_names =
        "::Model::Namespace::namespace_contents_have_unique_names";

      exception NameNotFound { NameType name; };
      exception NameNotResolved {
         NameType missing_name;
         NameTypeList resolved_part; };
      exception BadKindString {};
   }; // end of interface NamespaceClass

   interface Namespace : NamespaceClass, ModelElement {
      ModelElementUList contents ()
         raises (Reflective::SemanticError);
      void set_contents (in ModelElementUList new_values)
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void add_contents (in ModelElement new_value)
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void add_contents_before (in ModelElement new_value,
                                in ModelElement before)
         raises (Reflective::StructuralError,
                 Reflective::NotFound, Reflective::SemanticError);
      void modify_contents (in ModelElement old_value,
                            in ModelElement new_value)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void remove_contents (in ModelElement old_value)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      ModelElement lookup_element (in NameType name)
         raises (NamespaceClass::NameNotFound, Reflective::SemanticError);
      ModelElement resolve_qualified_name (in NameTypeList qualified_name)
         raises (NamespaceClass::NameNotResolved,
                 Reflective::SemanticError);
      ModelElementUList find_elements_by_type (in Class of_type,
                                               in boolean include_subtypes)
         raises (Reflective::SemanticError);
      boolean name_is_valid (in NameType proposed_name)
         raises (Reflective::SemanticError);
   }; // end of interface Namespace

   enum TristateKind { yes, no, dont_care };

   interface GeneralizableElementClass : NamespaceClass {
      readonly attribute GeneralizableElementUList
      all_of_kind_generalizable_element;

      const string supertype_contents_must_be_unique =
        "::Model::GeneralizableElement::supertype_contents_must_be_unique";
      const string supertypes_must_obey_diamond_rule =
        "::Model::GeneralizableElement::supertypes_must_obey_diamond_rule";
      const string supertype_must_not_be_self =
        "::Model::GeneralizableElement::supertype_must_not_be_self";
      const string supertype_is_of_the_same_type =
        "::Model::GeneralizableElement::supertype_is_of_the_same_type";
      const string supertype_visible_from_subtype =
        "::Model::GeneralizableElement::supertype_visible_from_subtype";
      const string is_root_yes_implies_no_supertypes =
        "::Model::GeneralizableElement::is_root_yes_implies_no_supertypes";
      const string is_root_no_implies_supertypes =
        "::Model::GeneralizableElement::is_root_no_implies_supertypes";
      const string is_leaf_yes_implies_no_subtypes =
        "::Model::GeneralizableElement::is_leaf_yes_implies_no_subtypes";
      const string is_leaf_no_implies_subtypes =
        "::Model::GeneralizableElement::is_leaf_no_implies_subtypes";
   }; // end of interface GeneralizableElementClass

   interface GeneralizableElement : GeneralizableElementClass, Namespace {
      TristateKind is_root ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_is_root (in TristateKind new_value)
         raises (Reflective::SemanticError);
      void set_is_leaf (in TristateKind new_value)
         raises (Reflective::SemanticError);
      boolean is_abstract ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_is_abstract (in boolean new_value)
         raises (Reflective::SemanticError);
      VisibilityKind visibility ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_visibility (in VisibilityKind new_value)
         raises (Reflective::SemanticError);
      GeneralizableElementUList supertypes ()
         raises (Reflective::SemanticError);
      void set_supertypes (in GeneralizableElementUList new_values)
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void add_supertypes (in GeneralizableElement new_value)
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void add_supertypes_before (in GeneralizableElement new_value,
                                  in GeneralizableElement before)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void modify_supertypes (in GeneralizableElement old_value,
                              in GeneralizableElement new_value)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void remove_supertypes (in GeneralizableElement old_value)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      GeneralizableElementSet all_supertypes ()
         raises (Reflective::SemanticError);
      ModelElement lookup_element_extended (in NameType name)
         raises (Reflective::SemanticError);
      ModelElementUList find_elements_by_type_extended (in NameType name)
         raises (Reflective::SemanticError);
   }; // end of interface GeneralizableElement

   interface TypedElementClass : ModelElementClass {
      // get all typed_element including subtypes of typed_element
      readonly attribute TypedElementUList all_of_kind_typed_element;

      const string type_visible_from_typed_element =
        "::Model::TypedElement::type_visible_from_typed_element";
   }; // end of interface TypedElementClass

   interface TypedElement : TypedElementClass, ModelElement {
      Classifier type ()
         raises (Reflective::SemanticError);
      void set_type (in Classifier new_value)
         raises (Reflective::SemanticError);
   }; // end of interface TypedElement

   interface ClassifierClass : GeneralizableElementClass {
      readonly attribute ClassifierUList all_of_kind_classifier;
   }; // end of interface ClassifierClass

   interface Classifier : ClassifierClass, GeneralizableElement { };

   interface ClassClass : ClassifierClass {
      readonly attribute ClassUList all_of_kind_class;
      readonly attribute ClassUList all_of_type_class;

      const string abstract_implies_not_singleton =
        "::Model::Class::abstract_implies_not_singleton";
      const string type_containment_rules =
        "::Model::Class::type_containment_rules";

      Class create_class (
          /* from ModelElement */         in ::Model::NameType name,
          /* from ModelElement */         in ::Model::AnnotationType annotation,
          /* from GeneralizableElement */ in ::Model::TristateKind is_root,
          /* from GeneralizableElement */ in ::Model::TristateKind is_leaf,
          /* from GeneralizableElement */ in boolean is_abstract,
          /* from GeneralizableElement */ in ::Model::VisibilityKind visibility,
          /* from Class */                in boolean is_singleton)
         raises (Reflective::SemanticError);
   }; // end of interface ClassClass

   interface Class : ClassClass, Classifier {
      boolean is_singleton ()
         raises (Reflective::StructuralError,
                 Reflective::SemanticError);
      void set_is_singleton (in boolean new_value)
         raises (Reflective::SemanticError);
   }; // end of interface Class

   interface DataTypeClass : ClassifierClass {
      readonly attribute DataTypeUList all_of_kind_data_type;
      readonly attribute DataTypeUList all_of_type_data_type;

      const string data_type_is_not_abstract =
        "::Model::DataType::data_type_is_not_abstract";
      const string data_type_allowable_typecode_kinds =
        "::Model::DataType::data_type_allowable_typecode_kinds";
      const string typecode_directly_embedded_types_represented =
        "::Model::DataType::typecode_directly_embedded_types_represented";
      const string data_type_containment_rules =
        "::Model::DataType::data_type_containment_rules";

      DataType create_data_type (
          /* from ModelElement */         in ::Model::NameType name,
          /* from ModelElement */         in ::Model::AnnotationType annotation,
          /* from GeneralizableElement */ in ::Model::TristateKind is_root,
          /* from GeneralizableElement */ in ::Model::TristateKind is_leaf,
          /* from GeneralizableElement */ in boolean is_abstract,
          /* from GeneralizableElement */ in ::Model::VisibilityKind visibility,
          /* from DataType */             in TypeCode type_code)
         raises (Reflective::SemanticError);
   }; // end of interface DataTypeClass

   interface DataType : DataTypeClass, Classifier {
      TypeCode type_code ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_type_code (in TypeCode new_value)
         raises (Reflective::SemanticError);
   }; // end of interface DataType

   interface TypeAliasClass : TypedElementClass {
      readonly attribute TypeAliasUList all_of_kind_type_alias;
      readonly attribute TypeAliasUList all_of_type_type_alias;

      TypeAlias create_type_alias (
                  /* from ModelElement */ in ::Model::NameType name,
                  /* from ModelElement */ in ::Model::AnnotationType annotation)
         raises (Reflective::SemanticError);
   }; // end of interface TypeAliasClass

   interface TypeAlias : TypeAliasClass, TypedElement { };

   enum ScopeKind { instance_level, classifier_level };

   interface FeatureClass : ModelElementClass {
      readonly attribute FeatureUList all_of_kind_feature;
   }; // end of interface FeatureClass

   interface Feature : FeatureClass, ModelElement {
      ScopeKind scope ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_scope (in ScopeKind new_value)
         raises (Reflective::SemanticError);
      VisibilityKind visibility ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_visibility (in VisibilityKind new_value)
         raises (Reflective::SemanticError);
   }; // end of interface Feature

   interface StructuralFeatureClass : FeatureClass, TypedElementClass {
      readonly attribute StructuralFeatureUList all_of_kind_structural_feature;

      const string parameter_not_an_association =
        "::Model::StructuralFeature::parameter_not_an_association";
   }; // end of interface StructuralFeatureClass

   interface StructuralFeature : StructuralFeatureClass, Feature, TypedElement {
      boolean is_changeable ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_is_changeable (in boolean new_value)
         raises (Reflective::SemanticError);
   }; // end of interface StructuralFeature

   interface MofAttributeClass : StructuralFeatureClass {
      readonly attribute MofAttributeUList all_of_kind_mof_attribute;
      readonly attribute MofAttributeUList all_of_type_mof_attribute;

      MofAttribute create_mof_attribute (
             /* from ModelElement */      in ::Model::NameType name,
             /* from ModelElement */      in ::Model::AnnotationType annotation,
             /* from Feature */           in ::Model::ScopeKind scope,
             /* from Feature */           in ::Model::VisibilityKind visibility,
             /* from StructuralFeature */ in boolean is_changeable,
             /* from MofAttribute */      in boolean is_derived)
         raises (Reflective::SemanticError);
   }; // end of interface MofAttributeClass

   interface MofAttribute : MofAttributeClass, StructuralFeature {
      boolean is_derived ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_is_derived (in boolean new_value)
         raises (Reflective::SemanticError);
   }; // end of interface MofAttribute

   interface ReferenceClass : StructuralFeatureClass {
      readonly attribute ReferenceUList all_of_kind_reference;
      readonly attribute ReferenceUList all_of_type_reference;

      const string reference_is_instance_scope =
        "::Model::Reference::reference_is_instance_scope";
      const string referenced_end_type_consistent_with_container =
        "::Model::Reference::referenced_end_type_consistent_with_container";
      const string referenced_end_visible_from_reference =
        "::Model::Reference::referenced_end_visible_from_reference";
      const string changeable_reference_has_changeable_referent =
        "::Model::Reference::changeable_reference_has_changeable_referent";
      const string reference_multiplicity_matches_referenced_end =
        "::Model::Reference::reference_multiplicity_matches_referenced_end";
      const string reference_type_is_referenced_ends =
        "::Model::Reference::reference_type_is_referenced_ends";

      Reference create_reference (
             /* from ModelElement */      in ::Model::NameType name,
             /* from ModelElement */      in ::Model::AnnotationType annotation,
             /* from Feature */           in ::Model::ScopeKind scope,
             /* from Feature */           in ::Model::VisibilityKind visibility,
             /* from StructuralFeature */ in boolean is_changeable)
         raises (Reflective::SemanticError);
   }; // end of interface ReferenceClass

   interface Reference : ReferenceClass, StructuralFeature {
      AssociationEnd exposed_end ()
         raises (Reflective::SemanticError);
      void set_exposed_end (in AssociationEnd new_value)
         raises (Reflective::SemanticError);
      AssociationEnd referenced_end ()
         raises (Reflective::SemanticError);
      void set_referenced_end (in AssociationEnd new_value)
         raises (Reflective::SemanticError);
   }; // end of interface Reference

   interface BehaviouralFeatureClass : FeatureClass, NamespaceClass {
      readonly attribute BehaviouralFeatureUList all_of_kind_behavioural_feature;
   }; // end of interface BehaviouralFeatureClass

   interface BehaviouralFeature :
      BehaviouralFeatureClass, Feature , Namespace {};

   interface OperationClass : BehaviouralFeatureClass {
      readonly attribute OperationUList all_of_kind_operation;
      readonly attribute OperationUList all_of_type_operation;

      const string operation_has_at_most_one_return_parameter =
        "::Model::Operation::operation_has_at_most_one_return_parameter";
      const string operation_containment_rules =
        "::Model::Operation::operation_containment_rules";
      const string exception_visible_from_operation =
        "::Model::Operation::exception_visible_from_operation";

      Operation create_operation (
                  /* from ModelElement */ in ::Model::NameType name,
                  /* from ModelElement */ in ::Model::AnnotationType annotation,
                  /* from Feature */      in ::Model::ScopeKind scope,
                  /* from Feature */      in ::Model::VisibilityKind visibility,
                  /* from Operation */    in boolean is_query)
         raises (Reflective::SemanticError);
   }; // end of interface OperationClass

   interface Operation : OperationClass, BehaviouralFeature {
      boolean is_query ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_is_query (in boolean new_value)
         raises (Reflective::SemanticError);
      MofExceptionUList exceptions ()
         raises (Reflective::ConstraintError, Reflective::SemanticError);
      void set_exceptions (in MofExceptionUList new_values)
         raises (Reflective::StructuralError,
                 Reflective::ConstraintError,
                 Reflective::SemanticError);
      void add_exceptions (in MofException new_value)
         raises (Reflective::StructuralError,
                 Reflective::ConstraintError,
                 Reflective::SemanticError);
      void add_exceptions_before (in MofException new_value,
                                  in MofException before)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::ConstraintError,
                 Reflective::SemanticError);
      void modify_exceptions (in MofException old_value,
                              in MofException new_value)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::ConstraintError,
                 Reflective::SemanticError);
      void remove_exceptions (in MofException old_value)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::ConstraintError,
                 Reflective::SemanticError);
   }; // end of interface Operation

   interface MofExceptionClass : BehaviouralFeatureClass {
      readonly attribute MofExceptionUList all_of_kind_mof_exception;
      readonly attribute MofExceptionUList all_of_type_mof_exception;

      const string exception_has_only_out_parameters =
        "::Model::MofException::exception_has_only_out_parameters";
      const string exception_containment_rules =
        "::Model::MofException::exception_containment_rules";

      MofException create_mof_exception (
                  /* from ModelElement */ in ::Model::NameType name,
                  /* from ModelElement */ in ::Model::AnnotationType annotation,
                  /* from Feature */      in ::Model::ScopeKind scope,
                  /* from Feature */      in ::Model::VisibilityKind visibility)
         raises (Reflective::SemanticError);
   }; // end of interface MofExceptionClass

   interface MofException : MofExceptionClass , BehaviouralFeature { };

   interface AssociationClass : ClassifierClass {
      readonly attribute AssociationUList all_of_kind_association;
      readonly attribute AssociationUList all_of_type_association;
      const string association_has_no_supertypes =
        "::Model::Association::association_has_no_supertypes";
      const string association_root_and_leaf_dont_care =
        "::Model::Association::association_root_and_leaf_dont_care";
      const string association_is_not_abstract =
        "::Model::Association::association_is_not_abstract";
      const string association_has_two_ends =
        "::Model::Association::association_has_two_ends";
      const string association_less_than_two_aggregate_ends =
        "::Model::Association::association_less_than_two_aggregate_ends";
      const string association_less_than_two_ordered_ends =
        "::Model::Association::association_less_than_two_ordered_ends";
      const string association_containment_rules =
        "::Model::Association::association_containment_rules";
      const string non_public_association =
        "::Model::Association::non_public_association";

      Association create_association (
          /* from ModelElement */         in ::Model::NameType name,
          /* from ModelElement */         in ::Model::AnnotationType annotation,
          /* from GeneralizableElement */ in ::Model::TristateKind is_root,
          /* from GeneralizableElement */ in ::Model::TristateKind is_leaf,
          /* from GeneralizableElement */ in boolean is_abstract,
          /* from GeneralizableElement */ in ::Model::VisibilityKind visibility,
          /* from Association */          in boolean is_derived)
         raises (Reflective::SemanticError);
   }; // end of interface AssociationClass

   interface Association : AssociationClass, Classifier {

      boolean is_derived ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_is_derived (in boolean new_value)
         raises (Reflective::SemanticError);
   }; // end of interface Association

   enum AggregationKind { none, shared, composite };

   const long unbounded = -1;

   struct MultiplicityType {
      long lower; 
      long upper; 
      boolean is_ordered; 
      boolean is_unique; };

   const string multiplicity_lower_not_unbounded =
     "::Model::multiplicity_lower_not_unbounded";
   const string multiplicity_upper_greater_than_or_equal_to_lower =
     "::Model::multiplicity_upper_greater_than_or_equal_to_lower";
   const string multiplicity_upper_cannot_equal_zero =
     "::Model::multiplicity_upper_cannot_equal_zero";
   const string multiplicity_single_valued_implies_not_ordered_and_not_unique =
     "::Model::multiplicity_single_valued_implies_not_ordered_and_not_unique";

   interface AssociationEndClass : ModelElementClass {
      readonly attribute AssociationEndUList all_of_kind_association_end;
      readonly attribute AssociationEndUList all_of_type_association_end;

      const string association_end_is_unique =
        "::Model::AssociationEnd::association_end_is_unique";
      const string association_end_has_referent_implies_is_navigable =
        "::Model::AssociationEnd::association_end_has_referent_implies_is_navigable";
      const string association_end_type_not_association_or_data_type =
        "::Model::AssociationEnd::association_end_type_not_association_or_data_type";

      AssociationEnd create_association_end (
            /* from ModelElement */   in ::Model::NameType name,
            /* from ModelElement */   in ::Model::AnnotationType annotation,
            /* from AssociationEnd */ in boolean is_navigable,
            /* from AssociationEnd */ in ::Model::AggregationKind aggregation,
            /* from AssociationEnd */ in ::Model::MultiplicityType multiplicity)
         raises (Reflective::ConstraintError, Reflective::SemanticError);
   }; // end of interface AssociationEndClass

   interface AssociationEnd : AssociationEndClass, ModelElement {
      boolean is_navigable ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_is_navigable (in boolean new_value)
         raises (Reflective::SemanticError);
      AggregationKind aggregation ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_aggregation (in AggregationKind new_value)
         raises (Reflective::SemanticError);
      MultiplicityType multiplicity ()
         raises (Reflective::StructuralError,
                 Reflective::ConstraintError,
                 Reflective::SemanticError);
      void set_multiplicity (in MultiplicityType new_value)
         raises (Reflective::ConstraintError, Reflective::SemanticError);
      AssociationEnd other_end ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_other_end (in AssociationEnd new_value)
         raises (Reflective::SemanticError);
   }; // end of interface AssociationEnd


   interface PackageClass : GeneralizableElementClass {
      readonly attribute PackageUList all_of_kind_package;
      readonly attribute PackageUList all_of_type_package;

      const string package_not_abstract =
        "::Model::Package::package_not_abstract";
      const string package_containment_rules =
        "::Model::Package::package_containment_rules";

      typedef string FormatType;

      exception FormatNotSupported {};
      exception ObjectNotExternalisable { string explanation; };
      exception IllformedExternalisedObject { string explanation; };

      GeneralizableElement internalise (in any flattened,
                                        in PackageClass::FormatType format)
         raises (PackageClass::FormatNotSupported,
                 PackageClass::IllformedExternalisedObject,
                 Reflective::SemanticError);

      Package create_package (
          /* from ModelElement */         in ::Model::NameType name,
          /* from ModelElement */         in ::Model::AnnotationType annotation,
          /* from GeneralizableElement */ in ::Model::TristateKind is_root,
          /* from GeneralizableElement */ in ::Model::TristateKind is_leaf,
          /* from GeneralizableElement */ in boolean is_abstract,
          /* from GeneralizableElement */ in ::Model::VisibilityKind visibility)
         raises (Reflective::SemanticError);
   }; // end of interface PackageClass

   interface Package : PackageClass, GeneralizableElement {

      any externalise (in PackageClass::FormatType format)
         raises (PackageClass::ObjectNotExternalisable,
                 PackageClass::FormatNotSupported,
                 Reflective::SemanticError);
   }; // end of interface Package

   interface ImportClass : ModelElementClass {
      readonly attribute ImportUList all_of_kind_import;
      readonly attribute ImportUList all_of_type_import;

      const string import_imports_type_or_package =
        "::Model::Import::import_imports_type_or_package";
      const string import_does_not_import_container =
        "::Model::Import::import_does_not_import_container";
      const string imports_imported_does_not_contain_import =
        "::Model::Import::imports_imported_does_not_contain_import";
      const string imported_visible_from_import =
        "::Model::Import::imported_visible_from_import";

      Import create_import (
                  /* from ModelElement */ in ::Model::NameType name,
                  /* from ModelElement */ in ::Model::AnnotationType annotation,
                  /* from Import */       in ::Model::VisibilityKind visibility)
         raises (Reflective::SemanticError);
   }; // end of interface ImportClass

   interface Import : ImportClass, ModelElement {
      VisibilityKind visibility ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_visibility (in VisibilityKind new_value)
         raises (Reflective::SemanticError);
      Namespace imported_namespace ()
         raises (Reflective::SemanticError);
      void set_imported_namespace (in Namespace new_value)
         raises (Reflective::SemanticError);
   }; // end of interface Import

   enum DirectionKind { in_dir, out_dir, inout_dir, return_dir };

   interface ParameterClass : TypedElementClass {
      readonly attribute ParameterUList all_of_kind_parameter;
      readonly attribute ParameterUList all_of_type_parameter;

      const string parameter_not_an_association =
        "::Model::Parameter::parameter_not_an_association";

      Parameter create_parameter (
              /* from ModelElement */ in ::Model::NameType name,
              /* from ModelElement */ in ::Model::AnnotationType annotation,
              /* from Parameter */    in ::Model::DirectionKind direction,
              /* from Parameter */    in ::Model::MultiplicityType multiplicity)
         raises (Reflective::ConstraintError, Reflective::SemanticError);
   }; // end of interface ParameterClass

   interface Parameter : ParameterClass, TypedElement {
      DirectionKind direction ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_direction (in DirectionKind new_value)
         raises (Reflective::SemanticError);
      MultiplicityType multiplicity ()
         raises (Reflective::StructuralError,
                 Reflective::ConstraintError,
                 Reflective::SemanticError);
      void set_multiplicity (in MultiplicityType new_value)
         raises (Reflective::ConstraintError, Reflective::SemanticError);
   }; // end of interface Parameter

   interface ConstraintClass : ModelElementClass {
      readonly attribute ConstraintUList all_of_kind_constraint;
      readonly attribute ConstraintUList all_of_type_constraint;

      enum EvaluationKind { immediate, deferred };

      const string constraint_does_not_constrain_constraints =
        "::Model::Constraint::constraint_does_not_constrain_constraints";
      const string constraint_does_not_constrain_element =
        "::Model::Constraint::constraint_does_not_constrain_element";
      const string constraints_only_allowed_within_container =
        "::Model::Constraint::constraints_only_allowed_within_container";

            Constraint create_constraint (
                 /* from ModelElement */ in ::Model::NameType name,
                 /* from ModelElement */ in ::Model::AnnotationType annotation,
                 /* from Constraint */ in any expression,
                 /* from Constraint */ in string language,
                 /* from Constraint */
                 in ::Model::ConstraintClass::EvaluationKind evaluation_policy)
         raises (Reflective::SemanticError);
   }; // end of interface ConstraintClass

   interface Constraint : ConstraintClass, ModelElement {
      any expression ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_expression (in any new_value)
         raises (Reflective::SemanticError);
      string language ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_language (in string new_value)
         raises (Reflective::SemanticError);
      ConstraintClass::EvaluationKind evaluation_policy ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_evaluation_policy (in ConstraintClass::EvaluationKind new_value)
         raises (Reflective::SemanticError);
      ModelElementSet constrained_elts ()
         raises (Reflective::SemanticError);
      void set_constrained_elts (in ModelElementSet new_values)
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void add_constrained_elts (in ModelElement new_value)
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void modify_constrained_elts (in ModelElement old_value,
                                    in ModelElement new_value)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void remove_constrained_elts (in ModelElement old_value)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
   }; // end of interface Constraint

   typedef any LiteralType;

   interface ConstantClass : TypedElementClass {
      readonly attribute ConstantUList all_of_kind_constant;
      readonly attribute ConstantUList all_of_type_constant;

      const string constant_type_must_be_corba_const_type =
        "::Model::Constant::constant_type_must_be_corba_const_type";
      const string constant_value_compatible_with_type =
        "::Model::Constant::constant_value_compatible_with_type";

      Constant create_constant (
                  /* from ModelElement */ in ::Model::NameType name,
                  /* from ModelElement */ in ::Model::AnnotationType annotation,
                  /* from Constant */     in ::Model::LiteralType const_value)
         raises (Reflective::SemanticError);
   }; // end of interface ConstantClass

   interface Constant : ConstantClass, TypedElement {
      LiteralType const_value ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_const_value (in LiteralType new_value)
         raises (Reflective::SemanticError);
   }; // end of interface Constant

   interface TagClass : ModelElementClass {
      readonly attribute TagUList all_of_kind_tag;
      readonly attribute TagUList all_of_type_tag;

      Tag create_tag (
                 /* from ModelElement */ in ::Model::NameType name,
                 /* from ModelElement */ in ::Model::AnnotationType annotation,
                 /* from Tag */          in string tag_id,
                 /* from Tag */          in any values)
         raises (Reflective::SemanticError);
   }; // end of interface TagClass

   interface Tag : TagClass, ModelElement {
      string tag_id ()
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void set_tag_id (in string new_value)
         raises (Reflective::SemanticError);
      AnyBag values ()
         raises (Reflective::SemanticError);
      void set_values (in AnyBag new_value)
         raises (Reflective::SemanticError);
      void unset_values ()
         raises (Reflective::SemanticError);
      void add_values (in any new_value)
         raises (Reflective::SemanticError);
      void modify_values (in any old_value, in any new_value)
         raises (Reflective::NotFound, Reflective::SemanticError);
      void remove_values (in any old_value)
         raises (Reflective::NotFound, Reflective::SemanticError);
      TagUList elements ()
         raises (Reflective::SemanticError);
      void set_elements (in TagUList new_values)
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void add_elements (in Tag new_value)
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void add_elements_before (in Tag new_value, in Tag before)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void modify_elements (in Tag old_value, in Tag new_value)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void remove_elements (in Tag old_value)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
   }; // end of interface Tag

   struct AttachesToLink {
      ModelElement model_element;
      Tag tag;
   };
   typedef sequence <AttachesToLink> AttachesToLinkSet;

   interface AttachesTo : Reflective::RefAssociation {
      AttachesToLinkSet all_AttachesTo_links ();
      boolean exists (in ModelElement model_element, in Tag tag);
      TagUList with_model_element (in ModelElement model_element);
      ModelElementSet with_tag (in Tag tag);
      void add (in ModelElement model_element, in Tag tag)
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void add_before_tag (in ModelElement model_element,
                           in Tag tag,
                           in Tag before)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void modify_model_element (in ModelElement model_element,
                                 in Tag tag,
                                 in ModelElement new_model_element)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void modify_tag (in ModelElement model_element,
                       in Tag tag,
                       in Tag new_tag)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void remove (in ModelElement model_element, in Tag tag)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
   };

   struct DependsOnLink {
      ModelElement dependent;
      ModelElement provider;
   };
   typedef sequence <DependsOnLink> DependsOnLinkSet;

   interface DependsOn : Reflective::RefAssociation {
      DependsOnLinkSet all_DependsOn_links ();
      boolean exists (in ModelElement dependent, in ModelElement provider);
      ModelElementSet with_dependent (in ModelElement dependent);
      ModelElementSet with_provider (in ModelElement provider);
      void add (in ModelElement dependent, in ModelElement provider)
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void modify_dependent (in ModelElement dependent,
                             in ModelElement provider,
                             in ModelElement new_dependent)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void modify_provider (in ModelElement dependent,
                            in ModelElement provider,
                            in ModelElement new_provider)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void remove (in ModelElement dependent, in ModelElement provider)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
   };

   struct ContainsLink {
      Namespace container;
      ModelElement contained_element;
   };
   typedef sequence <ContainsLink> ContainsLinkSet;

   interface Contains : Reflective::RefAssociation {
      ContainsLinkSet all_Contains_links ();
      boolean exists (in Namespace container, in ModelElement contained_element);
      ModelElementUList with_container (in Namespace container);
      Namespace with_contained_element (in ModelElement contained_element);
      void add (in Namespace container, in ModelElement contained_element)
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void add_before_contained_element (in Namespace container,
                                         in ModelElement contained_element,
                                         in ModelElement before)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void modify_container (in Namespace container,
                             in ModelElement contained_element,
                             in Namespace new_container)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void modify_contained_element (in Namespace container,
                                     in ModelElement contained_element,
                                     in ModelElement new_contained_element)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void remove (in Namespace container, in ModelElement contained_element)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
   };

   struct GeneralizesLink {
      GeneralizableElement supertype;
      GeneralizableElement subtype;
   };
   typedef sequence <GeneralizesLink> GeneralizesLinkSet;

   interface Generalizes : Reflective::RefAssociation {
      GeneralizesLinkSet all_Generalizes_links ();
      boolean exists (in GeneralizableElement supertype,
                      in GeneralizableElement subtype);
      GeneralizableElementSet with_supertype (in GeneralizableElement supertype);
      GeneralizableElementUList with_subtype (in GeneralizableElement subtype);
      void add (in GeneralizableElement supertype,
                in GeneralizableElement subtype)
         raises (Reflective::StructuralError,
                 Reflective::SemanticError);
      void add_before_supertype (in GeneralizableElement supertype,
                                 in GeneralizableElement subtype,
                                 in GeneralizableElement before)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void modify_supertype (in GeneralizableElement supertype,
                             in GeneralizableElement subtype,
                             in GeneralizableElement new_supertype)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void modify_subtype (in GeneralizableElement supertype,
                           in GeneralizableElement subtype,
                           in GeneralizableElement new_subtype)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void remove (in GeneralizableElement supertype,
                   in GeneralizableElement subtype)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
   };

   struct AliasesLink {
      Import importer;
      Namespace imported;
   };
   typedef sequence <AliasesLink> AliasesLinkSet;

   interface Aliases : Reflective::RefAssociation {
      AliasesLinkSet all_Aliases_links ();
      boolean exists (in Import importer, in Namespace imported);
      Namespace with_importer (in Import importer);
      ImportSet with_imported (in Namespace imported);
      void add (in Import importer, in Namespace imported)
         raises (Reflective::StructuralError,
                 Reflective::SemanticError);
      void modify_importer (in Import importer,
                            in Namespace imported,
                            in Import new_importer)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void modify_imported (in Import importer,
                            in Namespace imported,
                            in Namespace new_imported)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void remove (in Import importer, in Namespace imported)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
   };

   struct ConstrainsLink {
      Constraint constraints;
      ModelElement constrained_element;
   };
   typedef sequence <ConstrainsLink> ConstrainsLinkSet;

   interface Constrains : Reflective::RefAssociation {
      ConstrainsLinkSet all_Constrains_links ();
      boolean exists (in Constraint constraints,
                      in ModelElement constrained_element);
      ModelElementSet with_constraints (in Constraint constraints);
      ConstraintSet with_constrained_element
        (in ModelElement constrained_element);
      void add (in Constraint constraints,
                in ModelElement constrained_element)
         raises (Reflective::StructuralError,
                 Reflective::SemanticError);
      void modify_constraints (in Constraint constraints,
                               in ModelElement constrained_element,
                               in Constraint new_constraints)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void modify_constrained_element (in Constraint constraints,
                                       in ModelElement constrained_element,
                                       in ModelElement new_constrained_element)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void remove (in Constraint constraints,
                   in ModelElement constrained_element)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
   };

   struct CanRaiseLink {
      Operation operation;
      MofException except;
   };
   typedef sequence <CanRaiseLink> CanRaiseLinkSet;

   interface CanRaise : Reflective::RefAssociation {
      const string exception_is_not_visible =
        "::Model::CanRaise::exception_is_not_visible";

      CanRaiseLinkSet all_CanRaise_links ();
      boolean exists (in Operation operation, in MofException except);
      MofExceptionUList with_operation (in Operation operation);
      OperationSet with_except (in MofException except);
      void add (in Operation operation, in MofException except)
         raises (Reflective::StructuralError,
                 Reflective::ConstraintError,
                 Reflective::SemanticError);
      void add_before_except (in Operation operation,
                              in MofException except,
                              in MofException before)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::ConstraintError,
                 Reflective::SemanticError);
      void modify_operation (in Operation operation,
                             in MofException except,
                             in Operation new_operation)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::ConstraintError,
                 Reflective::SemanticError);
      void modify_except (in Operation operation,
                          in MofException except,
                          in MofException new_except)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void remove (in Operation operation, in MofException except)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::ConstraintError,
                 Reflective::SemanticError);
   };

   struct ExposesLink {
      Reference referrer;
      AssociationEnd exposed_end;
   };
   typedef sequence <ExposesLink> ExposesLinkSet;

   interface Exposes : Reflective::RefAssociation {
      ExposesLinkSet all_Exposes_links ();
      boolean exists (in Reference referrer, in AssociationEnd exposed_end);
      AssociationEnd with_referrer (in Reference referrer);
      Reference with_exposed_end (in AssociationEnd exposed_end);
      void add (in Reference referrer, in AssociationEnd exposed_end)
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void modify_referrer (in Reference referrer,
                            in AssociationEnd exposed_end,
                            in Reference new_referrer)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void modify_exposed_end (in Reference referrer,
                               in AssociationEnd exposed_end,
                               in AssociationEnd new_exposed_end)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void remove (in Reference referrer, in AssociationEnd exposed_end)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
   };

   struct RefersToLink {
      Reference referent;
      AssociationEnd referenced_end;
   };
   typedef sequence <RefersToLink> RefersToLinkSet;

   interface RefersTo : Reflective::RefAssociation {
      RefersToLinkSet all_RefersTo_links ();
      boolean exists (in Reference referent, in AssociationEnd referenced_end);
      AssociationEnd with_referent (in Reference referent);
      Reference with_referenced_end (in AssociationEnd referenced_end);
      void add (in Reference referent, in AssociationEnd referenced_end)
         raises (Reflective::StructuralError,
                 Reflective::SemanticError);
      void modify_referent (in Reference referent,
                            in AssociationEnd referenced_end,
                            in Reference new_referent)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void modify_referenced_end (in Reference referent,
                                  in AssociationEnd referenced_end,
                                  in AssociationEnd new_referenced_end)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void remove (in Reference referent, in AssociationEnd referenced_end)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
   };

   struct IsOfTypeLink {
      Classifier type;
      TypedElement typed_elements;
   };
   typedef sequence <IsOfTypeLink> IsOfTypeLinkSet;

   interface IsOfType : Reflective::RefAssociation {
      IsOfTypeLinkSet all_IsOfType_links ();
      boolean exists (in Classifier type, in TypedElement typed_elements);
      TypedElementSet with_type (in Classifier type);
      Classifier with_typed_elements (in TypedElement typed_elements);
      void add (in Classifier type, in TypedElement typed_elements)
         raises (Reflective::StructuralError, Reflective::SemanticError);
      void modify_type (in Classifier type,
                        in TypedElement typed_elements,
                        in Classifier new_type)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void modify_typed_elements (in Classifier type,
                                  in TypedElement typed_elements,
                                  in TypedElement new_typed_elements)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
      void remove (in Classifier type, in TypedElement typed_elements)
         raises (Reflective::StructuralError,
                 Reflective::NotFound,
                 Reflective::SemanticError);
   };

   interface ModelPackageFactory {
      ModelPackage create_model_package ()
         raises (Reflective::SemanticError);
   };

   interface ModelPackage : Reflective::RefPackage {
      readonly attribute ModelElementClass model_element_class_ref;
      readonly attribute NamespaceClass namespace_class_ref;
      readonly attribute GeneralizableElementClass
        generalizable_element_class_ref;
      readonly attribute TypedElementClass typed_element_class_ref;
      readonly attribute ClassifierClass classifier_class_ref;
      readonly attribute ClassClass class_class_ref;
      readonly attribute DataTypeClass data_type_class_ref;
      readonly attribute TypeAliasClass type_alias_class_ref;
      readonly attribute FeatureClass feature_class_ref;
      readonly attribute StructuralFeatureClass structural_feature_class_ref;
      readonly attribute MofAttributeClass mof_attribute_class_ref;
      readonly attribute ReferenceClass reference_class_ref;
      readonly attribute BehaviouralFeatureClass behavioural_feature_class_ref;
      readonly attribute OperationClass operation_class_ref;
      readonly attribute MofExceptionClass mof_exception_class_ref;
      readonly attribute AssociationClass association_class_ref;
      readonly attribute AssociationEndClass association_end_class_ref;
      readonly attribute PackageClass package_class_ref;
      readonly attribute ImportClass import_class_ref;
      readonly attribute ParameterClass parameter_class_ref;
      readonly attribute ConstraintClass constraint_class_ref;
      readonly attribute ConstantClass constant_class_ref;
      readonly attribute TagClass tag_class_ref;
      readonly attribute AttachesTo attaches_to_ref;
      readonly attribute DependsOn depends_on_ref;
      readonly attribute Contains contains_ref;
      readonly attribute Generalizes generalizes_ref;
      readonly attribute Aliases aliases_ref;
      readonly attribute Constrains constrains_ref;
      readonly attribute CanRaise can_raise_ref;
      readonly attribute Exposes exposes_ref;
      readonly attribute RefersTo refers_to_ref;
      readonly attribute IsOfType is_of_type_ref;
   };
}; // end of module Model


#endif