#ifndef COMMON_BEHAVIOR_IDL
#define COMMON_BEHAVIOR_IDL
#pragma prefix "org.omg.uml.BehavioralElements"
#include "Reflective.idl"
#include "Core.idl"
#include "DataTypes.idl"

module CommonBehavior
{
   typedef sequence<Core::Classifier> ClassifierSet;
   typedef sequence<Core::BehavioralFeature> BehavioralFeatureSet;
   interface InstanceClass;
   interface Instance;
   typedef sequence<Instance> InstanceSet;
   typedef sequence<Instance> InstanceUList;
   interface SignalClass;
   interface Signal;
   typedef sequence<Signal> SignalSet;
   interface UninterpretedActionClass;
   interface UninterpretedAction;
   typedef sequence<UninterpretedAction> UninterpretedActionSet;
   interface AttributeLinkClass;
   interface AttributeLink;
   typedef sequence<AttributeLink> AttributeLinkSet;
   typedef sequence<AttributeLink> AttributeLinkUList;
   interface UmlObjectClass;
   interface UmlObject;
   typedef sequence<UmlObject> UmlObjectSet;
   interface LinkClass;
   interface Link;
   typedef sequence<Link> LinkSet;
   interface LinkObjectClass;
   interface LinkObject;
   typedef sequence<LinkObject> LinkObjectSet;
   interface DataValueClass;
   interface DataValue;
   typedef sequence<DataValue> DataValueSet;
   interface ReceptionClass;
   interface Reception;
   typedef sequence<Reception> ReceptionSet;
   interface LinkEndClass;
   interface LinkEnd;
   typedef sequence<LinkEnd> LinkEndSet;
   interface TerminateActionClass;
   interface TerminateAction;
   typedef sequence<TerminateAction> TerminateActionSet;
   interface StimulusClass;
   interface Stimulus;
   typedef sequence<Stimulus> StimulusSet;
   interface UmlExceptionClass;
   interface UmlException;
   typedef sequence<UmlException> UmlExceptionSet;
   interface ComponentInstanceClass;
   interface ComponentInstance;
   typedef sequence<ComponentInstance> ComponentInstanceSet;
   interface NodeInstanceClass;
   interface NodeInstance;
   typedef sequence<NodeInstance> NodeInstanceSet;
   interface SubsystemInstanceClass;
   interface SubsystemInstance;
   typedef sequence<SubsystemInstance> SubsystemInstanceSet;
   interface ProcedureClass;
   interface Procedure;
   typedef sequence<Procedure> ProcedureSet;
   interface CommonBehaviorPackage;

   interface InstanceClass : Core::ModelElementClass
   {
      readonly attribute InstanceSet all_of_type_instance;
   };

