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

module Core
{
   typedef sequence<string> StringSet;
   interface ElementClass;
   interface Element;
   typedef sequence<Element> ElementSet;
   interface ModelElementClass;
   interface ModelElement;
   typedef sequence<ModelElement> ModelElementSet;
   typedef sequence<ModelElement> ModelElementUList;
   interface GeneralizableElementClass;
   interface GeneralizableElement;
   typedef sequence<GeneralizableElement> GeneralizableElementSet;
   interface NamespaceClass;
   interface Namespace;
   typedef sequence<Namespace> NamespaceSet;
   interface ClassifierClass;
   interface Classifier;
   typedef sequence<Classifier> ClassifierSet;
   interface ClassClass;
   interface Class;
   typedef sequence<Class> ClassSet;
   interface DataTypeClass;
   interface DataType;
   typedef sequence<DataType> DataTypeSet;
   interface FeatureClass;
   interface Feature;
   typedef sequence<Feature> FeatureSet;
   typedef sequence<Feature> FeatureUList;
   interface StructuralFeatureClass;
   interface StructuralFeature;
   typedef sequence<StructuralFeature> StructuralFeatureSet;
   interface AssociationEndClass;
   interface AssociationEnd;
   typedef sequence<AssociationEnd> AssociationEndSet;
   typedef sequence<AssociationEnd> AssociationEndUList;
   interface UmlInterfaceClass;
   interface UmlInterface;
   typedef sequence<UmlInterface> UmlInterfaceSet;
   interface UmlConstraintClass;
   interface UmlConstraint;
   typedef sequence<UmlConstraint> UmlConstraintSet;
   interface RelationshipClass;
   interface Relationship;
   typedef sequence<Relationship> RelationshipSet;
   interface AssociationClass;
   interface Association;
   typedef sequence<Association> AssociationSet;
   interface UmlAttributeClass;
   interface UmlAttribute;
   typedef sequence<UmlAttribute> UmlAttributeSet;
   typedef sequence<UmlAttribute> UmlAttributeUList;
   interface BehavioralFeatureClass;
   interface BehavioralFeature;
   typedef sequence<BehavioralFeature> BehavioralFeatureSet;
   interface OperationClass;
   interface Operation;
   typedef sequence<Operation> OperationSet;
   interface ParameterClass;
   interface Parameter;
   typedef sequence<Parameter> ParameterSet;
   typedef sequence<Parameter> ParameterUList;
   interface MethodClass;
   interface Method;
   typedef sequence<Method> MethodSet;
   interface GeneralizationClass;
   interface Generalization;
   typedef sequence<Generalization> GeneralizationSet;
   interface UmlAssociationClassClass;
   interface UmlAssociationClass;
   typedef sequence<UmlAssociationClass> UmlAssociationClassSet;
   interface DependencyClass;
   interface Dependency;
   typedef sequence<Dependency> DependencySet;
   interface AbstractionClass;
   interface Abstraction;
   typedef sequence<Abstraction> AbstractionSet;
   interface PresentationElementClass;
   interface PresentationElement;
   typedef sequence<PresentationElement> PresentationElementSet;
   interface UsageClass;
   interface Usage;
   typedef sequence<Usage> UsageSet;
   interface BindingClass;
   interface Binding;
   typedef sequence<Binding> BindingSet;
   interface ComponentClass;
   interface Component;
   typedef sequence<Component> ComponentSet;
   interface NodeClass;
   interface Node;
   typedef sequence<Node> NodeSet;
   interface PermissionClass;
   interface Permission;
   typedef sequence<Permission> PermissionSet;
   interface CommentClass;
   interface Comment;
   typedef sequence<Comment> CommentSet;
   interface FlowClass;
   interface Flow;
   typedef sequence<Flow> FlowSet;
   interface ElementResidenceClass;
   interface ElementResidence;
   typedef sequence<ElementResidence> ElementResidenceSet;
   interface TemplateParameterClass;
   interface TemplateParameter;
   typedef sequence<TemplateParameter> TemplateParameterSet;
   typedef sequence<TemplateParameter> TemplateParameterUList;
   interface PrimitiveClass;
   interface Primitive;
   typedef sequence<Primitive> PrimitiveSet;
   interface EnumerationClass;
   interface Enumeration;
   typedef sequence<Enumeration> EnumerationSet;
   interface EnumerationLiteralClass;
   interface EnumerationLiteral;
   typedef sequence<EnumerationLiteral> EnumerationLiteralSet;
   typedef sequence<EnumerationLiteral> EnumerationLiteralUList;
   interface StereotypeClass;
   interface Stereotype;
   typedef sequence<Stereotype> StereotypeSet;
   interface TagDefinitionClass;
   interface TagDefinition;
   typedef sequence<TagDefinition> TagDefinitionSet;
   interface TaggedValueClass;
   interface TaggedValue;
   typedef sequence<TaggedValue> TaggedValueSet;
   interface ProgrammingLanguageDataTypeClass;
   interface ProgrammingLanguageDataType;
   typedef sequence<ProgrammingLanguageDataType> ProgrammingLanguageDataTypeSet;
   interface ArtifactClass;
   interface Artifact;
   typedef sequence<Artifact> ArtifactSet;
   interface TemplateArgumentClass;
   interface TemplateArgument;
   typedef sequence<TemplateArgument> TemplateArgumentSet;
   typedef sequence<TemplateArgument> TemplateArgumentUList;
   interface CorePackage;

   interface ElementClass : Reflective::RefObject
   {
      readonly attribute ElementSet all_of_type_element;
   };

   interface Element : ElementClass
   {
   }; // end of interface Element

   interface ModelElementClass : ElementClass
   {
      readonly attribute ModelElementSet all_of_type_model_element;
   };