   interface Instance : InstanceClass, Core::ModelElement
   {
      ClassifierSet classifier ()
         raises (Reflective::MofError);
      void set_classifier (in ClassifierSet new_value)
         raises (Reflective::MofError);
      void add_classifier (in Core::Classifier new_element)
         raises (Reflective::MofError);
      void modify_classifier (
         in Core::Classifier old_element,
         in Core::Classifier new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_classifier (in Core::Classifier old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      LinkEndSet link_end ()
         raises (Reflective::MofError);
      void set_link_end (in LinkEndSet new_value)
         raises (Reflective::MofError);
      void unset_link_end ()
         raises (Reflective::MofError);
      void add_link_end (in LinkEnd new_element)
         raises (Reflective::MofError);
      void modify_link_end (
         in LinkEnd old_element,
         in LinkEnd new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_link_end (in LinkEnd old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      AttributeLinkSet slot ()
         raises (Reflective::MofError);
      void set_slot (in AttributeLinkSet new_value)
         raises (Reflective::MofError);
      void unset_slot ()
         raises (Reflective::MofError);
      void add_slot (in AttributeLink new_element)
         raises (Reflective::MofError);
      void modify_slot (
         in AttributeLink old_element,
         in AttributeLink new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_slot (in AttributeLink old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ComponentInstance component_instance ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_component_instance (in ComponentInstance new_value)
         raises (Reflective::MofError);
      void unset_component_instance ()
         raises (Reflective::MofError);
      InstanceSet owned_instance ()
         raises (Reflective::MofError);
      void set_owned_instance (in InstanceSet new_value)
         raises (Reflective::MofError);
      void unset_owned_instance ()
         raises (Reflective::MofError);
      void add_owned_instance (in Instance new_element)
         raises (Reflective::MofError);
      void modify_owned_instance (
         in Instance old_element,
         in Instance new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_owned_instance (in Instance old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      LinkSet owned_link ()
         raises (Reflective::MofError);
      void set_owned_link (in LinkSet new_value)
         raises (Reflective::MofError);
      void unset_owned_link ()
         raises (Reflective::MofError);
      void add_owned_link (in Link new_element)
         raises (Reflective::MofError);
      void modify_owned_link (
         in Link old_element,
         in Link new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_owned_link (in Link old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Instance

   interface SignalClass : Core::ClassifierClass
   {
      readonly attribute SignalSet all_of_type_signal;
      readonly attribute SignalSet all_of_class_signal;
      Signal create_signal (
         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 Signal : SignalClass, Core::Classifier
   {
   }; // end of interface Signal

   interface UninterpretedActionClass : Reflective::RefObject
   {
      readonly attribute UninterpretedActionSet all_of_type_uninterpreted_action;
      readonly attribute UninterpretedActionSet all_of_class_uninterpreted_action;
      UninterpretedAction create_uninterpreted_action ()
         raises (Reflective::MofError);
   };

   interface UninterpretedAction : UninterpretedActionClass
   {
   }; // end of interface UninterpretedAction

   interface AttributeLinkClass : Core::ModelElementClass
   {
      readonly attribute AttributeLinkSet all_of_type_attribute_link;
      readonly attribute AttributeLinkSet all_of_class_attribute_link;
      AttributeLink create_attribute_link (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface AttributeLink : AttributeLinkClass, Core::ModelElement
   {
      Core::UmlAttribute uml_attribute ()
         raises (Reflective::MofError);
      void set_uml_attribute (in Core::UmlAttribute new_value)
         raises (Reflective::MofError);
      CommonBehavior::Instance uml_value ()
         raises (Reflective::MofError);
      void set_uml_value (in CommonBehavior::Instance new_value)
         raises (Reflective::MofError);
      CommonBehavior::Instance instance ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_instance (in CommonBehavior::Instance new_value)
         raises (Reflective::MofError);
      void unset_instance ()
         raises (Reflective::MofError);
      LinkEnd link_end ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_link_end (in LinkEnd new_value)
         raises (Reflective::MofError);
      void unset_link_end ()
         raises (Reflective::MofError);
   }; // end of interface AttributeLink

   interface UmlObjectClass : InstanceClass
   {
      readonly attribute UmlObjectSet all_of_type_uml_object;
      readonly attribute UmlObjectSet all_of_class_uml_object;
      UmlObject create_uml_object (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface UmlObject : UmlObjectClass, Instance
   {
   }; // end of interface UmlObject

   interface LinkClass : Core::ModelElementClass
   {
      readonly attribute LinkSet all_of_type_link;
      readonly attribute LinkSet all_of_class_link;
      Link create_link (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface Link : LinkClass, Core::ModelElement
   {
      Core::Association association ()
         raises (Reflective::MofError);
      void set_association (in Core::Association new_value)
         raises (Reflective::MofError);
      LinkEndSet connection ()
         raises (Reflective::MofError);
      void set_connection (in LinkEndSet new_value)
         raises (Reflective::MofError);
      void add_connection (in LinkEnd new_element)
         raises (Reflective::MofError);
      void modify_connection (
         in LinkEnd old_element,
         in LinkEnd new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_connection (in LinkEnd old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Link

   interface LinkObjectClass : UmlObjectClass, LinkClass
   {
      readonly attribute LinkObjectSet all_of_type_link_object;
      readonly attribute LinkObjectSet all_of_class_link_object;
      LinkObject create_link_object (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface LinkObject : LinkObjectClass, UmlObject, Link
   {
   }; // end of interface LinkObject

   interface DataValueClass : InstanceClass
   {
      readonly attribute DataValueSet all_of_type_data_value;
      readonly attribute DataValueSet all_of_class_data_value;
      DataValue create_data_value (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface DataValue : DataValueClass, Instance
   {
   }; // end of interface DataValue

   interface ReceptionClass : Core::BehavioralFeatureClass
   {
      readonly attribute ReceptionSet all_of_type_reception;
      readonly attribute ReceptionSet all_of_class_reception;
      Reception create_reception (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::ScopeKind owner_scope,
         in boolean is_query,
         in string specification,
         in boolean is_root,
         in boolean is_leaf,
         in boolean is_abstract)
         raises (Reflective::MofError);
   };

   interface Reception : ReceptionClass, Core::BehavioralFeature
   {
      string specification ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_specification (in string new_value)
         raises (Reflective::MofError);
      void unset_specification ()
         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);
      CommonBehavior::Signal signal ()
         raises (Reflective::MofError);
      void set_signal (in CommonBehavior::Signal new_value)
         raises (Reflective::MofError);
   }; // end of interface Reception

   interface LinkEndClass : Core::ModelElementClass
   {
      readonly attribute LinkEndSet all_of_type_link_end;
      readonly attribute LinkEndSet all_of_class_link_end;
      LinkEnd create_link_end (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface LinkEnd : LinkEndClass, Core::ModelElement
   {
      CommonBehavior::Instance instance ()
         raises (Reflective::MofError);
      void set_instance (in CommonBehavior::Instance new_value)
         raises (Reflective::MofError);
      CommonBehavior::Link link ()
         raises (Reflective::MofError);
      void set_link (in CommonBehavior::Link new_value)
         raises (Reflective::MofError);
      Core::AssociationEnd association_end ()
         raises (Reflective::MofError);
      void set_association_end (in Core::AssociationEnd new_value)
         raises (Reflective::MofError);
      AttributeLinkUList qualified_value ()
         raises (Reflective::MofError);
      void set_qualified_value (in AttributeLinkUList new_value)
         raises (Reflective::MofError);
      void unset_qualified_value ()
         raises (Reflective::MofError);
      void add_qualified_value (in AttributeLink new_element)
         raises (Reflective::MofError);
      void add_qualified_value_before (
         in AttributeLink new_element,
         in AttributeLink before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_qualified_value (
         in AttributeLink old_element,
         in AttributeLink new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_qualified_value (in AttributeLink old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface LinkEnd

   interface TerminateActionClass : Reflective::RefObject
   {
      readonly attribute TerminateActionSet all_of_type_terminate_action;
      readonly attribute TerminateActionSet all_of_class_terminate_action;
      TerminateAction create_terminate_action ()
         raises (Reflective::MofError);
   };

   interface TerminateAction : TerminateActionClass
   {
   }; // end of interface TerminateAction

   interface StimulusClass : Core::ModelElementClass
   {
      readonly attribute StimulusSet all_of_type_stimulus;
      readonly attribute StimulusSet all_of_class_stimulus;
      Stimulus create_stimulus (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface Stimulus : StimulusClass, Core::ModelElement
   {
      InstanceUList argument ()
         raises (Reflective::MofError);
      void set_argument (in InstanceUList new_value)
         raises (Reflective::MofError);
      void unset_argument ()
         raises (Reflective::MofError);
      void add_argument (in Instance new_element)
         raises (Reflective::MofError);
      void add_argument_before (
         in Instance new_element,
         in Instance before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_argument (
         in Instance old_element,
         in Instance new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_argument (in Instance old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      Instance sender ()
         raises (Reflective::MofError);
      void set_sender (in Instance new_value)
         raises (Reflective::MofError);
      Instance receiver ()
         raises (Reflective::MofError);
      void set_receiver (in Instance new_value)
         raises (Reflective::MofError);
      Link communication_link ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_communication_link (in Link new_value)
         raises (Reflective::MofError);
      void unset_communication_link ()
         raises (Reflective::MofError);
      Procedure dispatch_action ()
         raises (Reflective::MofError);
      void set_dispatch_action (in Procedure new_value)
         raises (Reflective::MofError);
   }; // end of interface Stimulus

   interface UmlExceptionClass : SignalClass
   {
      readonly attribute UmlExceptionSet all_of_type_uml_exception;
      readonly attribute UmlExceptionSet all_of_class_uml_exception;
      UmlException create_uml_exception (
         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 UmlException : UmlExceptionClass, Signal
   {
   }; // end of interface UmlException

   interface ComponentInstanceClass : InstanceClass
   {
      readonly attribute ComponentInstanceSet all_of_type_component_instance;
      readonly attribute ComponentInstanceSet all_of_class_component_instance;
      ComponentInstance create_component_instance (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface ComponentInstance : ComponentInstanceClass, Instance
   {
      NodeInstance node_instance ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_node_instance (in NodeInstance new_value)
         raises (Reflective::MofError);
      void unset_node_instance ()
         raises (Reflective::MofError);
      InstanceSet resident ()
         raises (Reflective::MofError);
      void set_resident (in InstanceSet new_value)
         raises (Reflective::MofError);
      void unset_resident ()
         raises (Reflective::MofError);
      void add_resident (in Instance new_element)
         raises (Reflective::MofError);
      void modify_resident (
         in Instance old_element,
         in Instance new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_resident (in Instance old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ComponentInstance

   interface NodeInstanceClass : InstanceClass
   {
      readonly attribute NodeInstanceSet all_of_type_node_instance;
      readonly attribute NodeInstanceSet all_of_class_node_instance;
      NodeInstance create_node_instance (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface NodeInstance : NodeInstanceClass, Instance
   {
      ComponentInstanceSet resident ()
         raises (Reflective::MofError);
      void set_resident (in ComponentInstanceSet new_value)
         raises (Reflective::MofError);
      void unset_resident ()
         raises (Reflective::MofError);
      void add_resident (in ComponentInstance new_element)
         raises (Reflective::MofError);
      void modify_resident (
         in ComponentInstance old_element,
         in ComponentInstance new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_resident (in ComponentInstance old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface NodeInstance

   interface SubsystemInstanceClass : InstanceClass
   {
      readonly attribute SubsystemInstanceSet all_of_type_subsystem_instance;
      readonly attribute SubsystemInstanceSet all_of_class_subsystem_instance;
      SubsystemInstance create_subsystem_instance (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface SubsystemInstance : SubsystemInstanceClass, Instance
   {
   }; // end of interface SubsystemInstance

   interface ProcedureClass : Core::ModelElementClass
   {
      readonly attribute ProcedureSet all_of_type_procedure;
      readonly attribute ProcedureSet all_of_class_procedure;
      Procedure create_procedure (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::Name language,
         in string body,
         in boolean is_list)
         raises (Reflective::MofError);
   };

   interface Procedure : ProcedureClass, Core::ModelElement
   {
      DataTypes::Name language ()
         raises (Reflective::MofError);
      void set_language (in DataTypes::Name new_value)
         raises (Reflective::MofError);
      string body ()
         raises (Reflective::MofError);
      void set_body (in string new_value)
         raises (Reflective::MofError);
      boolean is_list ()
         raises (Reflective::MofError);
      void set_is_list (in boolean new_value)
         raises (Reflective::MofError);
      DataTypes::Expression expression ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_expression (in DataTypes::Expression new_value)
         raises (Reflective::MofError);
      void unset_expression ()
         raises (Reflective::MofError);
      Core::Method method ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_method (in Core::Method new_value)
         raises (Reflective::MofError);
      void unset_method ()
         raises (Reflective::MofError);
   }; // end of interface Procedure

   struct AInstanceClassifierLink
   {
      CommonBehavior::Instance instance;
      Core::Classifier classifier;
   };
   typedef sequence<AInstanceClassifierLink> AInstanceClassifierLinkSet;

   interface AInstanceClassifier : Reflective::RefAssociation
   {
      AInstanceClassifierLinkSet all_a_instance_classifier_links()
         raises (Reflective::MofError);
      boolean exists (
         in CommonBehavior::Instance instance,
         in Core::Classifier classifier)
         raises (Reflective::MofError);
      InstanceSet instance (in Core::Classifier classifier)
         raises (Reflective::MofError);
      ClassifierSet classifier (in CommonBehavior::Instance instance)
         raises (Reflective::MofError);
      void add (
         in CommonBehavior::Instance instance,
         in Core::Classifier classifier)
         raises (Reflective::MofError);
      void modify_instance (
         in CommonBehavior::Instance instance,
         in Core::Classifier classifier,
         in CommonBehavior::Instance new_instance)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_classifier (
         in CommonBehavior::Instance instance,
         in Core::Classifier classifier,
         in Core::Classifier new_classifier)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CommonBehavior::Instance instance,
         in Core::Classifier classifier)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AInstanceClassifier

   struct AAttributeLinkAttributeLink
   {
      AttributeLink attribute_link;
      Core::UmlAttribute uml_attribute;
   };
   typedef sequence<AAttributeLinkAttributeLink> AAttributeLinkAttributeLinkSet;

   interface AAttributeLinkAttribute : Reflective::RefAssociation
   {
      AAttributeLinkAttributeLinkSet all_a_attribute_link_attribute_links()
         raises (Reflective::MofError);
      boolean exists (
         in AttributeLink attribute_link,
         in Core::UmlAttribute uml_attribute)
         raises (Reflective::MofError);
      AttributeLinkSet attribute_link (in Core::UmlAttribute uml_attribute)
         raises (Reflective::MofError);
      Core::UmlAttribute uml_attribute (in AttributeLink attribute_link)
         raises (Reflective::MofError);
      void add (
         in AttributeLink attribute_link,
         in Core::UmlAttribute uml_attribute)
         raises (Reflective::MofError);
      void modify_attribute_link (
         in AttributeLink attribute_link,
         in Core::UmlAttribute uml_attribute,
         in AttributeLink new_attribute_link)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_uml_attribute (
         in AttributeLink attribute_link,
         in Core::UmlAttribute uml_attribute,
         in Core::UmlAttribute new_uml_attribute)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in AttributeLink attribute_link,
         in Core::UmlAttribute uml_attribute)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AAttributeLinkAttribute

   struct AAttributeLinkValueLink
   {
      AttributeLink attribute_link;
      Instance uml_value;
   };
   typedef sequence<AAttributeLinkValueLink> AAttributeLinkValueLinkSet;

   interface AAttributeLinkValue : Reflective::RefAssociation
   {
      AAttributeLinkValueLinkSet all_a_attribute_link_value_links()
         raises (Reflective::MofError);
      boolean exists (
         in AttributeLink attribute_link,
         in Instance uml_value)
         raises (Reflective::MofError);
      AttributeLinkSet attribute_link (in Instance uml_value)
         raises (Reflective::MofError);
      Instance uml_value (in AttributeLink attribute_link)
         raises (Reflective::MofError);
      void add (
         in AttributeLink attribute_link,
         in Instance uml_value)
         raises (Reflective::MofError);
      void modify_attribute_link (
         in AttributeLink attribute_link,
         in Instance uml_value,
         in AttributeLink new_attribute_link)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_uml_value (
         in AttributeLink attribute_link,
         in Instance uml_value,
         in Instance new_uml_value)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in AttributeLink attribute_link,
         in Instance uml_value)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AAttributeLinkValue

   struct AInstanceLinkEndLink
   {
      CommonBehavior::Instance instance;
      LinkEnd link_end;
   };
   typedef sequence<AInstanceLinkEndLink> AInstanceLinkEndLinkSet;

   interface AInstanceLinkEnd : Reflective::RefAssociation
   {
      AInstanceLinkEndLinkSet all_a_instance_link_end_links()
         raises (Reflective::MofError);
      boolean exists (
         in CommonBehavior::Instance instance,
         in LinkEnd link_end)
         raises (Reflective::MofError);
      CommonBehavior::Instance instance (in LinkEnd link_end)
         raises (Reflective::MofError);
      LinkEndSet link_end (in CommonBehavior::Instance instance)
         raises (Reflective::MofError);
      void add (
         in CommonBehavior::Instance instance,
         in LinkEnd link_end)
         raises (Reflective::MofError);
      void modify_instance (
         in CommonBehavior::Instance instance,
         in LinkEnd link_end,
         in CommonBehavior::Instance new_instance)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_link_end (
         in CommonBehavior::Instance instance,
         in LinkEnd link_end,
         in LinkEnd new_link_end)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CommonBehavior::Instance instance,
         in LinkEnd link_end)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AInstanceLinkEnd

   struct ASignalReceptionLink
   {
      CommonBehavior::Signal signal;
      CommonBehavior::Reception reception;
   };
   typedef sequence<ASignalReceptionLink> ASignalReceptionLinkSet;

   interface ASignalReception : Reflective::RefAssociation
   {
      ASignalReceptionLinkSet all_a_signal_reception_links()
         raises (Reflective::MofError);
      boolean exists (
         in CommonBehavior::Signal signal,
         in CommonBehavior::Reception reception)
         raises (Reflective::MofError);
      CommonBehavior::Signal signal (in CommonBehavior::Reception reception)
         raises (Reflective::MofError);
      ReceptionSet reception (in CommonBehavior::Signal signal)
         raises (Reflective::MofError);
      void add (
         in CommonBehavior::Signal signal,
         in CommonBehavior::Reception reception)
         raises (Reflective::MofError);
      void modify_signal (
         in CommonBehavior::Signal signal,
         in CommonBehavior::Reception reception,
         in CommonBehavior::Signal new_signal)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_reception (
         in CommonBehavior::Signal signal,
         in CommonBehavior::Reception reception,
         in CommonBehavior::Reception new_reception)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CommonBehavior::Signal signal,
         in CommonBehavior::Reception reception)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASignalReception

   struct ASlotInstanceLink
   {
      AttributeLink slot;
      CommonBehavior::Instance instance;
   };
   typedef sequence<ASlotInstanceLink> ASlotInstanceLinkSet;

   interface ASlotInstance : Reflective::RefAssociation
   {
      ASlotInstanceLinkSet all_a_slot_instance_links()
         raises (Reflective::MofError);
      boolean exists (
         in AttributeLink slot,
         in CommonBehavior::Instance instance)
         raises (Reflective::MofError);
      AttributeLinkSet slot (in CommonBehavior::Instance instance)
         raises (Reflective::MofError);
      CommonBehavior::Instance instance (in AttributeLink slot)
         raises (Reflective::MofError);
      void add (
         in AttributeLink slot,
         in CommonBehavior::Instance instance)
         raises (Reflective::MofError);
      void modify_slot (
         in AttributeLink slot,
         in CommonBehavior::Instance instance,
         in AttributeLink new_slot)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_instance (
         in AttributeLink slot,
         in CommonBehavior::Instance instance,
         in CommonBehavior::Instance new_instance)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in AttributeLink slot,
         in CommonBehavior::Instance instance)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASlotInstance

   struct AArgumentStimulusLink
   {
      Instance argument;
      CommonBehavior::Stimulus stimulus;
   };
   typedef sequence<AArgumentStimulusLink> AArgumentStimulusLinkSet;

   interface AArgumentStimulus : Reflective::RefAssociation
   {
      AArgumentStimulusLinkSet all_a_argument_stimulus_links()
         raises (Reflective::MofError);
      boolean exists (
         in Instance argument,
         in CommonBehavior::Stimulus stimulus)
         raises (Reflective::MofError);
      InstanceUList argument (in CommonBehavior::Stimulus stimulus)
         raises (Reflective::MofError);
      StimulusSet stimulus (in Instance argument)
         raises (Reflective::MofError);
      void add (
         in Instance argument,
         in CommonBehavior::Stimulus stimulus)
         raises (Reflective::MofError);
      void add_before_argument (
         in Instance argument,
         in CommonBehavior::Stimulus stimulus,
         in Instance before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_argument (
         in Instance argument,
         in CommonBehavior::Stimulus stimulus,
         in Instance new_argument)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_stimulus (
         in Instance argument,
         in CommonBehavior::Stimulus stimulus,
         in CommonBehavior::Stimulus new_stimulus)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Instance argument,
         in CommonBehavior::Stimulus stimulus)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AArgumentStimulus

   struct AContextRaisedSignalLink
   {
      Core::BehavioralFeature uml_context;
      Signal raised_signal;
   };
   typedef sequence<AContextRaisedSignalLink> AContextRaisedSignalLinkSet;

   interface AContextRaisedSignal : Reflective::RefAssociation
   {
      AContextRaisedSignalLinkSet all_a_context_raised_signal_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::BehavioralFeature uml_context,
         in Signal raised_signal)
         raises (Reflective::MofError);
      BehavioralFeatureSet uml_context (in Signal raised_signal)
         raises (Reflective::MofError);
      SignalSet raised_signal (in Core::BehavioralFeature uml_context)
         raises (Reflective::MofError);
      void add (
         in Core::BehavioralFeature uml_context,
         in Signal raised_signal)
         raises (Reflective::MofError);
      void modify_uml_context (
         in Core::BehavioralFeature uml_context,
         in Signal raised_signal,
         in Core::BehavioralFeature new_uml_context)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_raised_signal (
         in Core::BehavioralFeature uml_context,
         in Signal raised_signal,
         in Signal new_raised_signal)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::BehavioralFeature uml_context,
         in Signal raised_signal)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AContextRaisedSignal

   struct AAssociationLinkLink
   {
      Core::Association association;
      CommonBehavior::Link link;
   };
   typedef sequence<AAssociationLinkLink> AAssociationLinkLinkSet;

   interface AAssociationLink : Reflective::RefAssociation
   {
      AAssociationLinkLinkSet all_a_association_link_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Association association,
         in CommonBehavior::Link link)
         raises (Reflective::MofError);
      Core::Association association (in CommonBehavior::Link link)
         raises (Reflective::MofError);
      LinkSet link (in Core::Association association)
         raises (Reflective::MofError);
      void add (
         in Core::Association association,
         in CommonBehavior::Link link)
         raises (Reflective::MofError);
      void modify_association (
         in Core::Association association,
         in CommonBehavior::Link link,
         in Core::Association new_association)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_link (
         in Core::Association association,
         in CommonBehavior::Link link,
         in CommonBehavior::Link new_link)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Association association,
         in CommonBehavior::Link link)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AAssociationLink

   struct ALinkConnectionLink
   {
      CommonBehavior::Link link;
      LinkEnd connection;
   };
   typedef sequence<ALinkConnectionLink> ALinkConnectionLinkSet;

   interface ALinkConnection : Reflective::RefAssociation
   {
      ALinkConnectionLinkSet all_a_link_connection_links()
         raises (Reflective::MofError);
      boolean exists (
         in CommonBehavior::Link link,
         in LinkEnd connection)
         raises (Reflective::MofError);
      CommonBehavior::Link link (in LinkEnd connection)
         raises (Reflective::MofError);
      LinkEndSet connection (in CommonBehavior::Link link)
         raises (Reflective::MofError);
      void add (
         in CommonBehavior::Link link,
         in LinkEnd connection)
         raises (Reflective::MofError);
      void modify_link (
         in CommonBehavior::Link link,
         in LinkEnd connection,
         in CommonBehavior::Link new_link)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_connection (
         in CommonBehavior::Link link,
         in LinkEnd connection,
         in LinkEnd new_connection)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CommonBehavior::Link link,
         in LinkEnd connection)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ALinkConnection

   struct AAssociationEndLinkEndLink
   {
      Core::AssociationEnd association_end;
      LinkEnd link_end;
   };
   typedef sequence<AAssociationEndLinkEndLink> AAssociationEndLinkEndLinkSet;

   interface AAssociationEndLinkEnd : Reflective::RefAssociation
   {
      AAssociationEndLinkEndLinkSet all_a_association_end_link_end_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::AssociationEnd association_end,
         in LinkEnd link_end)
         raises (Reflective::MofError);
      Core::AssociationEnd association_end (in LinkEnd link_end)
         raises (Reflective::MofError);
      LinkEndSet link_end (in Core::AssociationEnd association_end)
         raises (Reflective::MofError);
      void add (
         in Core::AssociationEnd association_end,
         in LinkEnd link_end)
         raises (Reflective::MofError);
      void modify_association_end (
         in Core::AssociationEnd association_end,
         in LinkEnd link_end,
         in Core::AssociationEnd new_association_end)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_link_end (
         in Core::AssociationEnd association_end,
         in LinkEnd link_end,
         in LinkEnd new_link_end)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::AssociationEnd association_end,
         in LinkEnd link_end)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AAssociationEndLinkEnd

   struct AStimulusSenderLink
   {
      CommonBehavior::Stimulus stimulus;
      Instance sender;
   };
   typedef sequence<AStimulusSenderLink> AStimulusSenderLinkSet;

   interface AStimulusSender : Reflective::RefAssociation
   {
      AStimulusSenderLinkSet all_a_stimulus_sender_links()
         raises (Reflective::MofError);
      boolean exists (
         in CommonBehavior::Stimulus stimulus,
         in Instance sender)
         raises (Reflective::MofError);
      StimulusSet stimulus (in Instance sender)
         raises (Reflective::MofError);
      Instance sender (in CommonBehavior::Stimulus stimulus)
         raises (Reflective::MofError);
      void add (
         in CommonBehavior::Stimulus stimulus,
         in Instance sender)
         raises (Reflective::MofError);
      void modify_stimulus (
         in CommonBehavior::Stimulus stimulus,
         in Instance sender,
         in CommonBehavior::Stimulus new_stimulus)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_sender (
         in CommonBehavior::Stimulus stimulus,
         in Instance sender,
         in Instance new_sender)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CommonBehavior::Stimulus stimulus,
         in Instance sender)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AStimulusSender

   struct AResidentNodeInstanceLink
   {
      ComponentInstance resident;
      NodeInstance node_instance;
   };
   typedef sequence<AResidentNodeInstanceLink> AResidentNodeInstanceLinkSet;

   interface AResidentNodeInstance : Reflective::RefAssociation
   {
      AResidentNodeInstanceLinkSet all_a_resident_node_instance_links()
         raises (Reflective::MofError);
      boolean exists (
         in ComponentInstance resident,
         in NodeInstance node_instance)
         raises (Reflective::MofError);
      ComponentInstanceSet resident (in NodeInstance node_instance)
         raises (Reflective::MofError);
      NodeInstance node_instance (in ComponentInstance resident)
         raises (Reflective::MofError);
      void add (
         in ComponentInstance resident,
         in NodeInstance node_instance)
         raises (Reflective::MofError);
      void modify_resident (
         in ComponentInstance resident,
         in NodeInstance node_instance,
         in ComponentInstance new_resident)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_node_instance (
         in ComponentInstance resident,
         in NodeInstance node_instance,
         in NodeInstance new_node_instance)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ComponentInstance resident,
         in NodeInstance node_instance)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AResidentNodeInstance

   struct AResidentComponentInstanceLink
   {
      Instance resident;
      ComponentInstance component_instance;
   };
   typedef sequence<AResidentComponentInstanceLink> AResidentComponentInstanceLinkSet;

   interface AResidentComponentInstance : Reflective::RefAssociation
   {
      AResidentComponentInstanceLinkSet all_a_resident_component_instance_links()
         raises (Reflective::MofError);
      boolean exists (
         in Instance resident,
         in ComponentInstance component_instance)
         raises (Reflective::MofError);
      InstanceSet resident (in ComponentInstance component_instance)
         raises (Reflective::MofError);
      ComponentInstance component_instance (in Instance resident)
         raises (Reflective::MofError);
      void add (
         in Instance resident,
         in ComponentInstance component_instance)
         raises (Reflective::MofError);
      void modify_resident (
         in Instance resident,
         in ComponentInstance component_instance,
         in Instance new_resident)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_component_instance (
         in Instance resident,
         in ComponentInstance component_instance,
         in ComponentInstance new_component_instance)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Instance resident,
         in ComponentInstance component_instance)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AResidentComponentInstance

   struct AReceiverStimulusLink
   {
      Instance receiver;
      CommonBehavior::Stimulus stimulus;
   };
   typedef sequence<AReceiverStimulusLink> AReceiverStimulusLinkSet;

   interface AReceiverStimulus : Reflective::RefAssociation
   {
      AReceiverStimulusLinkSet all_a_receiver_stimulus_links()
         raises (Reflective::MofError);
      boolean exists (
         in Instance receiver,
         in CommonBehavior::Stimulus stimulus)
         raises (Reflective::MofError);
      Instance receiver (in CommonBehavior::Stimulus stimulus)
         raises (Reflective::MofError);
      StimulusSet stimulus (in Instance receiver)
         raises (Reflective::MofError);
      void add (
         in Instance receiver,
         in CommonBehavior::Stimulus stimulus)
         raises (Reflective::MofError);
      void modify_receiver (
         in Instance receiver,
         in CommonBehavior::Stimulus stimulus,
         in Instance new_receiver)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_stimulus (
         in Instance receiver,
         in CommonBehavior::Stimulus stimulus,
         in CommonBehavior::Stimulus new_stimulus)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Instance receiver,
         in CommonBehavior::Stimulus stimulus)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AReceiverStimulus

   struct AStimulusCommunicationLinkLink
   {
      CommonBehavior::Stimulus stimulus;
      Link communication_link;
   };
   typedef sequence<AStimulusCommunicationLinkLink> AStimulusCommunicationLinkLinkSet;

   interface AStimulusCommunicationLink : Reflective::RefAssociation
   {
      AStimulusCommunicationLinkLinkSet all_a_stimulus_communication_link_links()
         raises (Reflective::MofError);
      boolean exists (
         in CommonBehavior::Stimulus stimulus,
         in Link communication_link)
         raises (Reflective::MofError);
      StimulusSet stimulus (in Link communication_link)
         raises (Reflective::MofError);
      Link communication_link (in CommonBehavior::Stimulus stimulus)
         raises (Reflective::MofError);
      void add (
         in CommonBehavior::Stimulus stimulus,
         in Link communication_link)
         raises (Reflective::MofError);
      void modify_stimulus (
         in CommonBehavior::Stimulus stimulus,
         in Link communication_link,
         in CommonBehavior::Stimulus new_stimulus)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_communication_link (
         in CommonBehavior::Stimulus stimulus,
         in Link communication_link,
         in Link new_communication_link)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CommonBehavior::Stimulus stimulus,
         in Link communication_link)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AStimulusCommunicationLink

   struct ALinkEndQualifiedValueLink
   {
      LinkEnd link_end;
      AttributeLink qualified_value;
   };
   typedef sequence<ALinkEndQualifiedValueLink> ALinkEndQualifiedValueLinkSet;

   interface ALinkEndQualifiedValue : Reflective::RefAssociation
   {
      ALinkEndQualifiedValueLinkSet all_a_link_end_qualified_value_links()
         raises (Reflective::MofError);
      boolean exists (
         in LinkEnd link_end,
         in AttributeLink qualified_value)
         raises (Reflective::MofError);
      LinkEnd link_end (in AttributeLink qualified_value)
         raises (Reflective::MofError);
      AttributeLinkUList qualified_value (in LinkEnd link_end)
         raises (Reflective::MofError);
      void add (
         in LinkEnd link_end,
         in AttributeLink qualified_value)
         raises (Reflective::MofError);
      void add_before_qualified_value (
         in LinkEnd link_end,
         in AttributeLink qualified_value,
         in AttributeLink before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_link_end (
         in LinkEnd link_end,
         in AttributeLink qualified_value,
         in LinkEnd new_link_end)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_qualified_value (
         in LinkEnd link_end,
         in AttributeLink qualified_value,
         in AttributeLink new_qualified_value)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in LinkEnd link_end,
         in AttributeLink qualified_value)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ALinkEndQualifiedValue

   struct AOwnedInstanceOwnerLink
   {
      Instance owned_instance;
      Instance owner;
   };
   typedef sequence<AOwnedInstanceOwnerLink> AOwnedInstanceOwnerLinkSet;

   interface AOwnedInstanceOwner : Reflective::RefAssociation
   {
      AOwnedInstanceOwnerLinkSet all_a_owned_instance_owner_links()
         raises (Reflective::MofError);
      boolean exists (
         in Instance owned_instance,
         in Instance owner)
         raises (Reflective::MofError);
      InstanceSet owned_instance (in Instance owner)
         raises (Reflective::MofError);
      Instance owner (in Instance owned_instance)
         raises (Reflective::MofError);
      void add (
         in Instance owned_instance,
         in Instance owner)
         raises (Reflective::MofError);
      void modify_owned_instance (
         in Instance owned_instance,
         in Instance owner,
         in Instance new_owned_instance)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_owner (
         in Instance owned_instance,
         in Instance owner,
         in Instance new_owner)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Instance owned_instance,
         in Instance owner)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AOwnedInstanceOwner

   struct AOwnedLinkOwnerLink
   {
      Link owned_link;
      Instance owner;
   };
   typedef sequence<AOwnedLinkOwnerLink> AOwnedLinkOwnerLinkSet;

   interface AOwnedLinkOwner : Reflective::RefAssociation
   {
      AOwnedLinkOwnerLinkSet all_a_owned_link_owner_links()
         raises (Reflective::MofError);
      boolean exists (
         in Link owned_link,
         in Instance owner)
         raises (Reflective::MofError);
      LinkSet owned_link (in Instance owner)
         raises (Reflective::MofError);
      Instance owner (in Link owned_link)
         raises (Reflective::MofError);
      void add (
         in Link owned_link,
         in Instance owner)
         raises (Reflective::MofError);
      void modify_owned_link (
         in Link owned_link,
         in Instance owner,
         in Link new_owned_link)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_owner (
         in Link owned_link,
         in Instance owner,
         in Instance new_owner)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Link owned_link,
         in Instance owner)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AOwnedLinkOwner

   struct AExpressionProcedureLink
   {
      DataTypes::Expression expression;
      CommonBehavior::Procedure procedure;
   };
   typedef sequence<AExpressionProcedureLink> AExpressionProcedureLinkSet;

   interface AExpressionProcedure : Reflective::RefAssociation
   {
      AExpressionProcedureLinkSet all_a_expression_procedure_links()
         raises (Reflective::MofError);
      boolean exists (
         in DataTypes::Expression expression,
         in CommonBehavior::Procedure procedure)
         raises (Reflective::MofError);
      DataTypes::Expression expression (in CommonBehavior::Procedure procedure)
         raises (Reflective::MofError);
      CommonBehavior::Procedure procedure (in DataTypes::Expression expression)
         raises (Reflective::MofError);
      void add (
         in DataTypes::Expression expression,
         in CommonBehavior::Procedure procedure)
         raises (Reflective::MofError);
      void modify_expression (
         in DataTypes::Expression expression,
         in CommonBehavior::Procedure procedure,
         in DataTypes::Expression new_expression)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_procedure (
         in DataTypes::Expression expression,
         in CommonBehavior::Procedure procedure,
         in CommonBehavior::Procedure new_procedure)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in DataTypes::Expression expression,
         in CommonBehavior::Procedure procedure)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AExpressionProcedure

   struct ADispatchActionStimulusLink
   {
      Procedure dispatch_action;
      CommonBehavior::Stimulus stimulus;
   };
   typedef sequence<ADispatchActionStimulusLink> ADispatchActionStimulusLinkSet;

   interface ADispatchActionStimulus : Reflective::RefAssociation
   {
      ADispatchActionStimulusLinkSet all_a_dispatch_action_stimulus_links()
         raises (Reflective::MofError);
      boolean exists (
         in Procedure dispatch_action,
         in CommonBehavior::Stimulus stimulus)
         raises (Reflective::MofError);
      Procedure dispatch_action (in CommonBehavior::Stimulus stimulus)
         raises (Reflective::MofError);
      StimulusSet stimulus (in Procedure dispatch_action)
         raises (Reflective::MofError);
      void add (
         in Procedure dispatch_action,
         in CommonBehavior::Stimulus stimulus)
         raises (Reflective::MofError);
      void modify_dispatch_action (
         in Procedure dispatch_action,
         in CommonBehavior::Stimulus stimulus,
         in Procedure new_dispatch_action)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_stimulus (
         in Procedure dispatch_action,
         in CommonBehavior::Stimulus stimulus,
         in CommonBehavior::Stimulus new_stimulus)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Procedure dispatch_action,
         in CommonBehavior::Stimulus stimulus)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ADispatchActionStimulus

   struct AProcedureMethodLink
   {
      CommonBehavior::Procedure procedure;
      Core::Method method;
   };
   typedef sequence<AProcedureMethodLink> AProcedureMethodLinkSet;

   interface AProcedureMethod : Reflective::RefAssociation
   {
      AProcedureMethodLinkSet all_a_procedure_method_links()
         raises (Reflective::MofError);
      boolean exists (
         in CommonBehavior::Procedure procedure,
         in Core::Method method)
         raises (Reflective::MofError);
      CommonBehavior::Procedure procedure (in Core::Method method)
         raises (Reflective::MofError);
      Core::Method method (in CommonBehavior::Procedure procedure)
         raises (Reflective::MofError);
      void add (
         in CommonBehavior::Procedure procedure,
         in Core::Method method)
         raises (Reflective::MofError);
      void modify_procedure (
         in CommonBehavior::Procedure procedure,
         in Core::Method method,
         in CommonBehavior::Procedure new_procedure)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_method (
         in CommonBehavior::Procedure procedure,
         in Core::Method method,
         in Core::Method new_method)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CommonBehavior::Procedure procedure,
         in Core::Method method)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AProcedureMethod

   interface CommonBehaviorPackageFactory
   {
      CommonBehaviorPackage create_common_behavior_package ()
         raises (Reflective::MofError);
   };

   interface CommonBehaviorPackage : Reflective::RefPackage
   {
      readonly attribute DataTypes::DataTypesPackage data_types_ref;
      readonly attribute Core::CorePackage core_ref;
      readonly attribute InstanceClass instance_ref;
      readonly attribute SignalClass signal_ref;
      readonly attribute UninterpretedActionClass uninterpreted_action_ref;
      readonly attribute AttributeLinkClass attribute_link_ref;
      readonly attribute UmlObjectClass uml_object_ref;
      readonly attribute LinkClass link_ref;
      readonly attribute LinkObjectClass link_object_ref;
      readonly attribute DataValueClass data_value_ref;
      readonly attribute ReceptionClass reception_ref;
      readonly attribute LinkEndClass link_end_ref;
      readonly attribute TerminateActionClass terminate_action_ref;
      readonly attribute StimulusClass stimulus_ref;
      readonly attribute UmlExceptionClass uml_exception_ref;
      readonly attribute ComponentInstanceClass component_instance_ref;
      readonly attribute NodeInstanceClass node_instance_ref;
      readonly attribute SubsystemInstanceClass subsystem_instance_ref;
      readonly attribute ProcedureClass procedure_ref;
      readonly attribute AInstanceClassifier a_instance_classifier_ref;
      readonly attribute AAttributeLinkAttribute a_attribute_link_attribute_ref;
      readonly attribute AAttributeLinkValue a_attribute_link_value_ref;
      readonly attribute AInstanceLinkEnd a_instance_link_end_ref;
      readonly attribute ASignalReception a_signal_reception_ref;
      readonly attribute ASlotInstance a_slot_instance_ref;
      readonly attribute AArgumentStimulus a_argument_stimulus_ref;
      readonly attribute AContextRaisedSignal a_context_raised_signal_ref;
      readonly attribute AAssociationLink a_association_link_ref;
      readonly attribute ALinkConnection a_link_connection_ref;
      readonly attribute AAssociationEndLinkEnd a_association_end_link_end_ref;
      readonly attribute AStimulusSender a_stimulus_sender_ref;
      readonly attribute AResidentNodeInstance a_resident_node_instance_ref;
      readonly attribute AResidentComponentInstance a_resident_component_instance_ref;
      readonly attribute AReceiverStimulus a_receiver_stimulus_ref;
      readonly attribute AStimulusCommunicationLink a_stimulus_communication_link_ref;
      readonly attribute ALinkEndQualifiedValue a_link_end_qualified_value_ref;
      readonly attribute AOwnedInstanceOwner a_owned_instance_owner_ref;
      readonly attribute AOwnedLinkOwner a_owned_link_owner_ref;
      readonly attribute AExpressionProcedure a_expression_procedure_ref;
      readonly attribute ADispatchActionStimulus a_dispatch_action_stimulus_ref;
      readonly attribute AProcedureMethod a_procedure_method_ref;
   };
};

#endif