   interface ModelElement : ModelElementClass, Element
   {
      DataTypes::Name name ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_name (in DataTypes::Name new_value)
         raises (Reflective::MofError);
      void unset_name ()
         raises (Reflective::MofError);
      DataTypes::VisibilityKind visibility ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_visibility (in DataTypes::VisibilityKind new_value)
         raises (Reflective::MofError);
      void unset_visibility ()
         raises (Reflective::MofError);
      boolean is_specification ()
         raises (Reflective::MofError);
      void set_is_specification (in boolean new_value)
         raises (Reflective::MofError);
      Core::Namespace namespace ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_namespace (in Core::Namespace new_value)
         raises (Reflective::MofError);
      void unset_namespace ()
         raises (Reflective::MofError);
      DependencySet client_dependency ()
         raises (Reflective::MofError);
      void set_client_dependency (in DependencySet new_value)
         raises (Reflective::MofError);
      void unset_client_dependency ()
         raises (Reflective::MofError);
      void add_client_dependency (in Dependency new_element)
         raises (Reflective::MofError);
      void modify_client_dependency (
         in Dependency old_element,
         in Dependency new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_client_dependency (in Dependency old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      UmlConstraintSet uml_constraint ()
         raises (Reflective::MofError);
      void set_uml_constraint (in UmlConstraintSet new_value)
         raises (Reflective::MofError);
      void unset_uml_constraint ()
         raises (Reflective::MofError);
      void add_uml_constraint (in UmlConstraint new_element)
         raises (Reflective::MofError);
      void modify_uml_constraint (
         in UmlConstraint old_element,
         in UmlConstraint new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_uml_constraint (in UmlConstraint old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      FlowSet target_flow ()
         raises (Reflective::MofError);
      void set_target_flow (in FlowSet new_value)
         raises (Reflective::MofError);
      void unset_target_flow ()
         raises (Reflective::MofError);
      void add_target_flow (in Flow new_element)
         raises (Reflective::MofError);
      void modify_target_flow (
         in Flow old_element,
         in Flow new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_target_flow (in Flow old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      FlowSet source_flow ()
         raises (Reflective::MofError);
      void set_source_flow (in FlowSet new_value)
         raises (Reflective::MofError);
      void unset_source_flow ()
         raises (Reflective::MofError);
      void add_source_flow (in Flow new_element)
         raises (Reflective::MofError);
      void modify_source_flow (
         in Flow old_element,
         in Flow new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_source_flow (in Flow old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      CommentSet comment ()
         raises (Reflective::MofError);
      void set_comment (in CommentSet new_value)
         raises (Reflective::MofError);
      void unset_comment ()
         raises (Reflective::MofError);
      void add_comment (in Core::Comment new_element)
         raises (Reflective::MofError);
      void modify_comment (
         in Core::Comment old_element,
         in Core::Comment new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_comment (in Core::Comment old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      TemplateParameterUList template_parameter ()
         raises (Reflective::MofError);
      void set_template_parameter (in TemplateParameterUList new_value)
         raises (Reflective::MofError);
      void unset_template_parameter ()
         raises (Reflective::MofError);
      void add_template_parameter (in TemplateParameter new_element)
         raises (Reflective::MofError);
      void add_template_parameter_before (
         in TemplateParameter new_element,
         in TemplateParameter before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_template_parameter (
         in TemplateParameter old_element,
         in TemplateParameter new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_template_parameter (in TemplateParameter old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      StereotypeSet stereotype ()
         raises (Reflective::MofError);
      void set_stereotype (in StereotypeSet new_value)
         raises (Reflective::MofError);
      void unset_stereotype ()
         raises (Reflective::MofError);
      void add_stereotype (in Core::Stereotype new_element)
         raises (Reflective::MofError);
      void modify_stereotype (
         in Core::Stereotype old_element,
         in Core::Stereotype new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_stereotype (in Core::Stereotype old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      TaggedValueSet tagged_value ()
         raises (Reflective::MofError);
      void set_tagged_value (in TaggedValueSet new_value)
         raises (Reflective::MofError);
      void unset_tagged_value ()
         raises (Reflective::MofError);
      void add_tagged_value (in TaggedValue new_element)
         raises (Reflective::MofError);
      void modify_tagged_value (
         in TaggedValue old_element,
         in TaggedValue new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_tagged_value (in TaggedValue old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ModelElement

   interface GeneralizableElementClass : ModelElementClass
   {
      readonly attribute GeneralizableElementSet all_of_type_generalizable_element;
   };

   interface GeneralizableElement : GeneralizableElementClass, ModelElement
   {
      boolean is_root ()
         raises (Reflective::MofError);
      void set_is_root (in boolean new_value)
         raises (Reflective::MofError);
      boolean is_leaf ()
         raises (Reflective::MofError);
      void set_is_leaf (in boolean new_value)
         raises (Reflective::MofError);
      boolean is_abstract ()
         raises (Reflective::MofError);
      void set_is_abstract (in boolean new_value)
         raises (Reflective::MofError);
      GeneralizationSet generalization ()
         raises (Reflective::MofError);
      void set_generalization (in GeneralizationSet new_value)
         raises (Reflective::MofError);
      void unset_generalization ()
         raises (Reflective::MofError);
      void add_generalization (in Core::Generalization new_element)
         raises (Reflective::MofError);
      void modify_generalization (
         in Core::Generalization old_element,
         in Core::Generalization new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_generalization (in Core::Generalization old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface GeneralizableElement

   interface NamespaceClass : ModelElementClass
   {
      readonly attribute Core::NamespaceSet all_of_type_namespace;
   };

   interface Namespace : NamespaceClass, ModelElement
   {
      ModelElementSet owned_element ()
         raises (Reflective::MofError);
      void set_owned_element (in ModelElementSet new_value)
         raises (Reflective::MofError);
      void unset_owned_element ()
         raises (Reflective::MofError);
      void add_owned_element (in ModelElement new_element)
         raises (Reflective::MofError);
      void modify_owned_element (
         in ModelElement old_element,
         in ModelElement new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_owned_element (in ModelElement old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Namespace

   interface ClassifierClass : GeneralizableElementClass, Core::NamespaceClass
   {
      readonly attribute ClassifierSet all_of_type_classifier;
   };

   interface Classifier : ClassifierClass, GeneralizableElement, Core::Namespace
   {
      FeatureUList feature ()
         raises (Reflective::MofError);
      void set_feature (in FeatureUList new_value)
         raises (Reflective::MofError);
      void unset_feature ()
         raises (Reflective::MofError);
      void add_feature (in Core::Feature new_element)
         raises (Reflective::MofError);
      void add_feature_before (
         in Core::Feature new_element,
         in Core::Feature before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_feature (
         in Core::Feature old_element,
         in Core::Feature new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_feature (in Core::Feature old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      GeneralizationSet powertype_range ()
         raises (Reflective::MofError);
      void set_powertype_range (in GeneralizationSet new_value)
         raises (Reflective::MofError);
      void unset_powertype_range ()
         raises (Reflective::MofError);
      void add_powertype_range (in Core::Generalization new_element)
         raises (Reflective::MofError);
      void modify_powertype_range (
         in Core::Generalization old_element,
         in Core::Generalization new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_powertype_range (in Core::Generalization old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Classifier

   interface ClassClass : ClassifierClass
   {
      readonly attribute ClassSet all_of_type_class;
      readonly attribute ClassSet all_of_class_class;
      Class create_class (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_root,
         in boolean is_leaf,
         in boolean is_abstract,
         in boolean is_active)
         raises (Reflective::MofError);
   };

   interface Class : ClassClass, Classifier
   {
      boolean is_active ()
         raises (Reflective::MofError);
      void set_is_active (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface Class

   interface DataTypeClass : ClassifierClass
   {
      readonly attribute DataTypeSet all_of_type_data_type;
      readonly attribute DataTypeSet all_of_class_data_type;
      DataType create_data_type (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_root,
         in boolean is_leaf,
         in boolean is_abstract)
         raises (Reflective::MofError);
   };

   interface DataType : DataTypeClass, Classifier
   {
   }; // end of interface DataType

   interface FeatureClass : ModelElementClass
   {
      readonly attribute FeatureSet all_of_type_feature;
   };

   interface Feature : FeatureClass, ModelElement
   {
      DataTypes::ScopeKind owner_scope ()
         raises (Reflective::MofError);
      void set_owner_scope (in DataTypes::ScopeKind new_value)
         raises (Reflective::MofError);
      Classifier owner ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_owner (in Classifier new_value)
         raises (Reflective::MofError);
      void unset_owner ()
         raises (Reflective::MofError);
   }; // end of interface Feature

   interface StructuralFeatureClass : FeatureClass
   {
      readonly attribute StructuralFeatureSet all_of_type_structural_feature;
   };

   interface StructuralFeature : StructuralFeatureClass, Feature
   {
      DataTypes::Multiplicity multiplicity ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_multiplicity (in DataTypes::Multiplicity new_value)
         raises (Reflective::MofError);
      void unset_multiplicity ()
         raises (Reflective::MofError);
      DataTypes::ChangeableKind changeability ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_changeability (in DataTypes::ChangeableKind new_value)
         raises (Reflective::MofError);
      void unset_changeability ()
         raises (Reflective::MofError);
      DataTypes::ScopeKind target_scope ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_target_scope (in DataTypes::ScopeKind new_value)
         raises (Reflective::MofError);
      void unset_target_scope ()
         raises (Reflective::MofError);
      DataTypes::OrderingKind ordering ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_ordering (in DataTypes::OrderingKind new_value)
         raises (Reflective::MofError);
      void unset_ordering ()
         raises (Reflective::MofError);
      Classifier type ()
         raises (Reflective::MofError);
      void set_type (in Classifier new_value)
         raises (Reflective::MofError);
   }; // end of interface StructuralFeature

   interface AssociationEndClass : ModelElementClass
   {
      readonly attribute AssociationEndSet all_of_type_association_end;
      readonly attribute AssociationEndSet all_of_class_association_end;
      AssociationEnd create_association_end (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_navigable,
         in DataTypes::OrderingKind ordering,
         in DataTypes::AggregationKind aggregation,
         in DataTypes::ScopeKind target_scope,
         in DataTypes::Multiplicity multiplicity,
         in DataTypes::ChangeableKind changeability)
         raises (Reflective::MofError);
   };

   interface AssociationEnd : AssociationEndClass, ModelElement
   {
      boolean is_navigable ()
         raises (Reflective::MofError);
      void set_is_navigable (in boolean new_value)
         raises (Reflective::MofError);
      DataTypes::OrderingKind ordering ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_ordering (in DataTypes::OrderingKind new_value)
         raises (Reflective::MofError);
      void unset_ordering ()
         raises (Reflective::MofError);
      DataTypes::AggregationKind aggregation ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_aggregation (in DataTypes::AggregationKind new_value)
         raises (Reflective::MofError);
      void unset_aggregation ()
         raises (Reflective::MofError);
      DataTypes::ScopeKind target_scope ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_target_scope (in DataTypes::ScopeKind new_value)
         raises (Reflective::MofError);
      void unset_target_scope ()
         raises (Reflective::MofError);
      DataTypes::Multiplicity multiplicity ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_multiplicity (in DataTypes::Multiplicity new_value)
         raises (Reflective::MofError);
      void unset_multiplicity ()
         raises (Reflective::MofError);
      DataTypes::ChangeableKind changeability ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_changeability (in DataTypes::ChangeableKind new_value)
         raises (Reflective::MofError);
      void unset_changeability ()
         raises (Reflective::MofError);
      Core::Association association ()
         raises (Reflective::MofError);
      void set_association (in Core::Association new_value)
         raises (Reflective::MofError);
      UmlAttributeUList qualifier ()
         raises (Reflective::MofError);
      void set_qualifier (in UmlAttributeUList new_value)
         raises (Reflective::MofError);
      void unset_qualifier ()
         raises (Reflective::MofError);
      void add_qualifier (in UmlAttribute new_element)
         raises (Reflective::MofError);
      void add_qualifier_before (
         in UmlAttribute new_element,
         in UmlAttribute before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_qualifier (
         in UmlAttribute old_element,
         in UmlAttribute new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_qualifier (in UmlAttribute old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      Classifier participant ()
         raises (Reflective::MofError);
      void set_participant (in Classifier new_value)
         raises (Reflective::MofError);
      ClassifierSet specification ()
         raises (Reflective::MofError);
      void set_specification (in ClassifierSet new_value)
         raises (Reflective::MofError);
      void unset_specification ()
         raises (Reflective::MofError);
      void add_specification (in Classifier new_element)
         raises (Reflective::MofError);
      void modify_specification (
         in Classifier old_element,
         in Classifier new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_specification (in Classifier old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AssociationEnd

   interface UmlInterfaceClass : ClassifierClass
   {
      readonly attribute UmlInterfaceSet all_of_type_uml_interface;
      readonly attribute UmlInterfaceSet all_of_class_uml_interface;
      UmlInterface create_uml_interface (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_root,
         in boolean is_leaf,
         in boolean is_abstract)
         raises (Reflective::MofError);
   };

   interface UmlInterface : UmlInterfaceClass, Classifier
   {
   }; // end of interface UmlInterface

   interface UmlConstraintClass : ModelElementClass
   {
      readonly attribute UmlConstraintSet all_of_type_uml_constraint;
      readonly attribute UmlConstraintSet all_of_class_uml_constraint;
      UmlConstraint create_uml_constraint (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::BooleanExpression body)
         raises (Reflective::MofError);
   };

   interface UmlConstraint : UmlConstraintClass, ModelElement
   {
      DataTypes::BooleanExpression body ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_body (in DataTypes::BooleanExpression new_value)
         raises (Reflective::MofError);
      void unset_body ()
         raises (Reflective::MofError);
      ModelElementUList constrained_element ()
         raises (Reflective::MofError);
      void set_constrained_element (in ModelElementUList new_value)
         raises (Reflective::MofError);
      void unset_constrained_element ()
         raises (Reflective::MofError);
      void add_constrained_element (in ModelElement new_element)
         raises (Reflective::MofError);
      void add_constrained_element_before (
         in ModelElement new_element,
         in ModelElement before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_constrained_element (
         in ModelElement old_element,
         in ModelElement new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_constrained_element (in ModelElement old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface UmlConstraint

   interface RelationshipClass : ModelElementClass
   {
      readonly attribute RelationshipSet all_of_type_relationship;
   };

   interface Relationship : RelationshipClass, ModelElement
   {
   }; // end of interface Relationship

   interface AssociationClass : GeneralizableElementClass, RelationshipClass
   {
      readonly attribute AssociationSet all_of_type_association;
      readonly attribute AssociationSet all_of_class_association;
      Association create_association (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_root,
         in boolean is_leaf,
         in boolean is_abstract)
         raises (Reflective::MofError);
   };

   interface Association : AssociationClass, GeneralizableElement, Relationship
   {
      AssociationEndUList connection ()
         raises (Reflective::MofError);
      void set_connection (in AssociationEndUList new_value)
         raises (Reflective::MofError);
      void add_connection (in AssociationEnd new_element)
         raises (Reflective::MofError);
      void add_connection_before (
         in AssociationEnd new_element,
         in AssociationEnd before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_connection (
         in AssociationEnd old_element,
         in AssociationEnd new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_connection (in AssociationEnd old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Association

   interface UmlAttributeClass : StructuralFeatureClass
   {
      readonly attribute UmlAttributeSet all_of_type_uml_attribute;
      readonly attribute UmlAttributeSet all_of_class_uml_attribute;
      UmlAttribute create_uml_attribute (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::ScopeKind owner_scope,
         in DataTypes::Multiplicity multiplicity,
         in DataTypes::ChangeableKind changeability,
         in DataTypes::ScopeKind target_scope,
         in DataTypes::OrderingKind ordering,
         in DataTypes::Expression initial_value)
         raises (Reflective::MofError);
   };

   interface UmlAttribute : UmlAttributeClass, StructuralFeature
   {
      DataTypes::Expression initial_value ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_initial_value (in DataTypes::Expression new_value)
         raises (Reflective::MofError);
      void unset_initial_value ()
         raises (Reflective::MofError);
      AssociationEnd association_end ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_association_end (in AssociationEnd new_value)
         raises (Reflective::MofError);
      void unset_association_end ()
         raises (Reflective::MofError);
   }; // end of interface UmlAttribute

   interface BehavioralFeatureClass : FeatureClass
   {
      readonly attribute BehavioralFeatureSet all_of_type_behavioral_feature;
   };

   interface BehavioralFeature : BehavioralFeatureClass, Feature
   {
      boolean is_query ()
         raises (Reflective::MofError);
      void set_is_query (in boolean new_value)
         raises (Reflective::MofError);
      ParameterUList parameter ()
         raises (Reflective::MofError);
      void set_parameter (in ParameterUList new_value)
         raises (Reflective::MofError);
      void unset_parameter ()
         raises (Reflective::MofError);
      void add_parameter (in Core::Parameter new_element)
         raises (Reflective::MofError);
      void add_parameter_before (
         in Core::Parameter new_element,
         in Core::Parameter before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_parameter (
         in Core::Parameter old_element,
         in Core::Parameter new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_parameter (in Core::Parameter old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface BehavioralFeature

   interface OperationClass : BehavioralFeatureClass
   {
      readonly attribute OperationSet all_of_type_operation;
      readonly attribute OperationSet all_of_class_operation;
      Operation create_operation (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::ScopeKind owner_scope,
         in boolean is_query,
         in DataTypes::CallConcurrencyKind concurrency,
         in boolean is_root,
         in boolean is_leaf,
         in boolean is_abstract,
         in string specification)
         raises (Reflective::MofError);
   };

   interface Operation : OperationClass, BehavioralFeature
   {
      DataTypes::CallConcurrencyKind concurrency ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_concurrency (in DataTypes::CallConcurrencyKind new_value)
         raises (Reflective::MofError);
      void unset_concurrency ()
         raises (Reflective::MofError);
      boolean is_root ()
         raises (Reflective::MofError);
      void set_is_root (in boolean new_value)
         raises (Reflective::MofError);
      boolean is_leaf ()
         raises (Reflective::MofError);
      void set_is_leaf (in boolean new_value)
         raises (Reflective::MofError);
      boolean is_abstract ()
         raises (Reflective::MofError);
      void set_is_abstract (in boolean new_value)
         raises (Reflective::MofError);
      string specification ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_specification (in string new_value)
         raises (Reflective::MofError);
      void unset_specification ()
         raises (Reflective::MofError);
   }; // end of interface Operation

   interface ParameterClass : ModelElementClass
   {
      readonly attribute ParameterSet all_of_type_parameter;
      readonly attribute ParameterSet all_of_class_parameter;
      Parameter create_parameter (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::Expression default_value,
         in DataTypes::ParameterDirectionKind kind)
         raises (Reflective::MofError);
   };

   interface Parameter : ParameterClass, ModelElement
   {
      DataTypes::Expression default_value ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_default_value (in DataTypes::Expression new_value)
         raises (Reflective::MofError);
      void unset_default_value ()
         raises (Reflective::MofError);
      DataTypes::ParameterDirectionKind kind ()
         raises (Reflective::MofError);
      void set_kind (in DataTypes::ParameterDirectionKind new_value)
         raises (Reflective::MofError);
      BehavioralFeature behavioral_feature ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_behavioral_feature (in BehavioralFeature new_value)
         raises (Reflective::MofError);
      void unset_behavioral_feature ()
         raises (Reflective::MofError);
      Classifier type ()
         raises (Reflective::MofError);
      void set_type (in Classifier new_value)
         raises (Reflective::MofError);
   }; // end of interface Parameter

   interface MethodClass : BehavioralFeatureClass
   {
      readonly attribute MethodSet all_of_type_method;
      readonly attribute MethodSet all_of_class_method;
      Method create_method (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::ScopeKind owner_scope,
         in boolean is_query,
         in DataTypes::ProcedureExpression body)
         raises (Reflective::MofError);
   };

   interface Method : MethodClass, BehavioralFeature
   {
      DataTypes::ProcedureExpression body ()
         raises (Reflective::MofError);
      void set_body (in DataTypes::ProcedureExpression new_value)
         raises (Reflective::MofError);
      Operation specification ()
         raises (Reflective::MofError);
      void set_specification (in Operation new_value)
         raises (Reflective::MofError);
   }; // end of interface Method

   interface GeneralizationClass : RelationshipClass
   {
      readonly attribute GeneralizationSet all_of_type_generalization;
      readonly attribute GeneralizationSet all_of_class_generalization;
      Generalization create_generalization (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::Name discriminator)
         raises (Reflective::MofError);
   };

   interface Generalization : GeneralizationClass, Relationship
   {
      DataTypes::Name discriminator ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_discriminator (in DataTypes::Name new_value)
         raises (Reflective::MofError);
      void unset_discriminator ()
         raises (Reflective::MofError);
      GeneralizableElement child ()
         raises (Reflective::MofError);
      void set_child (in GeneralizableElement new_value)
         raises (Reflective::MofError);
      GeneralizableElement parent ()
         raises (Reflective::MofError);
      void set_parent (in GeneralizableElement new_value)
         raises (Reflective::MofError);
      Classifier powertype ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_powertype (in Classifier new_value)
         raises (Reflective::MofError);
      void unset_powertype ()
         raises (Reflective::MofError);
   }; // end of interface Generalization

   interface UmlAssociationClassClass : AssociationClass, ClassClass
   {
      readonly attribute UmlAssociationClassSet all_of_type_uml_association_class;
      readonly attribute UmlAssociationClassSet all_of_class_uml_association_class;
      UmlAssociationClass create_uml_association_class (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_root,
         in boolean is_leaf,
         in boolean is_abstract,
         in boolean is_active)
         raises (Reflective::MofError);
   };

   interface UmlAssociationClass : UmlAssociationClassClass, Association, Class
   {
   }; // end of interface UmlAssociationClass

   interface DependencyClass : RelationshipClass
   {
      readonly attribute DependencySet all_of_type_dependency;
      readonly attribute DependencySet all_of_class_dependency;
      Dependency create_dependency (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface Dependency : DependencyClass, Relationship
   {
      ModelElementSet client ()
         raises (Reflective::MofError);
      void set_client (in ModelElementSet new_value)
         raises (Reflective::MofError);
      void add_client (in ModelElement new_element)
         raises (Reflective::MofError);
      void modify_client (
         in ModelElement old_element,
         in ModelElement new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_client (in ModelElement old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ModelElementSet supplier ()
         raises (Reflective::MofError);
      void set_supplier (in ModelElementSet new_value)
         raises (Reflective::MofError);
      void add_supplier (in ModelElement new_element)
         raises (Reflective::MofError);
      void modify_supplier (
         in ModelElement old_element,
         in ModelElement new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_supplier (in ModelElement old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Dependency

   interface AbstractionClass : DependencyClass
   {
      readonly attribute AbstractionSet all_of_type_abstraction;
      readonly attribute AbstractionSet all_of_class_abstraction;
      Abstraction create_abstraction (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::MappingExpression mapping)
         raises (Reflective::MofError);
   };

   interface Abstraction : AbstractionClass, Dependency
   {
      DataTypes::MappingExpression mapping ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_mapping (in DataTypes::MappingExpression new_value)
         raises (Reflective::MofError);
      void unset_mapping ()
         raises (Reflective::MofError);
   }; // end of interface Abstraction

   interface PresentationElementClass : ElementClass
   {
      readonly attribute PresentationElementSet all_of_type_presentation_element;
   };

   interface PresentationElement : PresentationElementClass, Element
   {
      ModelElementSet subject ()
         raises (Reflective::MofError);
      void set_subject (in ModelElementSet new_value)
         raises (Reflective::MofError);
      void unset_subject ()
         raises (Reflective::MofError);
      void add_subject (in ModelElement new_element)
         raises (Reflective::MofError);
      void modify_subject (
         in ModelElement old_element,
         in ModelElement new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_subject (in ModelElement old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface PresentationElement

   interface UsageClass : DependencyClass
   {
      readonly attribute UsageSet all_of_type_usage;
      readonly attribute UsageSet all_of_class_usage;
      Usage create_usage (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface Usage : UsageClass, Dependency
   {
   }; // end of interface Usage

   interface BindingClass : DependencyClass
   {
      readonly attribute BindingSet all_of_type_binding;
      readonly attribute BindingSet all_of_class_binding;
      Binding create_binding (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface Binding : BindingClass, Dependency
   {
      TemplateArgumentUList argument ()
         raises (Reflective::MofError);
      void set_argument (in TemplateArgumentUList new_value)
         raises (Reflective::MofError);
      void add_argument (in TemplateArgument new_element)
         raises (Reflective::MofError);
      void add_argument_before (
         in TemplateArgument new_element,
         in TemplateArgument before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_argument (
         in TemplateArgument old_element,
         in TemplateArgument new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_argument (in TemplateArgument old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Binding

   interface ComponentClass : ClassifierClass
   {
      readonly attribute ComponentSet all_of_type_component;
      readonly attribute ComponentSet all_of_class_component;
      Component create_component (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_root,
         in boolean is_leaf,
         in boolean is_abstract)
         raises (Reflective::MofError);
   };

   interface Component : ComponentClass, Classifier
   {
      NodeSet deployment_location ()
         raises (Reflective::MofError);
      void set_deployment_location (in NodeSet new_value)
         raises (Reflective::MofError);
      void unset_deployment_location ()
         raises (Reflective::MofError);
      void add_deployment_location (in Node new_element)
         raises (Reflective::MofError);
      void modify_deployment_location (
         in Node old_element,
         in Node new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_deployment_location (in Node old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ElementResidenceSet resident_element ()
         raises (Reflective::MofError);
      void set_resident_element (in ElementResidenceSet new_value)
         raises (Reflective::MofError);
      void unset_resident_element ()
         raises (Reflective::MofError);
      void add_resident_element (in ElementResidence new_element)
         raises (Reflective::MofError);
      void modify_resident_element (
         in ElementResidence old_element,
         in ElementResidence new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_resident_element (in ElementResidence old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ArtifactSet implementation ()
         raises (Reflective::MofError);
      void set_implementation (in ArtifactSet new_value)
         raises (Reflective::MofError);
      void unset_implementation ()
         raises (Reflective::MofError);
      void add_implementation (in Artifact new_element)
         raises (Reflective::MofError);
      void modify_implementation (
         in Artifact old_element,
         in Artifact new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_implementation (in Artifact old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Component

   interface NodeClass : ClassifierClass
   {
      readonly attribute NodeSet all_of_type_node;
      readonly attribute NodeSet all_of_class_node;
      Node create_node (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_root,
         in boolean is_leaf,
         in boolean is_abstract)
         raises (Reflective::MofError);
   };

   interface Node : NodeClass, Classifier
   {
      ComponentSet deployed_component ()
         raises (Reflective::MofError);
      void set_deployed_component (in ComponentSet new_value)
         raises (Reflective::MofError);
      void unset_deployed_component ()
         raises (Reflective::MofError);
      void add_deployed_component (in Component new_element)
         raises (Reflective::MofError);
      void modify_deployed_component (
         in Component old_element,
         in Component new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_deployed_component (in Component old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Node

   interface PermissionClass : DependencyClass
   {
      readonly attribute PermissionSet all_of_type_permission;
      readonly attribute PermissionSet all_of_class_permission;
      Permission create_permission (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface Permission : PermissionClass, Dependency
   {
   }; // end of interface Permission

   interface CommentClass : ModelElementClass
   {
      readonly attribute Core::CommentSet all_of_type_comment;
      readonly attribute Core::CommentSet all_of_class_comment;
      Core::Comment create_comment (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in string body)
         raises (Reflective::MofError);
   };

   interface Comment : CommentClass, ModelElement
   {
      string body ()
         raises (Reflective::MofError);
      void set_body (in string new_value)
         raises (Reflective::MofError);
      ModelElementSet annotated_element ()
         raises (Reflective::MofError);
      void set_annotated_element (in ModelElementSet new_value)
         raises (Reflective::MofError);
      void unset_annotated_element ()
         raises (Reflective::MofError);
      void add_annotated_element (in ModelElement new_element)
         raises (Reflective::MofError);
      void modify_annotated_element (
         in ModelElement old_element,
         in ModelElement new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_annotated_element (in ModelElement old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Comment

   interface FlowClass : RelationshipClass
   {
      readonly attribute FlowSet all_of_type_flow;
      readonly attribute FlowSet all_of_class_flow;
      Flow create_flow (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface Flow : FlowClass, Relationship
   {
      ModelElementSet target ()
         raises (Reflective::MofError);
      void set_target (in ModelElementSet new_value)
         raises (Reflective::MofError);
      void unset_target ()
         raises (Reflective::MofError);
      void add_target (in ModelElement new_element)
         raises (Reflective::MofError);
      void modify_target (
         in ModelElement old_element,
         in ModelElement new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_target (in ModelElement old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ModelElementSet source ()
         raises (Reflective::MofError);
      void set_source (in ModelElementSet new_value)
         raises (Reflective::MofError);
      void unset_source ()
         raises (Reflective::MofError);
      void add_source (in ModelElement new_element)
         raises (Reflective::MofError);
      void modify_source (
         in ModelElement old_element,
         in ModelElement new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_source (in ModelElement old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Flow

   interface ElementResidenceClass : Reflective::RefObject
   {
      readonly attribute ElementResidenceSet all_of_type_element_residence;
      readonly attribute ElementResidenceSet all_of_class_element_residence;
      ElementResidence create_element_residence (
         in DataTypes::VisibilityKind visibility)
         raises (Reflective::MofError);
   };

   interface ElementResidence : ElementResidenceClass
   {
      DataTypes::VisibilityKind visibility ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_visibility (in DataTypes::VisibilityKind new_value)
         raises (Reflective::MofError);
      void unset_visibility ()
         raises (Reflective::MofError);
      ModelElement resident ()
         raises (Reflective::MofError);
      void set_resident (in ModelElement new_value)
         raises (Reflective::MofError);
      Component container ()
         raises (Reflective::MofError);
      void set_container (in Component new_value)
         raises (Reflective::MofError);
   }; // end of interface ElementResidence

   interface TemplateParameterClass : Reflective::RefObject
   {
      readonly attribute TemplateParameterSet all_of_type_template_parameter;
      readonly attribute TemplateParameterSet all_of_class_template_parameter;
      TemplateParameter create_template_parameter ()
         raises (Reflective::MofError);
   };

   interface TemplateParameter : TemplateParameterClass
   {
      ModelElement template ()
         raises (Reflective::MofError);
      void set_template (in ModelElement new_value)
         raises (Reflective::MofError);
      ModelElement parameter ()
         raises (Reflective::MofError);
      void set_parameter (in ModelElement new_value)
         raises (Reflective::MofError);
      ModelElement default_element ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_default_element (in ModelElement new_value)
         raises (Reflective::MofError);
      void unset_default_element ()
         raises (Reflective::MofError);
   }; // end of interface TemplateParameter

   interface PrimitiveClass : DataTypeClass
   {
      readonly attribute PrimitiveSet all_of_type_primitive;
      readonly attribute PrimitiveSet all_of_class_primitive;
      Primitive create_primitive (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_root,
         in boolean is_leaf,
         in boolean is_abstract)
         raises (Reflective::MofError);
   };

   interface Primitive : PrimitiveClass, DataType
   {
   }; // end of interface Primitive

   interface EnumerationClass : DataTypeClass
   {
      readonly attribute EnumerationSet all_of_type_enumeration;
      readonly attribute EnumerationSet all_of_class_enumeration;
      Enumeration create_enumeration (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_root,
         in boolean is_leaf,
         in boolean is_abstract)
         raises (Reflective::MofError);
   };

   interface Enumeration : EnumerationClass, DataType
   {
      EnumerationLiteralUList literal ()
         raises (Reflective::MofError);
      void set_literal (in EnumerationLiteralUList new_value)
         raises (Reflective::MofError);
      void add_literal (in EnumerationLiteral new_element)
         raises (Reflective::MofError);
      void add_literal_before (
         in EnumerationLiteral new_element,
         in EnumerationLiteral before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_literal (
         in EnumerationLiteral old_element,
         in EnumerationLiteral new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_literal (in EnumerationLiteral old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Enumeration

   interface EnumerationLiteralClass : ModelElementClass
   {
      readonly attribute EnumerationLiteralSet all_of_type_enumeration_literal;
      readonly attribute EnumerationLiteralSet all_of_class_enumeration_literal;
      EnumerationLiteral create_enumeration_literal (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface EnumerationLiteral : EnumerationLiteralClass, ModelElement
   {
      Core::Enumeration enumeration ()
         raises (Reflective::MofError);
      void set_enumeration (in Core::Enumeration new_value)
         raises (Reflective::MofError);
   }; // end of interface EnumerationLiteral

   interface StereotypeClass : GeneralizableElementClass
   {
      readonly attribute Core::StereotypeSet all_of_type_stereotype;
      readonly attribute Core::StereotypeSet all_of_class_stereotype;
      Core::Stereotype create_stereotype (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_root,
         in boolean is_leaf,
         in boolean is_abstract,
         in DataTypes::Geometry icon,
         in DataTypes::NameSet base_class)         // DataTypes:: added by hand
         raises (Reflective::MofError);
   };

   interface Stereotype : StereotypeClass, GeneralizableElement
   {
      DataTypes::Geometry icon ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_icon (in DataTypes::Geometry new_value)
         raises (Reflective::MofError);
      void unset_icon ()
         raises (Reflective::MofError);
      DataTypes::NameSet base_class ()          // DataTypes:: added by hand
         raises (Reflective::MofError);
      void set_base_class (in DataTypes::NameSet new_value)    // DataTypes:: added by hand
         raises (Reflective::MofError);
      void add_base_class (in DataTypes::Name new_element)
         raises (Reflective::MofError);
      void modify_base_class (
         in DataTypes::Name old_element,
         in DataTypes::Name new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_base_class (in DataTypes::Name old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      TagDefinitionSet defined_tag ()
         raises (Reflective::MofError);
      void set_defined_tag (in TagDefinitionSet new_value)
         raises (Reflective::MofError);
      void unset_defined_tag ()
         raises (Reflective::MofError);
      void add_defined_tag (in TagDefinition new_element)
         raises (Reflective::MofError);
      void modify_defined_tag (
         in TagDefinition old_element,
         in TagDefinition new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_defined_tag (in TagDefinition old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      UmlConstraintSet stereotype_constraint ()
         raises (Reflective::MofError);
      void set_stereotype_constraint (in UmlConstraintSet new_value)
         raises (Reflective::MofError);
      void unset_stereotype_constraint ()
         raises (Reflective::MofError);
      void add_stereotype_constraint (in UmlConstraint new_element)
         raises (Reflective::MofError);
      void modify_stereotype_constraint (
         in UmlConstraint old_element,
         in UmlConstraint new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_stereotype_constraint (in UmlConstraint old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Stereotype

   interface TagDefinitionClass : ModelElementClass
   {
      readonly attribute TagDefinitionSet all_of_type_tag_definition;
      readonly attribute TagDefinitionSet all_of_class_tag_definition;
      TagDefinition create_tag_definition (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::Name tag_type,
         in DataTypes::Multiplicity multiplicity)
         raises (Reflective::MofError);
   };

   interface TagDefinition : TagDefinitionClass, ModelElement
   {
      DataTypes::Name tag_type ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_tag_type (in DataTypes::Name new_value)
         raises (Reflective::MofError);
      void unset_tag_type ()
         raises (Reflective::MofError);
      DataTypes::Multiplicity multiplicity ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_multiplicity (in DataTypes::Multiplicity new_value)
         raises (Reflective::MofError);
      void unset_multiplicity ()
         raises (Reflective::MofError);
      Core::Stereotype owner ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_owner (in Core::Stereotype new_value)
         raises (Reflective::MofError);
      void unset_owner ()
         raises (Reflective::MofError);
   }; // end of interface TagDefinition

   interface TaggedValueClass : ModelElementClass
   {
      readonly attribute TaggedValueSet all_of_type_tagged_value;
      readonly attribute TaggedValueSet all_of_class_tagged_value;
      TaggedValue create_tagged_value (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in StringSet data_value)
         raises (Reflective::MofError);
   };

   interface TaggedValue : TaggedValueClass, ModelElement
   {
      StringSet data_value ()
         raises (Reflective::MofError);
      void set_data_value (in StringSet new_value)
         raises (Reflective::MofError);
      void unset_data_value ()
         raises (Reflective::MofError);
      void add_data_value (in string new_element)
         raises (Reflective::MofError);
      void modify_data_value (
         in string old_element,
         in string new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_data_value (in string old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ModelElement model_element ()
         raises (Reflective::MofError);
      void set_model_element (in ModelElement new_value)
         raises (Reflective::MofError);
      TagDefinition type ()
         raises (Reflective::MofError);
      void set_type (in TagDefinition new_value)
         raises (Reflective::MofError);
      ModelElementSet reference_value ()
         raises (Reflective::MofError);
      void set_reference_value (in ModelElementSet new_value)
         raises (Reflective::MofError);
      void unset_reference_value ()
         raises (Reflective::MofError);
      void add_reference_value (in ModelElement new_element)
         raises (Reflective::MofError);
      void modify_reference_value (
         in ModelElement old_element,
         in ModelElement new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_reference_value (in ModelElement old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface TaggedValue

   interface ProgrammingLanguageDataTypeClass : DataTypeClass
   {
      readonly attribute ProgrammingLanguageDataTypeSet all_of_type_programming_language_data_type;
      readonly attribute ProgrammingLanguageDataTypeSet all_of_class_programming_language_data_type;
      ProgrammingLanguageDataType create_programming_language_data_type (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_root,
         in boolean is_leaf,
         in boolean is_abstract,
         in DataTypes::TypeExpression expression)
         raises (Reflective::MofError);
   };

   interface ProgrammingLanguageDataType : ProgrammingLanguageDataTypeClass, DataType
   {
      DataTypes::TypeExpression expression ()
         raises (Reflective::MofError);
      void set_expression (in DataTypes::TypeExpression new_value)
         raises (Reflective::MofError);
   }; // end of interface ProgrammingLanguageDataType

   interface ArtifactClass : ClassifierClass
   {
      readonly attribute ArtifactSet all_of_type_artifact;
      readonly attribute ArtifactSet all_of_class_artifact;
      Artifact create_artifact (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_root,
         in boolean is_leaf,
         in boolean is_abstract)
         raises (Reflective::MofError);
   };

   interface Artifact : ArtifactClass, Classifier
   {
   }; // end of interface Artifact

   interface TemplateArgumentClass : Reflective::RefObject
   {
      readonly attribute TemplateArgumentSet all_of_type_template_argument;
      readonly attribute TemplateArgumentSet all_of_class_template_argument;
      TemplateArgument create_template_argument ()
         raises (Reflective::MofError);
   };

   interface TemplateArgument : TemplateArgumentClass
   {
      ModelElement model_element ()
         raises (Reflective::MofError);
      void set_model_element (in ModelElement new_value)
         raises (Reflective::MofError);
      Core::Binding binding ()
         raises (Reflective::MofError);
      void set_binding (in Core::Binding new_value)
         raises (Reflective::MofError);
   }; // end of interface TemplateArgument

   struct AAssociationConnectionLink
   {
      Core::Association association;
      AssociationEnd connection;
   };
   typedef sequence<AAssociationConnectionLink> AAssociationConnectionLinkSet;

   interface AAssociationConnection : Reflective::RefAssociation
   {
      AAssociationConnectionLinkSet all_a_association_connection_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Association association,
         in AssociationEnd connection)
         raises (Reflective::MofError);
      Core::Association association (in AssociationEnd connection)
         raises (Reflective::MofError);
      AssociationEndUList connection (in Core::Association association)
         raises (Reflective::MofError);
      void add (
         in Core::Association association,
         in AssociationEnd connection)
         raises (Reflective::MofError);
      void add_before_connection (
         in Core::Association association,
         in AssociationEnd connection,
         in AssociationEnd before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_association (
         in Core::Association association,
         in AssociationEnd connection,
         in Core::Association new_association)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_connection (
         in Core::Association association,
         in AssociationEnd connection,
         in AssociationEnd new_connection)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Association association,
         in AssociationEnd connection)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AAssociationConnection

   struct AOwnerFeatureLink
   {
      Classifier owner;
      Core::Feature feature;
   };
   typedef sequence<AOwnerFeatureLink> AOwnerFeatureLinkSet;

   interface AOwnerFeature : Reflective::RefAssociation
   {
      AOwnerFeatureLinkSet all_a_owner_feature_links()
         raises (Reflective::MofError);
      boolean exists (
         in Classifier owner,
         in Core::Feature feature)
         raises (Reflective::MofError);
      Classifier owner (in Core::Feature feature)
         raises (Reflective::MofError);
      FeatureUList feature (in Classifier owner)
         raises (Reflective::MofError);
      void add (
         in Classifier owner,
         in Core::Feature feature)
         raises (Reflective::MofError);
      void add_before_feature (
         in Classifier owner,
         in Core::Feature feature,
         in Core::Feature before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_owner (
         in Classifier owner,
         in Core::Feature feature,
         in Classifier new_owner)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_feature (
         in Classifier owner,
         in Core::Feature feature,
         in Core::Feature new_feature)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Classifier owner,
         in Core::Feature feature)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AOwnerFeature

   struct ASpecificationMethodLink
   {
      Operation specification;
      Core::Method method;
   };
   typedef sequence<ASpecificationMethodLink> ASpecificationMethodLinkSet;

   interface ASpecificationMethod : Reflective::RefAssociation
   {
      ASpecificationMethodLinkSet all_a_specification_method_links()
         raises (Reflective::MofError);
      boolean exists (
         in Operation specification,
         in Core::Method method)
         raises (Reflective::MofError);
      Operation specification (in Core::Method method)
         raises (Reflective::MofError);
      MethodSet method (in Operation specification)
         raises (Reflective::MofError);
      void add (
         in Operation specification,
         in Core::Method method)
         raises (Reflective::MofError);
      void modify_specification (
         in Operation specification,
         in Core::Method method,
         in Operation new_specification)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_method (
         in Operation specification,
         in Core::Method method,
         in Core::Method new_method)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Operation specification,
         in Core::Method method)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASpecificationMethod

   struct ATypedFeatureTypeLink
   {
      StructuralFeature typed_feature;
      Classifier type;
   };
   typedef sequence<ATypedFeatureTypeLink> ATypedFeatureTypeLinkSet;

   interface ATypedFeatureType : Reflective::RefAssociation
   {
      ATypedFeatureTypeLinkSet all_a_typed_feature_type_links()
         raises (Reflective::MofError);
      boolean exists (
         in StructuralFeature typed_feature,
         in Classifier type)
         raises (Reflective::MofError);
      StructuralFeatureSet typed_feature (in Classifier type)
         raises (Reflective::MofError);
      Classifier type (in StructuralFeature typed_feature)
         raises (Reflective::MofError);
      void add (
         in StructuralFeature typed_feature,
         in Classifier type)
         raises (Reflective::MofError);
      void modify_typed_feature (
         in StructuralFeature typed_feature,
         in Classifier type,
         in StructuralFeature new_typed_feature)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_type (
         in StructuralFeature typed_feature,
         in Classifier type,
         in Classifier new_type)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in StructuralFeature typed_feature,
         in Classifier type)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ATypedFeatureType

   struct ANamespaceOwnedElementLink
   {
      Core::Namespace namespace;
      ModelElement owned_element;
   };
   typedef sequence<ANamespaceOwnedElementLink> ANamespaceOwnedElementLinkSet;

   interface ANamespaceOwnedElement : Reflective::RefAssociation
   {
      ANamespaceOwnedElementLinkSet all_a_namespace_owned_element_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Namespace namespace,
         in ModelElement owned_element)
         raises (Reflective::MofError);
      Core::Namespace namespace (in ModelElement owned_element)
         raises (Reflective::MofError);
      ModelElementSet owned_element (in Core::Namespace namespace)
         raises (Reflective::MofError);
      void add (
         in Core::Namespace namespace,
         in ModelElement owned_element)
         raises (Reflective::MofError);
      void modify_namespace (
         in Core::Namespace namespace,
         in ModelElement owned_element,
         in Core::Namespace new_namespace)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_owned_element (
         in Core::Namespace namespace,
         in ModelElement owned_element,
         in ModelElement new_owned_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Namespace namespace,
         in ModelElement owned_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ANamespaceOwnedElement

   struct ABehavioralFeatureParameterLink
   {
      BehavioralFeature behavioral_feature;
      Core::Parameter parameter;
   };
   typedef sequence<ABehavioralFeatureParameterLink> ABehavioralFeatureParameterLinkSet;

   interface ABehavioralFeatureParameter : Reflective::RefAssociation
   {
      ABehavioralFeatureParameterLinkSet all_a_behavioral_feature_parameter_links()
         raises (Reflective::MofError);
      boolean exists (
         in BehavioralFeature behavioral_feature,
         in Core::Parameter parameter)
         raises (Reflective::MofError);
      BehavioralFeature behavioral_feature (in Core::Parameter parameter)
         raises (Reflective::MofError);
      ParameterUList parameter (in BehavioralFeature behavioral_feature)
         raises (Reflective::MofError);
      void add (
         in BehavioralFeature behavioral_feature,
         in Core::Parameter parameter)
         raises (Reflective::MofError);
      void add_before_parameter (
         in BehavioralFeature behavioral_feature,
         in Core::Parameter parameter,
         in Core::Parameter before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_behavioral_feature (
         in BehavioralFeature behavioral_feature,
         in Core::Parameter parameter,
         in BehavioralFeature new_behavioral_feature)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_parameter (
         in BehavioralFeature behavioral_feature,
         in Core::Parameter parameter,
         in Core::Parameter new_parameter)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in BehavioralFeature behavioral_feature,
         in Core::Parameter parameter)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ABehavioralFeatureParameter

   struct ATypedParameterTypeLink
   {
      Parameter typed_parameter;
      Classifier type;
   };
   typedef sequence<ATypedParameterTypeLink> ATypedParameterTypeLinkSet;

   interface ATypedParameterType : Reflective::RefAssociation
   {
      ATypedParameterTypeLinkSet all_a_typed_parameter_type_links()
         raises (Reflective::MofError);
      boolean exists (
         in Parameter typed_parameter,
         in Classifier type)
         raises (Reflective::MofError);
      ParameterSet typed_parameter (in Classifier type)
         raises (Reflective::MofError);
      Classifier type (in Parameter typed_parameter)
         raises (Reflective::MofError);
      void add (
         in Parameter typed_parameter,
         in Classifier type)
         raises (Reflective::MofError);
      void modify_typed_parameter (
         in Parameter typed_parameter,
         in Classifier type,
         in Parameter new_typed_parameter)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_type (
         in Parameter typed_parameter,
         in Classifier type,
         in Classifier new_type)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Parameter typed_parameter,
         in Classifier type)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ATypedParameterType

   struct AChildGeneralizationLink
   {
      GeneralizableElement child;
      Core::Generalization generalization;
   };
   typedef sequence<AChildGeneralizationLink> AChildGeneralizationLinkSet;

   interface AChildGeneralization : Reflective::RefAssociation
   {
      AChildGeneralizationLinkSet all_a_child_generalization_links()
         raises (Reflective::MofError);
      boolean exists (
         in GeneralizableElement child,
         in Core::Generalization generalization)
         raises (Reflective::MofError);
      GeneralizableElement child (in Core::Generalization generalization)
         raises (Reflective::MofError);
      GeneralizationSet generalization (in GeneralizableElement child)
         raises (Reflective::MofError);
      void add (
         in GeneralizableElement child,
         in Core::Generalization generalization)
         raises (Reflective::MofError);
      void modify_child (
         in GeneralizableElement child,
         in Core::Generalization generalization,
         in GeneralizableElement new_child)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_generalization (
         in GeneralizableElement child,
         in Core::Generalization generalization,
         in Core::Generalization new_generalization)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in GeneralizableElement child,
         in Core::Generalization generalization)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AChildGeneralization

   struct AParentSpecializationLink
   {
      GeneralizableElement parent;
      Generalization specialization;
   };
   typedef sequence<AParentSpecializationLink> AParentSpecializationLinkSet;

   interface AParentSpecialization : Reflective::RefAssociation
   {
      AParentSpecializationLinkSet all_a_parent_specialization_links()
         raises (Reflective::MofError);
      boolean exists (
         in GeneralizableElement parent,
         in Generalization specialization)
         raises (Reflective::MofError);
      GeneralizableElement parent (in Generalization specialization)
         raises (Reflective::MofError);
      GeneralizationSet specialization (in GeneralizableElement parent)
         raises (Reflective::MofError);
      void add (
         in GeneralizableElement parent,
         in Generalization specialization)
         raises (Reflective::MofError);
      void modify_parent (
         in GeneralizableElement parent,
         in Generalization specialization,
         in GeneralizableElement new_parent)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_specialization (
         in GeneralizableElement parent,
         in Generalization specialization,
         in Generalization new_specialization)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in GeneralizableElement parent,
         in Generalization specialization)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AParentSpecialization

   struct AQualifierAssociationEndLink
   {
      UmlAttribute qualifier;
      AssociationEnd association_end;
   };
   typedef sequence<AQualifierAssociationEndLink> AQualifierAssociationEndLinkSet;

   interface AQualifierAssociationEnd : Reflective::RefAssociation
   {
      AQualifierAssociationEndLinkSet all_a_qualifier_association_end_links()
         raises (Reflective::MofError);
      boolean exists (
         in UmlAttribute qualifier,
         in AssociationEnd association_end)
         raises (Reflective::MofError);
      UmlAttributeUList qualifier (in AssociationEnd association_end)
         raises (Reflective::MofError);
      AssociationEnd association_end (in UmlAttribute qualifier)
         raises (Reflective::MofError);
      void add (
         in UmlAttribute qualifier,
         in AssociationEnd association_end)
         raises (Reflective::MofError);
      void add_before_qualifier (
         in UmlAttribute qualifier,
         in AssociationEnd association_end,
         in UmlAttribute before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_qualifier (
         in UmlAttribute qualifier,
         in AssociationEnd association_end,
         in UmlAttribute new_qualifier)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_association_end (
         in UmlAttribute qualifier,
         in AssociationEnd association_end,
         in AssociationEnd new_association_end)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in UmlAttribute qualifier,
         in AssociationEnd association_end)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AQualifierAssociationEnd

   struct AParticipantAssociationLink
   {
      Classifier participant;
      AssociationEnd association;
   };
   typedef sequence<AParticipantAssociationLink> AParticipantAssociationLinkSet;

   interface AParticipantAssociation : Reflective::RefAssociation
   {
      AParticipantAssociationLinkSet all_a_participant_association_links()
         raises (Reflective::MofError);
      boolean exists (
         in Classifier participant,
         in AssociationEnd association)
         raises (Reflective::MofError);
      Classifier participant (in AssociationEnd association)
         raises (Reflective::MofError);
      AssociationEndSet association (in Classifier participant)
         raises (Reflective::MofError);
      void add (
         in Classifier participant,
         in AssociationEnd association)
         raises (Reflective::MofError);
      void modify_participant (
         in Classifier participant,
         in AssociationEnd association,
         in Classifier new_participant)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_association (
         in Classifier participant,
         in AssociationEnd association,
         in AssociationEnd new_association)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Classifier participant,
         in AssociationEnd association)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AParticipantAssociation

   struct ASpecifiedEndSpecificationLink
   {
      AssociationEnd specified_end;
      Classifier specification;
   };
   typedef sequence<ASpecifiedEndSpecificationLink> ASpecifiedEndSpecificationLinkSet;

   interface ASpecifiedEndSpecification : Reflective::RefAssociation
   {
      ASpecifiedEndSpecificationLinkSet all_a_specified_end_specification_links()
         raises (Reflective::MofError);
      boolean exists (
         in AssociationEnd specified_end,
         in Classifier specification)
         raises (Reflective::MofError);
      AssociationEndSet specified_end (in Classifier specification)
         raises (Reflective::MofError);
      ClassifierSet specification (in AssociationEnd specified_end)
         raises (Reflective::MofError);
      void add (
         in AssociationEnd specified_end,
         in Classifier specification)
         raises (Reflective::MofError);
      void modify_specified_end (
         in AssociationEnd specified_end,
         in Classifier specification,
         in AssociationEnd new_specified_end)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_specification (
         in AssociationEnd specified_end,
         in Classifier specification,
         in Classifier new_specification)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in AssociationEnd specified_end,
         in Classifier specification)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASpecifiedEndSpecification

   struct AClientClientDependencyLink
   {
      ModelElement client;
      Dependency client_dependency;
   };
   typedef sequence<AClientClientDependencyLink> AClientClientDependencyLinkSet;

   interface AClientClientDependency : Reflective::RefAssociation
   {
      AClientClientDependencyLinkSet all_a_client_client_dependency_links()
         raises (Reflective::MofError);
      boolean exists (
         in ModelElement client,
         in Dependency client_dependency)
         raises (Reflective::MofError);
      ModelElementSet client (in Dependency client_dependency)
         raises (Reflective::MofError);
      DependencySet client_dependency (in ModelElement client)
         raises (Reflective::MofError);
      void add (
         in ModelElement client,
         in Dependency client_dependency)
         raises (Reflective::MofError);
      void modify_client (
         in ModelElement client,
         in Dependency client_dependency,
         in ModelElement new_client)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_client_dependency (
         in ModelElement client,
         in Dependency client_dependency,
         in Dependency new_client_dependency)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ModelElement client,
         in Dependency client_dependency)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AClientClientDependency

   struct AConstrainedElementConstraintLink
   {
      ModelElement constrained_element;
      UmlConstraint uml_constraint;
   };
   typedef sequence<AConstrainedElementConstraintLink> AConstrainedElementConstraintLinkSet;

   interface AConstrainedElementConstraint : Reflective::RefAssociation
   {
      AConstrainedElementConstraintLinkSet all_a_constrained_element_constraint_links()
         raises (Reflective::MofError);
      boolean exists (
         in ModelElement constrained_element,
         in UmlConstraint uml_constraint)
         raises (Reflective::MofError);
      ModelElementUList constrained_element (in UmlConstraint uml_constraint)
         raises (Reflective::MofError);
      UmlConstraintSet uml_constraint (in ModelElement constrained_element)
         raises (Reflective::MofError);
      void add (
         in ModelElement constrained_element,
         in UmlConstraint uml_constraint)
         raises (Reflective::MofError);
      void add_before_constrained_element (
         in ModelElement constrained_element,
         in UmlConstraint uml_constraint,
         in ModelElement before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_constrained_element (
         in ModelElement constrained_element,
         in UmlConstraint uml_constraint,
         in ModelElement new_constrained_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_uml_constraint (
         in ModelElement constrained_element,
         in UmlConstraint uml_constraint,
         in UmlConstraint new_uml_constraint)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ModelElement constrained_element,
         in UmlConstraint uml_constraint)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AConstrainedElementConstraint

   struct ASupplierSupplierDependencyLink
   {
      ModelElement supplier;
      Dependency supplier_dependency;
   };
   typedef sequence<ASupplierSupplierDependencyLink> ASupplierSupplierDependencyLinkSet;

   interface ASupplierSupplierDependency : Reflective::RefAssociation
   {
      ASupplierSupplierDependencyLinkSet all_a_supplier_supplier_dependency_links()
         raises (Reflective::MofError);
      boolean exists (
         in ModelElement supplier,
         in Dependency supplier_dependency)
         raises (Reflective::MofError);
      ModelElementSet supplier (in Dependency supplier_dependency)
         raises (Reflective::MofError);
      DependencySet supplier_dependency (in ModelElement supplier)
         raises (Reflective::MofError);
      void add (
         in ModelElement supplier,
         in Dependency supplier_dependency)
         raises (Reflective::MofError);
      void modify_supplier (
         in ModelElement supplier,
         in Dependency supplier_dependency,
         in ModelElement new_supplier)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_supplier_dependency (
         in ModelElement supplier,
         in Dependency supplier_dependency,
         in Dependency new_supplier_dependency)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ModelElement supplier,
         in Dependency supplier_dependency)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASupplierSupplierDependency

   struct APresentationSubjectLink
   {
      PresentationElement presentation;
      ModelElement subject;
   };
   typedef sequence<APresentationSubjectLink> APresentationSubjectLinkSet;

   interface APresentationSubject : Reflective::RefAssociation
   {
      APresentationSubjectLinkSet all_a_presentation_subject_links()
         raises (Reflective::MofError);
      boolean exists (
         in PresentationElement presentation,
         in ModelElement subject)
         raises (Reflective::MofError);
      PresentationElementSet presentation (in ModelElement subject)
         raises (Reflective::MofError);
      ModelElementSet subject (in PresentationElement presentation)
         raises (Reflective::MofError);
      void add (
         in PresentationElement presentation,
         in ModelElement subject)
         raises (Reflective::MofError);
      void modify_presentation (
         in PresentationElement presentation,
         in ModelElement subject,
         in PresentationElement new_presentation)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_subject (
         in PresentationElement presentation,
         in ModelElement subject,
         in ModelElement new_subject)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in PresentationElement presentation,
         in ModelElement subject)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface APresentationSubject

   struct ADeploymentLocationDeployedComponentLink
   {
      Node deployment_location;
      Component deployed_component;
   };
   typedef sequence<ADeploymentLocationDeployedComponentLink> ADeploymentLocationDeployedComponentLinkSet;

   interface ADeploymentLocationDeployedComponent : Reflective::RefAssociation
   {
      ADeploymentLocationDeployedComponentLinkSet all_a_deployment_location_deployed_component_links()
         raises (Reflective::MofError);
      boolean exists (
         in Node deployment_location,
         in Component deployed_component)
         raises (Reflective::MofError);
      NodeSet deployment_location (in Component deployed_component)
         raises (Reflective::MofError);
      ComponentSet deployed_component (in Node deployment_location)
         raises (Reflective::MofError);
      void add (
         in Node deployment_location,
         in Component deployed_component)
         raises (Reflective::MofError);
      void modify_deployment_location (
         in Node deployment_location,
         in Component deployed_component,
         in Node new_deployment_location)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_deployed_component (
         in Node deployment_location,
         in Component deployed_component,
         in Component new_deployed_component)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Node deployment_location,
         in Component deployed_component)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ADeploymentLocationDeployedComponent

   struct ATargetFlowTargetLink
   {
      Flow target_flow;
      ModelElement target;
   };
   typedef sequence<ATargetFlowTargetLink> ATargetFlowTargetLinkSet;

   interface ATargetFlowTarget : Reflective::RefAssociation
   {
      ATargetFlowTargetLinkSet all_a_target_flow_target_links()
         raises (Reflective::MofError);
      boolean exists (
         in Flow target_flow,
         in ModelElement target)
         raises (Reflective::MofError);
      FlowSet target_flow (in ModelElement target)
         raises (Reflective::MofError);
      ModelElementSet target (in Flow target_flow)
         raises (Reflective::MofError);
      void add (
         in Flow target_flow,
         in ModelElement target)
         raises (Reflective::MofError);
      void modify_target_flow (
         in Flow target_flow,
         in ModelElement target,
         in Flow new_target_flow)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_target (
         in Flow target_flow,
         in ModelElement target,
         in ModelElement new_target)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Flow target_flow,
         in ModelElement target)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ATargetFlowTarget

   struct ASourceFlowSourceLink
   {
      Flow source_flow;
      ModelElement source;
   };
   typedef sequence<ASourceFlowSourceLink> ASourceFlowSourceLinkSet;

   interface ASourceFlowSource : Reflective::RefAssociation
   {
      ASourceFlowSourceLinkSet all_a_source_flow_source_links()
         raises (Reflective::MofError);
      boolean exists (
         in Flow source_flow,
         in ModelElement source)
         raises (Reflective::MofError);
      FlowSet source_flow (in ModelElement source)
         raises (Reflective::MofError);
      ModelElementSet source (in Flow source_flow)
         raises (Reflective::MofError);
      void add (
         in Flow source_flow,
         in ModelElement source)
         raises (Reflective::MofError);
      void modify_source_flow (
         in Flow source_flow,
         in ModelElement source,
         in Flow new_source_flow)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_source (
         in Flow source_flow,
         in ModelElement source,
         in ModelElement new_source)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Flow source_flow,
         in ModelElement source)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASourceFlowSource

   struct ADefaultElementDefaultedParameterLink
   {
      ModelElement default_element;
      TemplateParameter defaulted_parameter;
   };
   typedef sequence<ADefaultElementDefaultedParameterLink> ADefaultElementDefaultedParameterLinkSet;

   interface ADefaultElementDefaultedParameter : Reflective::RefAssociation
   {
      ADefaultElementDefaultedParameterLinkSet all_a_default_element_defaulted_parameter_links()
         raises (Reflective::MofError);
      boolean exists (
         in ModelElement default_element,
         in TemplateParameter defaulted_parameter)
         raises (Reflective::MofError);
      ModelElement default_element (in TemplateParameter defaulted_parameter)
         raises (Reflective::MofError);
      TemplateParameterSet defaulted_parameter (in ModelElement default_element)
         raises (Reflective::MofError);
      void add (
         in ModelElement default_element,
         in TemplateParameter defaulted_parameter)
         raises (Reflective::MofError);
      void modify_default_element (
         in ModelElement default_element,
         in TemplateParameter defaulted_parameter,
         in ModelElement new_default_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_defaulted_parameter (
         in ModelElement default_element,
         in TemplateParameter defaulted_parameter,
         in TemplateParameter new_defaulted_parameter)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ModelElement default_element,
         in TemplateParameter defaulted_parameter)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ADefaultElementDefaultedParameter

   struct ABindingArgumentLink
   {
      Core::Binding binding;
      TemplateArgument argument;
   };
   typedef sequence<ABindingArgumentLink> ABindingArgumentLinkSet;

   interface ABindingArgument : Reflective::RefAssociation
   {
      ABindingArgumentLinkSet all_a_binding_argument_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Binding binding,
         in TemplateArgument argument)
         raises (Reflective::MofError);
      Core::Binding binding (in TemplateArgument argument)
         raises (Reflective::MofError);
      TemplateArgumentUList argument (in Core::Binding binding)
         raises (Reflective::MofError);
      void add (
         in Core::Binding binding,
         in TemplateArgument argument)
         raises (Reflective::MofError);
      void add_before_argument (
         in Core::Binding binding,
         in TemplateArgument argument,
         in TemplateArgument before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_binding (
         in Core::Binding binding,
         in TemplateArgument argument,
         in Core::Binding new_binding)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_argument (
         in Core::Binding binding,
         in TemplateArgument argument,
         in TemplateArgument new_argument)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Binding binding,
         in TemplateArgument argument)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ABindingArgument

   struct APowertypePowertypeRangeLink
   {
      Classifier powertype;
      Generalization powertype_range;
   };
   typedef sequence<APowertypePowertypeRangeLink> APowertypePowertypeRangeLinkSet;

   interface APowertypePowertypeRange : Reflective::RefAssociation
   {
      APowertypePowertypeRangeLinkSet all_a_powertype_powertype_range_links()
         raises (Reflective::MofError);
      boolean exists (
         in Classifier powertype,
         in Generalization powertype_range)
         raises (Reflective::MofError);
      Classifier powertype (in Generalization powertype_range)
         raises (Reflective::MofError);
      GeneralizationSet powertype_range (in Classifier powertype)
         raises (Reflective::MofError);
      void add (
         in Classifier powertype,
         in Generalization powertype_range)
         raises (Reflective::MofError);
      void modify_powertype (
         in Classifier powertype,
         in Generalization powertype_range,
         in Classifier new_powertype)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_powertype_range (
         in Classifier powertype,
         in Generalization powertype_range,
         in Generalization new_powertype_range)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Classifier powertype,
         in Generalization powertype_range)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface APowertypePowertypeRange

   struct ACommentAnnotatedElementLink
   {
      Core::Comment comment;
      ModelElement annotated_element;
   };
   typedef sequence<ACommentAnnotatedElementLink> ACommentAnnotatedElementLinkSet;

   interface ACommentAnnotatedElement : Reflective::RefAssociation
   {
      ACommentAnnotatedElementLinkSet all_a_comment_annotated_element_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Comment comment,
         in ModelElement annotated_element)
         raises (Reflective::MofError);
      CommentSet comment (in ModelElement annotated_element)
         raises (Reflective::MofError);
      ModelElementSet annotated_element (in Core::Comment comment)
         raises (Reflective::MofError);
      void add (
         in Core::Comment comment,
         in ModelElement annotated_element)
         raises (Reflective::MofError);
      void modify_comment (
         in Core::Comment comment,
         in ModelElement annotated_element,
         in Core::Comment new_comment)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_annotated_element (
         in Core::Comment comment,
         in ModelElement annotated_element,
         in ModelElement new_annotated_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Comment comment,
         in ModelElement annotated_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ACommentAnnotatedElement

   struct AResidentElementResidenceLink
   {
      ModelElement resident;
      ElementResidence element_residence;
   };
   typedef sequence<AResidentElementResidenceLink> AResidentElementResidenceLinkSet;

   interface AResidentElementResidence : Reflective::RefAssociation
   {
      AResidentElementResidenceLinkSet all_a_resident_element_residence_links()
         raises (Reflective::MofError);
      boolean exists (
         in ModelElement resident,
         in ElementResidence element_residence)
         raises (Reflective::MofError);
      ModelElement resident (in ElementResidence element_residence)
         raises (Reflective::MofError);
      ElementResidenceSet element_residence (in ModelElement resident)
         raises (Reflective::MofError);
      void add (
         in ModelElement resident,
         in ElementResidence element_residence)
         raises (Reflective::MofError);
      void modify_resident (
         in ModelElement resident,
         in ElementResidence element_residence,
         in ModelElement new_resident)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_element_residence (
         in ModelElement resident,
         in ElementResidence element_residence,
         in ElementResidence new_element_residence)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ModelElement resident,
         in ElementResidence element_residence)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AResidentElementResidence

   struct AContainerResidentElementLink
   {
      Component container;
      ElementResidence resident_element;
   };
   typedef sequence<AContainerResidentElementLink> AContainerResidentElementLinkSet;

   interface AContainerResidentElement : Reflective::RefAssociation
   {
      AContainerResidentElementLinkSet all_a_container_resident_element_links()
         raises (Reflective::MofError);
      boolean exists (
         in Component container,
         in ElementResidence resident_element)
         raises (Reflective::MofError);
      Component container (in ElementResidence resident_element)
         raises (Reflective::MofError);
      ElementResidenceSet resident_element (in Component container)
         raises (Reflective::MofError);
      void add (
         in Component container,
         in ElementResidence resident_element)
         raises (Reflective::MofError);
      void modify_container (
         in Component container,
         in ElementResidence resident_element,
         in Component new_container)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_resident_element (
         in Component container,
         in ElementResidence resident_element,
         in ElementResidence new_resident_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Component container,
         in ElementResidence resident_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AContainerResidentElement

   struct ATemplateTemplateParameterLink
   {
      ModelElement template;
      TemplateParameter template_parameter;
   };
   typedef sequence<ATemplateTemplateParameterLink> ATemplateTemplateParameterLinkSet;

   interface ATemplateTemplateParameter : Reflective::RefAssociation
   {
      ATemplateTemplateParameterLinkSet all_a_template_template_parameter_links()
         raises (Reflective::MofError);
      boolean exists (
         in ModelElement template,
         in TemplateParameter template_parameter)
         raises (Reflective::MofError);
      ModelElement template (in TemplateParameter template_parameter)
         raises (Reflective::MofError);
      TemplateParameterUList template_parameter (in ModelElement template)
         raises (Reflective::MofError);
      void add (
         in ModelElement template,
         in TemplateParameter template_parameter)
         raises (Reflective::MofError);
      void add_before_template_parameter (
         in ModelElement template,
         in TemplateParameter template_parameter,
         in TemplateParameter before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_template (
         in ModelElement template,
         in TemplateParameter template_parameter,
         in ModelElement new_template)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_template_parameter (
         in ModelElement template,
         in TemplateParameter template_parameter,
         in TemplateParameter new_template_parameter)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ModelElement template,
         in TemplateParameter template_parameter)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ATemplateTemplateParameter

   struct AParameterParameterTemplateLink
   {
      ModelElement parameter;
      TemplateParameter parameter_template;
   };
   typedef sequence<AParameterParameterTemplateLink> AParameterParameterTemplateLinkSet;

   interface AParameterParameterTemplate : Reflective::RefAssociation
   {
      AParameterParameterTemplateLinkSet all_a_parameter_parameter_template_links()
         raises (Reflective::MofError);
      boolean exists (
         in ModelElement parameter,
         in TemplateParameter parameter_template)
         raises (Reflective::MofError);
      ModelElement parameter (in TemplateParameter parameter_template)
         raises (Reflective::MofError);
      TemplateParameter parameter_template (in ModelElement parameter)
         raises (Reflective::MofError);
      void add (
         in ModelElement parameter,
         in TemplateParameter parameter_template)
         raises (Reflective::MofError);
      void modify_parameter (
         in ModelElement parameter,
         in TemplateParameter parameter_template,
         in ModelElement new_parameter)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_parameter_template (
         in ModelElement parameter,
         in TemplateParameter parameter_template,
         in TemplateParameter new_parameter_template)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ModelElement parameter,
         in TemplateParameter parameter_template)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AParameterParameterTemplate

   struct AEnumerationLiteralLink
   {
      Core::Enumeration enumeration;
      EnumerationLiteral literal;
   };
   typedef sequence<AEnumerationLiteralLink> AEnumerationLiteralLinkSet;

   interface AEnumerationLiteral : Reflective::RefAssociation
   {
      AEnumerationLiteralLinkSet all_a_enumeration_literal_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Enumeration enumeration,
         in EnumerationLiteral literal)
         raises (Reflective::MofError);
      Core::Enumeration enumeration (in EnumerationLiteral literal)
         raises (Reflective::MofError);
      EnumerationLiteralUList literal (in Core::Enumeration enumeration)
         raises (Reflective::MofError);
      void add (
         in Core::Enumeration enumeration,
         in EnumerationLiteral literal)
         raises (Reflective::MofError);
      void add_before_literal (
         in Core::Enumeration enumeration,
         in EnumerationLiteral literal,
         in EnumerationLiteral before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_enumeration (
         in Core::Enumeration enumeration,
         in EnumerationLiteral literal,
         in Core::Enumeration new_enumeration)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_literal (
         in Core::Enumeration enumeration,
         in EnumerationLiteral literal,
         in EnumerationLiteral new_literal)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Enumeration enumeration,
         in EnumerationLiteral literal)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AEnumerationLiteral

   struct ADefinedTagOwnerLink
   {
      TagDefinition defined_tag;
      Stereotype owner;
   };
   typedef sequence<ADefinedTagOwnerLink> ADefinedTagOwnerLinkSet;

   interface ADefinedTagOwner : Reflective::RefAssociation
   {
      ADefinedTagOwnerLinkSet all_a_defined_tag_owner_links()
         raises (Reflective::MofError);
      boolean exists (
         in TagDefinition defined_tag,
         in Stereotype owner)
         raises (Reflective::MofError);
      TagDefinitionSet defined_tag (in Stereotype owner)
         raises (Reflective::MofError);
      Stereotype owner (in TagDefinition defined_tag)
         raises (Reflective::MofError);
      void add (
         in TagDefinition defined_tag,
         in Stereotype owner)
         raises (Reflective::MofError);
      void modify_defined_tag (
         in TagDefinition defined_tag,
         in Stereotype owner,
         in TagDefinition new_defined_tag)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_owner (
         in TagDefinition defined_tag,
         in Stereotype owner,
         in Stereotype new_owner)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in TagDefinition defined_tag,
         in Stereotype owner)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ADefinedTagOwner

   struct AStereotypeExtendedElementLink
   {
      Core::Stereotype stereotype;
      ModelElement extended_element;
   };
   typedef sequence<AStereotypeExtendedElementLink> AStereotypeExtendedElementLinkSet;

   interface AStereotypeExtendedElement : Reflective::RefAssociation
   {
      AStereotypeExtendedElementLinkSet all_a_stereotype_extended_element_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Stereotype stereotype,
         in ModelElement extended_element)
         raises (Reflective::MofError);
      StereotypeSet stereotype (in ModelElement extended_element)
         raises (Reflective::MofError);
      ModelElementSet extended_element (in Core::Stereotype stereotype)
         raises (Reflective::MofError);
      void add (
         in Core::Stereotype stereotype,
         in ModelElement extended_element)
         raises (Reflective::MofError);
      void modify_stereotype (
         in Core::Stereotype stereotype,
         in ModelElement extended_element,
         in Core::Stereotype new_stereotype)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_extended_element (
         in Core::Stereotype stereotype,
         in ModelElement extended_element,
         in ModelElement new_extended_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Stereotype stereotype,
         in ModelElement extended_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AStereotypeExtendedElement

   struct AConstrainedStereotypeStereotypeConstraintLink
   {
      Stereotype constrained_stereotype;
      UmlConstraint stereotype_constraint;
   };
   typedef sequence<AConstrainedStereotypeStereotypeConstraintLink> AConstrainedStereotypeStereotypeConstraintLinkSet;

   interface AConstrainedStereotypeStereotypeConstraint : Reflective::RefAssociation
   {
      AConstrainedStereotypeStereotypeConstraintLinkSet all_a_constrained_stereotype_stereotype_constraint_links()
         raises (Reflective::MofError);
      boolean exists (
         in Stereotype constrained_stereotype,
         in UmlConstraint stereotype_constraint)
         raises (Reflective::MofError);
      Stereotype constrained_stereotype (in UmlConstraint stereotype_constraint)
         raises (Reflective::MofError);
      UmlConstraintSet stereotype_constraint (in Stereotype constrained_stereotype)
         raises (Reflective::MofError);
      void add (
         in Stereotype constrained_stereotype,
         in UmlConstraint stereotype_constraint)
         raises (Reflective::MofError);
      void modify_constrained_stereotype (
         in Stereotype constrained_stereotype,
         in UmlConstraint stereotype_constraint,
         in Stereotype new_constrained_stereotype)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_stereotype_constraint (
         in Stereotype constrained_stereotype,
         in UmlConstraint stereotype_constraint,
         in UmlConstraint new_stereotype_constraint)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Stereotype constrained_stereotype,
         in UmlConstraint stereotype_constraint)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AConstrainedStereotypeStereotypeConstraint

   struct AModelElementTaggedValueLink
   {
      ModelElement model_element;
      TaggedValue tagged_value;
   };
   typedef sequence<AModelElementTaggedValueLink> AModelElementTaggedValueLinkSet;

   interface AModelElementTaggedValue : Reflective::RefAssociation
   {
      AModelElementTaggedValueLinkSet all_a_model_element_tagged_value_links()
         raises (Reflective::MofError);
      boolean exists (
         in ModelElement model_element,
         in TaggedValue tagged_value)
         raises (Reflective::MofError);
      ModelElement model_element (in TaggedValue tagged_value)
         raises (Reflective::MofError);
      TaggedValueSet tagged_value (in ModelElement model_element)
         raises (Reflective::MofError);
      void add (
         in ModelElement model_element,
         in TaggedValue tagged_value)
         raises (Reflective::MofError);
      void modify_model_element (
         in ModelElement model_element,
         in TaggedValue tagged_value,
         in ModelElement new_model_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_tagged_value (
         in ModelElement model_element,
         in TaggedValue tagged_value,
         in TaggedValue new_tagged_value)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ModelElement model_element,
         in TaggedValue tagged_value)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AModelElementTaggedValue

   struct ATypeTypedValueLink
   {
      TagDefinition type;
      TaggedValue typed_value;
   };
   typedef sequence<ATypeTypedValueLink> ATypeTypedValueLinkSet;

   interface ATypeTypedValue : Reflective::RefAssociation
   {
      ATypeTypedValueLinkSet all_a_type_typed_value_links()
         raises (Reflective::MofError);
      boolean exists (
         in TagDefinition type,
         in TaggedValue typed_value)
         raises (Reflective::MofError);
      TagDefinition type (in TaggedValue typed_value)
         raises (Reflective::MofError);
      TaggedValueSet typed_value (in TagDefinition type)
         raises (Reflective::MofError);
      void add (
         in TagDefinition type,
         in TaggedValue typed_value)
         raises (Reflective::MofError);
      void modify_type (
         in TagDefinition type,
         in TaggedValue typed_value,
         in TagDefinition new_type)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_typed_value (
         in TagDefinition type,
         in TaggedValue typed_value,
         in TaggedValue new_typed_value)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in TagDefinition type,
         in TaggedValue typed_value)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ATypeTypedValue

   struct AReferenceValueReferenceTagLink
   {
      ModelElement reference_value;
      TaggedValue reference_tag;
   };
   typedef sequence<AReferenceValueReferenceTagLink> AReferenceValueReferenceTagLinkSet;

   interface AReferenceValueReferenceTag : Reflective::RefAssociation
   {
      AReferenceValueReferenceTagLinkSet all_a_reference_value_reference_tag_links()
         raises (Reflective::MofError);
      boolean exists (
         in ModelElement reference_value,
         in TaggedValue reference_tag)
         raises (Reflective::MofError);
      ModelElementSet reference_value (in TaggedValue reference_tag)
         raises (Reflective::MofError);
      TaggedValueSet reference_tag (in ModelElement reference_value)
         raises (Reflective::MofError);
      void add (
         in ModelElement reference_value,
         in TaggedValue reference_tag)
         raises (Reflective::MofError);
      void modify_reference_value (
         in ModelElement reference_value,
         in TaggedValue reference_tag,
         in ModelElement new_reference_value)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_reference_tag (
         in ModelElement reference_value,
         in TaggedValue reference_tag,
         in TaggedValue new_reference_tag)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ModelElement reference_value,
         in TaggedValue reference_tag)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AReferenceValueReferenceTag

   struct AImplementationImplementationLocationLink
   {
      Artifact implementation;
      Component implementation_location;
   };
   typedef sequence<AImplementationImplementationLocationLink> AImplementationImplementationLocationLinkSet;

   interface AImplementationImplementationLocation : Reflective::RefAssociation
   {
      AImplementationImplementationLocationLinkSet all_a_implementation_implementation_location_links()
         raises (Reflective::MofError);
      boolean exists (
         in Artifact implementation,
         in Component implementation_location)
         raises (Reflective::MofError);
      ArtifactSet implementation (in Component implementation_location)
         raises (Reflective::MofError);
      ComponentSet implementation_location (in Artifact implementation)
         raises (Reflective::MofError);
      void add (
         in Artifact implementation,
         in Component implementation_location)
         raises (Reflective::MofError);
      void modify_implementation (
         in Artifact implementation,
         in Component implementation_location,
         in Artifact new_implementation)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_implementation_location (
         in Artifact implementation,
         in Component implementation_location,
         in Component new_implementation_location)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Artifact implementation,
         in Component implementation_location)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AImplementationImplementationLocation

   struct AModelElementTemplateArgumentLink
   {
      ModelElement model_element;
      TemplateArgument template_argument;
   };
   typedef sequence<AModelElementTemplateArgumentLink> AModelElementTemplateArgumentLinkSet;

   interface AModelElementTemplateArgument : Reflective::RefAssociation
   {
      AModelElementTemplateArgumentLinkSet all_a_model_element_template_argument_links()
         raises (Reflective::MofError);
      boolean exists (
         in ModelElement model_element,
         in TemplateArgument template_argument)
         raises (Reflective::MofError);
      ModelElement model_element (in TemplateArgument template_argument)
         raises (Reflective::MofError);
      TemplateArgumentSet template_argument (in ModelElement model_element)
         raises (Reflective::MofError);
      void add (
         in ModelElement model_element,
         in TemplateArgument template_argument)
         raises (Reflective::MofError);
      void modify_model_element (
         in ModelElement model_element,
         in TemplateArgument template_argument,
         in ModelElement new_model_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_template_argument (
         in ModelElement model_element,
         in TemplateArgument template_argument,
         in TemplateArgument new_template_argument)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ModelElement model_element,
         in TemplateArgument template_argument)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AModelElementTemplateArgument

   interface CorePackageFactory
   {
      CorePackage create_core_package ()
         raises (Reflective::MofError);
   };

   interface CorePackage : Reflective::RefPackage
   {
      readonly attribute DataTypes::DataTypesPackage data_types_ref;
      readonly attribute ElementClass element_ref;
      readonly attribute ModelElementClass model_element_ref;
      readonly attribute GeneralizableElementClass generalizable_element_ref;
      readonly attribute NamespaceClass namespace_ref;
      readonly attribute ClassifierClass classifier_ref;
      readonly attribute ClassClass class_ref;
      readonly attribute DataTypeClass data_type_ref;
      readonly attribute FeatureClass feature_ref;
      readonly attribute StructuralFeatureClass structural_feature_ref;
      readonly attribute AssociationEndClass association_end_ref;
      readonly attribute UmlInterfaceClass uml_interface_ref;
      readonly attribute UmlConstraintClass uml_constraint_ref;
      readonly attribute RelationshipClass relationship_ref;
      readonly attribute AssociationClass association_ref;
      readonly attribute UmlAttributeClass uml_attribute_ref;
      readonly attribute BehavioralFeatureClass behavioral_feature_ref;
      readonly attribute OperationClass operation_ref;
      readonly attribute ParameterClass parameter_ref;
      readonly attribute MethodClass method_ref;
      readonly attribute GeneralizationClass generalization_ref;
      readonly attribute UmlAssociationClassClass uml_association_class_ref;
      readonly attribute DependencyClass dependency_ref;
      readonly attribute AbstractionClass abstraction_ref;
      readonly attribute PresentationElementClass presentation_element_ref;
      readonly attribute UsageClass usage_ref;
      readonly attribute BindingClass binding_ref;
      readonly attribute ComponentClass component_ref;
      readonly attribute NodeClass node_ref;
      readonly attribute PermissionClass permission_ref;
      readonly attribute CommentClass comment_ref;
      readonly attribute FlowClass flow_ref;
      readonly attribute ElementResidenceClass element_residence_ref;
      readonly attribute TemplateParameterClass template_parameter_ref;
      readonly attribute PrimitiveClass primitive_ref;
      readonly attribute EnumerationClass enumeration_ref;
      readonly attribute EnumerationLiteralClass enumeration_literal_ref;
      readonly attribute StereotypeClass stereotype_ref;
      readonly attribute TagDefinitionClass tag_definition_ref;
      readonly attribute TaggedValueClass tagged_value_ref;
      readonly attribute ProgrammingLanguageDataTypeClass programming_language_data_type_ref;
      readonly attribute ArtifactClass artifact_ref;
      readonly attribute TemplateArgumentClass template_argument_ref;
      readonly attribute AAssociationConnection a_association_connection_ref;
      readonly attribute AOwnerFeature a_owner_feature_ref;
      readonly attribute ASpecificationMethod a_specification_method_ref;
      readonly attribute ATypedFeatureType a_typed_feature_type_ref;
      readonly attribute ANamespaceOwnedElement a_namespace_owned_element_ref;
      readonly attribute ABehavioralFeatureParameter a_behavioral_feature_parameter_ref;
      readonly attribute ATypedParameterType a_typed_parameter_type_ref;
      readonly attribute AChildGeneralization a_child_generalization_ref;
      readonly attribute AParentSpecialization a_parent_specialization_ref;
      readonly attribute AQualifierAssociationEnd a_qualifier_association_end_ref;
      readonly attribute AParticipantAssociation a_participant_association_ref;
      readonly attribute ASpecifiedEndSpecification a_specified_end_specification_ref;
      readonly attribute AClientClientDependency a_client_client_dependency_ref;
      readonly attribute AConstrainedElementConstraint a_constrained_element_constraint_ref;
      readonly attribute ASupplierSupplierDependency a_supplier_supplier_dependency_ref;
      readonly attribute APresentationSubject a_presentation_subject_ref;
      readonly attribute ADeploymentLocationDeployedComponent a_deployment_location_deployed_component_ref;
      readonly attribute ATargetFlowTarget a_target_flow_target_ref;
      readonly attribute ASourceFlowSource a_source_flow_source_ref;
      readonly attribute ADefaultElementDefaultedParameter a_default_element_defaulted_parameter_ref;
      readonly attribute ABindingArgument a_binding_argument_ref;
      readonly attribute APowertypePowertypeRange a_powertype_powertype_range_ref;
      readonly attribute ACommentAnnotatedElement a_comment_annotated_element_ref;
      readonly attribute AResidentElementResidence a_resident_element_residence_ref;
      readonly attribute AContainerResidentElement a_container_resident_element_ref;
      readonly attribute ATemplateTemplateParameter a_template_template_parameter_ref;
      readonly attribute AParameterParameterTemplate a_parameter_parameter_template_ref;
      readonly attribute AEnumerationLiteral a_enumeration_literal_ref;
      readonly attribute ADefinedTagOwner a_defined_tag_owner_ref;
      readonly attribute AStereotypeExtendedElement a_stereotype_extended_element_ref;
      readonly attribute AConstrainedStereotypeStereotypeConstraint a_constrained_stereotype_stereotype_constraint_ref;
      readonly attribute AModelElementTaggedValue a_model_element_tagged_value_ref;
      readonly attribute ATypeTypedValue a_type_typed_value_ref;
      readonly attribute AReferenceValueReferenceTag a_reference_value_reference_tag_ref;
      readonly attribute AImplementationImplementationLocation a_implementation_implementation_location_ref;
      readonly attribute AModelElementTemplateArgument a_model_element_template_argument_ref;
   };
};

#endif