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

module Collaborations
{
   typedef sequence<CommonBehavior::Stimulus> StimulusSet;
   typedef sequence<CommonBehavior::Instance> InstanceSet;
   typedef sequence<Core::Classifier> ClassifierSet;
   typedef sequence<Core::ModelElement> ModelElementSet;
   typedef sequence<Core::UmlAttribute> UmlAttributeSet;
   typedef sequence<CommonBehavior::Link> LinkSet;
   typedef sequence<Core::Feature> FeatureSet;
   interface CollaborationClass;
   interface Collaboration;
   typedef sequence<Collaboration> CollaborationSet;
   interface ClassifierRoleClass;
   interface ClassifierRole;
   typedef sequence<ClassifierRole> ClassifierRoleSet;
   interface AssociationRoleClass;
   interface AssociationRole;
   typedef sequence<AssociationRole> AssociationRoleSet;
   interface AssociationEndRoleClass;
   interface AssociationEndRole;
   typedef sequence<AssociationEndRole> AssociationEndRoleSet;
   interface MessageClass;
   interface Message;
   typedef sequence<Message> MessageSet;
   interface InteractionClass;
   interface Interaction;
   typedef sequence<Interaction> InteractionSet;
   interface InteractionInstanceSetClass;
   interface InteractionInstanceSet;
   typedef sequence<InteractionInstanceSet> InteractionInstanceSetSet;
   interface CollaborationInstanceSetClass;
   interface CollaborationInstanceSet;
   typedef sequence<CollaborationInstanceSet> CollaborationInstanceSetSet;
   interface CollaborationsPackage;

   interface CollaborationClass : Core::GeneralizableElementClass, Core::NamespaceClass
   {
      readonly attribute CollaborationSet all_of_type_collaboration;
      readonly attribute CollaborationSet all_of_class_collaboration;
      Collaboration create_collaboration (
         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 Collaboration : CollaborationClass, Core::GeneralizableElement, Core::Namespace
   {
      InteractionSet interaction ()
         raises (Reflective::MofError);
      void set_interaction (in InteractionSet new_value)
         raises (Reflective::MofError);
      void unset_interaction ()
         raises (Reflective::MofError);
      void add_interaction (in Collaborations::Interaction new_element)
         raises (Reflective::MofError);
      void modify_interaction (
         in Collaborations::Interaction old_element,
         in Collaborations::Interaction new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_interaction (in Collaborations::Interaction old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      Core::Classifier represented_classifier ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_represented_classifier (in Core::Classifier new_value)
         raises (Reflective::MofError);
      void unset_represented_classifier ()
         raises (Reflective::MofError);
      Core::Operation represented_operation ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_represented_operation (in Core::Operation new_value)
         raises (Reflective::MofError);
      void unset_represented_operation ()
         raises (Reflective::MofError);
      ModelElementSet constraining_element ()
         raises (Reflective::MofError);
      void set_constraining_element (in ModelElementSet new_value)
         raises (Reflective::MofError);
      void unset_constraining_element ()
         raises (Reflective::MofError);
      void add_constraining_element (in Core::ModelElement new_element)
         raises (Reflective::MofError);
      void modify_constraining_element (
         in Core::ModelElement old_element,
         in Core::ModelElement new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_constraining_element (in Core::ModelElement old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      CollaborationSet used_collaboration ()
         raises (Reflective::MofError);
      void set_used_collaboration (in CollaborationSet new_value)
         raises (Reflective::MofError);
      void unset_used_collaboration ()
         raises (Reflective::MofError);
      void add_used_collaboration (in Collaboration new_element)
         raises (Reflective::MofError);
      void modify_used_collaboration (
         in Collaboration old_element,
         in Collaboration new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_used_collaboration (in Collaboration old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Collaboration

   interface ClassifierRoleClass : Core::ClassifierClass
   {
      readonly attribute ClassifierRoleSet all_of_type_classifier_role;
      readonly attribute ClassifierRoleSet all_of_class_classifier_role;
      ClassifierRole create_classifier_role (
         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::Multiplicity multiplicity)
         raises (Reflective::MofError);
   };

   interface ClassifierRole : ClassifierRoleClass, Core::Classifier
   {
      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);
      ClassifierSet base ()
         raises (Reflective::MofError);
      void set_base (in ClassifierSet new_value)
         raises (Reflective::MofError);
      void add_base (in Core::Classifier new_element)
         raises (Reflective::MofError);
      void modify_base (
         in Core::Classifier old_element,
         in Core::Classifier new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_base (in Core::Classifier old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      FeatureSet available_feature ()
         raises (Reflective::MofError);
      void set_available_feature (in FeatureSet new_value)
         raises (Reflective::MofError);
      void unset_available_feature ()
         raises (Reflective::MofError);
      void add_available_feature (in Core::Feature new_element)
         raises (Reflective::MofError);
      void modify_available_feature (
         in Core::Feature old_element,
         in Core::Feature new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_available_feature (in Core::Feature old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ModelElementSet available_contents ()
         raises (Reflective::MofError);
      void set_available_contents (in ModelElementSet new_value)
         raises (Reflective::MofError);
      void unset_available_contents ()
         raises (Reflective::MofError);
      void add_available_contents (in Core::ModelElement new_element)
         raises (Reflective::MofError);
      void modify_available_contents (
         in Core::ModelElement old_element,
         in Core::ModelElement new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_available_contents (in Core::ModelElement old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      InstanceSet conforming_instance ()
         raises (Reflective::MofError);
      void set_conforming_instance (in InstanceSet new_value)
         raises (Reflective::MofError);
      void unset_conforming_instance ()
         raises (Reflective::MofError);
      void add_conforming_instance (in CommonBehavior::Instance new_element)
         raises (Reflective::MofError);
      void modify_conforming_instance (
         in CommonBehavior::Instance old_element,
         in CommonBehavior::Instance new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_conforming_instance (in CommonBehavior::Instance old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ClassifierRole

   interface AssociationRoleClass : Core::AssociationClass
   {
      readonly attribute AssociationRoleSet all_of_type_association_role;
      readonly attribute AssociationRoleSet all_of_class_association_role;
      AssociationRole create_association_role (
         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::Multiplicity multiplicity)
         raises (Reflective::MofError);
   };

   interface AssociationRole : AssociationRoleClass, Core::Association
   {
      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::Association base ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_base (in Core::Association new_value)
         raises (Reflective::MofError);
      void unset_base ()
         raises (Reflective::MofError);
      MessageSet message ()
         raises (Reflective::MofError);
      void set_message (in MessageSet new_value)
         raises (Reflective::MofError);
      void unset_message ()
         raises (Reflective::MofError);
      void add_message (in Collaborations::Message new_element)
         raises (Reflective::MofError);
      void modify_message (
         in Collaborations::Message old_element,
         in Collaborations::Message new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_message (in Collaborations::Message old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      LinkSet conforming_link ()
         raises (Reflective::MofError);
      void set_conforming_link (in LinkSet new_value)
         raises (Reflective::MofError);
      void unset_conforming_link ()
         raises (Reflective::MofError);
      void add_conforming_link (in CommonBehavior::Link new_element)
         raises (Reflective::MofError);
      void modify_conforming_link (
         in CommonBehavior::Link old_element,
         in CommonBehavior::Link new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_conforming_link (in CommonBehavior::Link old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AssociationRole

   interface AssociationEndRoleClass : Core::AssociationEndClass
   {
      readonly attribute AssociationEndRoleSet all_of_type_association_end_role;
      readonly attribute AssociationEndRoleSet all_of_class_association_end_role;
      AssociationEndRole create_association_end_role (
         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,
         in DataTypes::Multiplicity collaboration_multiplicity)
         raises (Reflective::MofError);
   };

   interface AssociationEndRole : AssociationEndRoleClass, Core::AssociationEnd
   {
      DataTypes::Multiplicity collaboration_multiplicity ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_collaboration_multiplicity (in DataTypes::Multiplicity new_value)
         raises (Reflective::MofError);
      void unset_collaboration_multiplicity ()
         raises (Reflective::MofError);
      Core::AssociationEnd base ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_base (in Core::AssociationEnd new_value)
         raises (Reflective::MofError);
      void unset_base ()
         raises (Reflective::MofError);
      UmlAttributeSet available_qualifier ()
         raises (Reflective::MofError);
      void set_available_qualifier (in UmlAttributeSet new_value)
         raises (Reflective::MofError);
      void unset_available_qualifier ()
         raises (Reflective::MofError);
      void add_available_qualifier (in Core::UmlAttribute new_element)
         raises (Reflective::MofError);
      void modify_available_qualifier (
         in Core::UmlAttribute old_element,
         in Core::UmlAttribute new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_available_qualifier (in Core::UmlAttribute old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AssociationEndRole

   interface MessageClass : Core::ModelElementClass
   {
      readonly attribute MessageSet all_of_type_message;
      readonly attribute MessageSet all_of_class_message;
      Message create_message (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface Message : MessageClass, Core::ModelElement
   {
      Collaborations::Interaction interaction ()
         raises (Reflective::MofError);
      void set_interaction (in Collaborations::Interaction new_value)
         raises (Reflective::MofError);
      Message activator ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_activator (in Message new_value)
         raises (Reflective::MofError);
      void unset_activator ()
         raises (Reflective::MofError);
      ClassifierRole sender ()
         raises (Reflective::MofError);
      void set_sender (in ClassifierRole new_value)
         raises (Reflective::MofError);
      ClassifierRole receiver ()
         raises (Reflective::MofError);
      void set_receiver (in ClassifierRole new_value)
         raises (Reflective::MofError);
      MessageSet predecessor ()
         raises (Reflective::MofError);
      void set_predecessor (in MessageSet new_value)
         raises (Reflective::MofError);
      void unset_predecessor ()
         raises (Reflective::MofError);
      void add_predecessor (in Message new_element)
         raises (Reflective::MofError);
      void modify_predecessor (
         in Message old_element,
         in Message new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_predecessor (in Message old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      AssociationRole communication_connection ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_communication_connection (in AssociationRole new_value)
         raises (Reflective::MofError);
      void unset_communication_connection ()
         raises (Reflective::MofError);
      CommonBehavior::Procedure procedure ()
         raises (Reflective::MofError);
      void set_procedure (in CommonBehavior::Procedure new_value)
         raises (Reflective::MofError);
      StimulusSet conforming_stimulus ()
         raises (Reflective::MofError);
      void set_conforming_stimulus (in StimulusSet new_value)
         raises (Reflective::MofError);
      void unset_conforming_stimulus ()
         raises (Reflective::MofError);
      void add_conforming_stimulus (in CommonBehavior::Stimulus new_element)
         raises (Reflective::MofError);
      void modify_conforming_stimulus (
         in CommonBehavior::Stimulus old_element,
         in CommonBehavior::Stimulus new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_conforming_stimulus (in CommonBehavior::Stimulus old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Message

   interface InteractionClass : Core::ModelElementClass
   {
      readonly attribute InteractionSet all_of_type_interaction;
      readonly attribute InteractionSet all_of_class_interaction;
      Interaction create_interaction (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface Interaction : InteractionClass, Core::ModelElement
   {
      MessageSet message ()
         raises (Reflective::MofError);
      void set_message (in MessageSet new_value)
         raises (Reflective::MofError);
      void add_message (in Collaborations::Message new_element)
         raises (Reflective::MofError);
      void modify_message (
         in Collaborations::Message old_element,
         in Collaborations::Message new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_message (in Collaborations::Message old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      Collaboration uml_context ()
         raises (Reflective::MofError);
      void set_uml_context (in Collaboration new_value)
         raises (Reflective::MofError);
   }; // end of interface Interaction

   interface InteractionInstanceSetClass : Core::ModelElementClass
   {
      readonly attribute InteractionInstanceSetSet all_of_type_interaction_instance_set;
      readonly attribute InteractionInstanceSetSet all_of_class_interaction_instance_set;
      InteractionInstanceSet create_interaction_instance_set (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface InteractionInstanceSet : InteractionInstanceSetClass, Core::ModelElement
   {
      CollaborationInstanceSet uml_context ()
         raises (Reflective::MofError);
      void set_uml_context (in CollaborationInstanceSet new_value)
         raises (Reflective::MofError);
      Collaborations::Interaction interaction ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_interaction (in Collaborations::Interaction new_value)
         raises (Reflective::MofError);
      void unset_interaction ()
         raises (Reflective::MofError);
      StimulusSet participating_stimulus ()
         raises (Reflective::MofError);
      void set_participating_stimulus (in StimulusSet new_value)
         raises (Reflective::MofError);
      void add_participating_stimulus (in CommonBehavior::Stimulus new_element)
         raises (Reflective::MofError);
      void modify_participating_stimulus (
         in CommonBehavior::Stimulus old_element,
         in CommonBehavior::Stimulus new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_participating_stimulus (in CommonBehavior::Stimulus old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface InteractionInstanceSet

   interface CollaborationInstanceSetClass : Core::ModelElementClass
   {
      readonly attribute CollaborationInstanceSetSet all_of_type_collaboration_instance_set;
      readonly attribute CollaborationInstanceSetSet all_of_class_collaboration_instance_set;
      CollaborationInstanceSet create_collaboration_instance_set (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface CollaborationInstanceSet : CollaborationInstanceSetClass, Core::ModelElement
   {
      InteractionInstanceSetSet interaction_instance_set ()
         raises (Reflective::MofError);
      void set_interaction_instance_set (in InteractionInstanceSetSet new_value)
         raises (Reflective::MofError);
      void unset_interaction_instance_set ()
         raises (Reflective::MofError);
      void add_interaction_instance_set (in InteractionInstanceSet new_element)
         raises (Reflective::MofError);
      void modify_interaction_instance_set (
         in InteractionInstanceSet old_element,
         in InteractionInstanceSet new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_interaction_instance_set (in InteractionInstanceSet old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      Collaborations::Collaboration collaboration ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_collaboration (in Collaborations::Collaboration new_value)
         raises (Reflective::MofError);
      void unset_collaboration ()
         raises (Reflective::MofError);
      InstanceSet participating_instance ()
         raises (Reflective::MofError);
      void set_participating_instance (in InstanceSet new_value)
         raises (Reflective::MofError);
      void add_participating_instance (in CommonBehavior::Instance new_element)
         raises (Reflective::MofError);
      void modify_participating_instance (
         in CommonBehavior::Instance old_element,
         in CommonBehavior::Instance new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_participating_instance (in CommonBehavior::Instance old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      LinkSet participating_link ()
         raises (Reflective::MofError);
      void set_participating_link (in LinkSet new_value)
         raises (Reflective::MofError);
      void unset_participating_link ()
         raises (Reflective::MofError);
      void add_participating_link (in CommonBehavior::Link new_element)
         raises (Reflective::MofError);
      void modify_participating_link (
         in CommonBehavior::Link old_element,
         in CommonBehavior::Link new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_participating_link (in CommonBehavior::Link old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ModelElementSet constraining_element ()
         raises (Reflective::MofError);
      void set_constraining_element (in ModelElementSet new_value)
         raises (Reflective::MofError);
      void unset_constraining_element ()
         raises (Reflective::MofError);
      void add_constraining_element (in Core::ModelElement new_element)
         raises (Reflective::MofError);
      void modify_constraining_element (
         in Core::ModelElement old_element,
         in Core::ModelElement new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_constraining_element (in Core::ModelElement old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface CollaborationInstanceSet

   struct AInteractionMessageLink
   {
      Collaborations::Interaction interaction;
      Collaborations::Message message;
   };
   typedef sequence<AInteractionMessageLink> AInteractionMessageLinkSet;

   interface AInteractionMessage : Reflective::RefAssociation
   {
      AInteractionMessageLinkSet all_a_interaction_message_links()
         raises (Reflective::MofError);
      boolean exists (
         in Collaborations::Interaction interaction,
         in Collaborations::Message message)
         raises (Reflective::MofError);
      Collaborations::Interaction interaction (in Collaborations::Message message)
         raises (Reflective::MofError);
      MessageSet message (in Collaborations::Interaction interaction)
         raises (Reflective::MofError);
      void add (
         in Collaborations::Interaction interaction,
         in Collaborations::Message message)
         raises (Reflective::MofError);
      void modify_interaction (
         in Collaborations::Interaction interaction,
         in Collaborations::Message message,
         in Collaborations::Interaction new_interaction)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_message (
         in Collaborations::Interaction interaction,
         in Collaborations::Message message,
         in Collaborations::Message new_message)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Collaborations::Interaction interaction,
         in Collaborations::Message message)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AInteractionMessage

   struct AContextInteractionLink
   {
      Collaboration uml_context;
      Collaborations::Interaction interaction;
   };
   typedef sequence<AContextInteractionLink> AContextInteractionLinkSet;

   interface AContextInteraction : Reflective::RefAssociation
   {
      AContextInteractionLinkSet all_a_context_interaction_links()
         raises (Reflective::MofError);
      boolean exists (
         in Collaboration uml_context,
         in Collaborations::Interaction interaction)
         raises (Reflective::MofError);
      Collaboration uml_context (in Collaborations::Interaction interaction)
         raises (Reflective::MofError);
      InteractionSet interaction (in Collaboration uml_context)
         raises (Reflective::MofError);
      void add (
         in Collaboration uml_context,
         in Collaborations::Interaction interaction)
         raises (Reflective::MofError);
      void modify_uml_context (
         in Collaboration uml_context,
         in Collaborations::Interaction interaction,
         in Collaboration new_uml_context)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_interaction (
         in Collaboration uml_context,
         in Collaborations::Interaction interaction,
         in Collaborations::Interaction new_interaction)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Collaboration uml_context,
         in Collaborations::Interaction interaction)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AContextInteraction

   struct AClassifierRoleBaseLink
   {
      ClassifierRole classifier_role;
      Core::Classifier base;
   };
   typedef sequence<AClassifierRoleBaseLink> AClassifierRoleBaseLinkSet;

   interface AClassifierRoleBase : Reflective::RefAssociation
   {
      AClassifierRoleBaseLinkSet all_a_classifier_role_base_links()
         raises (Reflective::MofError);
      boolean exists (
         in ClassifierRole classifier_role,
         in Core::Classifier base)
         raises (Reflective::MofError);
      ClassifierRoleSet classifier_role (in Core::Classifier base)
         raises (Reflective::MofError);
      ClassifierSet base (in ClassifierRole classifier_role)
         raises (Reflective::MofError);
      void add (
         in ClassifierRole classifier_role,
         in Core::Classifier base)
         raises (Reflective::MofError);
      void modify_classifier_role (
         in ClassifierRole classifier_role,
         in Core::Classifier base,
         in ClassifierRole new_classifier_role)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_base (
         in ClassifierRole classifier_role,
         in Core::Classifier base,
         in Core::Classifier new_base)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ClassifierRole classifier_role,
         in Core::Classifier base)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AClassifierRoleBase

   struct ABaseAssociationEndRoleLink
   {
      Core::AssociationEnd base;
      AssociationEndRole association_end_role;
   };
   typedef sequence<ABaseAssociationEndRoleLink> ABaseAssociationEndRoleLinkSet;

   interface ABaseAssociationEndRole : Reflective::RefAssociation
   {
      ABaseAssociationEndRoleLinkSet all_a_base_association_end_role_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::AssociationEnd base,
         in AssociationEndRole association_end_role)
         raises (Reflective::MofError);
      Core::AssociationEnd base (in AssociationEndRole association_end_role)
         raises (Reflective::MofError);
      AssociationEndRoleSet association_end_role (in Core::AssociationEnd base)
         raises (Reflective::MofError);
      void add (
         in Core::AssociationEnd base,
         in AssociationEndRole association_end_role)
         raises (Reflective::MofError);
      void modify_base (
         in Core::AssociationEnd base,
         in AssociationEndRole association_end_role,
         in Core::AssociationEnd new_base)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_association_end_role (
         in Core::AssociationEnd base,
         in AssociationEndRole association_end_role,
         in AssociationEndRole new_association_end_role)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::AssociationEnd base,
         in AssociationEndRole association_end_role)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ABaseAssociationEndRole

   struct ABaseAssociationRoleLink
   {
      Core::Association base;
      AssociationRole association_role;
   };
   typedef sequence<ABaseAssociationRoleLink> ABaseAssociationRoleLinkSet;

   interface ABaseAssociationRole : Reflective::RefAssociation
   {
      ABaseAssociationRoleLinkSet all_a_base_association_role_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Association base,
         in AssociationRole association_role)
         raises (Reflective::MofError);
      Core::Association base (in AssociationRole association_role)
         raises (Reflective::MofError);
      AssociationRoleSet association_role (in Core::Association base)
         raises (Reflective::MofError);
      void add (
         in Core::Association base,
         in AssociationRole association_role)
         raises (Reflective::MofError);
      void modify_base (
         in Core::Association base,
         in AssociationRole association_role,
         in Core::Association new_base)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_association_role (
         in Core::Association base,
         in AssociationRole association_role,
         in AssociationRole new_association_role)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Association base,
         in AssociationRole association_role)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ABaseAssociationRole

   struct AClassifierRoleAvailableFeatureLink
   {
      ClassifierRole classifier_role;
      Core::Feature available_feature;
   };
   typedef sequence<AClassifierRoleAvailableFeatureLink> AClassifierRoleAvailableFeatureLinkSet;

   interface AClassifierRoleAvailableFeature : Reflective::RefAssociation
   {
      AClassifierRoleAvailableFeatureLinkSet all_a_classifier_role_available_feature_links()
         raises (Reflective::MofError);
      boolean exists (
         in ClassifierRole classifier_role,
         in Core::Feature available_feature)
         raises (Reflective::MofError);
      ClassifierRoleSet classifier_role (in Core::Feature available_feature)
         raises (Reflective::MofError);
      FeatureSet available_feature (in ClassifierRole classifier_role)
         raises (Reflective::MofError);
      void add (
         in ClassifierRole classifier_role,
         in Core::Feature available_feature)
         raises (Reflective::MofError);
      void modify_classifier_role (
         in ClassifierRole classifier_role,
         in Core::Feature available_feature,
         in ClassifierRole new_classifier_role)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_available_feature (
         in ClassifierRole classifier_role,
         in Core::Feature available_feature,
         in Core::Feature new_available_feature)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ClassifierRole classifier_role,
         in Core::Feature available_feature)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AClassifierRoleAvailableFeature

   struct AMessageActivatorLink
   {
      Collaborations::Message message;
      Collaborations::Message activator;
   };
   typedef sequence<AMessageActivatorLink> AMessageActivatorLinkSet;

   interface AMessageActivator : Reflective::RefAssociation
   {
      AMessageActivatorLinkSet all_a_message_activator_links()
         raises (Reflective::MofError);
      boolean exists (
         in Collaborations::Message message,
         in Collaborations::Message activator)
         raises (Reflective::MofError);
      MessageSet message (in Collaborations::Message activator)
         raises (Reflective::MofError);
      Collaborations::Message activator (in Collaborations::Message message)
         raises (Reflective::MofError);
      void add (
         in Collaborations::Message message,
         in Collaborations::Message activator)
         raises (Reflective::MofError);
      void modify_message (
         in Collaborations::Message message,
         in Collaborations::Message activator,
         in Collaborations::Message new_message)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_activator (
         in Collaborations::Message message,
         in Collaborations::Message activator,
         in Collaborations::Message new_activator)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Collaborations::Message message,
         in Collaborations::Message activator)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AMessageActivator

   struct AMessageSenderLink
   {
      Collaborations::Message message;
      ClassifierRole sender;
   };
   typedef sequence<AMessageSenderLink> AMessageSenderLinkSet;

   interface AMessageSender : Reflective::RefAssociation
   {
      AMessageSenderLinkSet all_a_message_sender_links()
         raises (Reflective::MofError);
      boolean exists (
         in Collaborations::Message message,
         in ClassifierRole sender)
         raises (Reflective::MofError);
      MessageSet message (in ClassifierRole sender)
         raises (Reflective::MofError);
      ClassifierRole sender (in Collaborations::Message message)
         raises (Reflective::MofError);
      void add (
         in Collaborations::Message message,
         in ClassifierRole sender)
         raises (Reflective::MofError);
      void modify_message (
         in Collaborations::Message message,
         in ClassifierRole sender,
         in Collaborations::Message new_message)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_sender (
         in Collaborations::Message message,
         in ClassifierRole sender,
         in ClassifierRole new_sender)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Collaborations::Message message,
         in ClassifierRole sender)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AMessageSender

   struct AReceiverMessageLink
   {
      ClassifierRole receiver;
      Collaborations::Message message;
   };
   typedef sequence<AReceiverMessageLink> AReceiverMessageLinkSet;

   interface AReceiverMessage : Reflective::RefAssociation
   {
      AReceiverMessageLinkSet all_a_receiver_message_links()
         raises (Reflective::MofError);
      boolean exists (
         in ClassifierRole receiver,
         in Collaborations::Message message)
         raises (Reflective::MofError);
      ClassifierRole receiver (in Collaborations::Message message)
         raises (Reflective::MofError);
      MessageSet message (in ClassifierRole receiver)
         raises (Reflective::MofError);
      void add (
         in ClassifierRole receiver,
         in Collaborations::Message message)
         raises (Reflective::MofError);
      void modify_receiver (
         in ClassifierRole receiver,
         in Collaborations::Message message,
         in ClassifierRole new_receiver)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_message (
         in ClassifierRole receiver,
         in Collaborations::Message message,
         in Collaborations::Message new_message)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ClassifierRole receiver,
         in Collaborations::Message message)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AReceiverMessage

   struct APredecessorSuccessorLink
   {
      Message predecessor;
      Message successor;
   };
   typedef sequence<APredecessorSuccessorLink> APredecessorSuccessorLinkSet;

   interface APredecessorSuccessor : Reflective::RefAssociation
   {
      APredecessorSuccessorLinkSet all_a_predecessor_successor_links()
         raises (Reflective::MofError);
      boolean exists (
         in Message predecessor,
         in Message successor)
         raises (Reflective::MofError);
      MessageSet predecessor (in Message successor)
         raises (Reflective::MofError);
      MessageSet successor (in Message predecessor)
         raises (Reflective::MofError);
      void add (
         in Message predecessor,
         in Message successor)
         raises (Reflective::MofError);
      void modify_predecessor (
         in Message predecessor,
         in Message successor,
         in Message new_predecessor)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_successor (
         in Message predecessor,
         in Message successor,
         in Message new_successor)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Message predecessor,
         in Message successor)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface APredecessorSuccessor

   struct AMessageCommunicationConnectionLink
   {
      Collaborations::Message message;
      AssociationRole communication_connection;
   };
   typedef sequence<AMessageCommunicationConnectionLink> AMessageCommunicationConnectionLinkSet;

   interface AMessageCommunicationConnection : Reflective::RefAssociation
   {
      AMessageCommunicationConnectionLinkSet all_a_message_communication_connection_links()
         raises (Reflective::MofError);
      boolean exists (
         in Collaborations::Message message,
         in AssociationRole communication_connection)
         raises (Reflective::MofError);
      MessageSet message (in AssociationRole communication_connection)
         raises (Reflective::MofError);
      AssociationRole communication_connection (in Collaborations::Message message)
         raises (Reflective::MofError);
      void add (
         in Collaborations::Message message,
         in AssociationRole communication_connection)
         raises (Reflective::MofError);
      void modify_message (
         in Collaborations::Message message,
         in AssociationRole communication_connection,
         in Collaborations::Message new_message)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_communication_connection (
         in Collaborations::Message message,
         in AssociationRole communication_connection,
         in AssociationRole new_communication_connection)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Collaborations::Message message,
         in AssociationRole communication_connection)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AMessageCommunicationConnection

   struct AClassifierRoleAvailableContentsLink
   {
      ClassifierRole classifier_role;
      Core::ModelElement available_contents;
   };
   typedef sequence<AClassifierRoleAvailableContentsLink> AClassifierRoleAvailableContentsLinkSet;

   interface AClassifierRoleAvailableContents : Reflective::RefAssociation
   {
      AClassifierRoleAvailableContentsLinkSet all_a_classifier_role_available_contents_links()
         raises (Reflective::MofError);
      boolean exists (
         in ClassifierRole classifier_role,
         in Core::ModelElement available_contents)
         raises (Reflective::MofError);
      ClassifierRoleSet classifier_role (in Core::ModelElement available_contents)
         raises (Reflective::MofError);
      ModelElementSet available_contents (in ClassifierRole classifier_role)
         raises (Reflective::MofError);
      void add (
         in ClassifierRole classifier_role,
         in Core::ModelElement available_contents)
         raises (Reflective::MofError);
      void modify_classifier_role (
         in ClassifierRole classifier_role,
         in Core::ModelElement available_contents,
         in ClassifierRole new_classifier_role)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_available_contents (
         in ClassifierRole classifier_role,
         in Core::ModelElement available_contents,
         in Core::ModelElement new_available_contents)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ClassifierRole classifier_role,
         in Core::ModelElement available_contents)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AClassifierRoleAvailableContents

   struct AProcedureMessageLink
   {
      CommonBehavior::Procedure procedure;
      Collaborations::Message message;
   };
   typedef sequence<AProcedureMessageLink> AProcedureMessageLinkSet;

   interface AProcedureMessage : Reflective::RefAssociation
   {
      AProcedureMessageLinkSet all_a_procedure_message_links()
         raises (Reflective::MofError);
      boolean exists (
         in CommonBehavior::Procedure procedure,
         in Collaborations::Message message)
         raises (Reflective::MofError);
      CommonBehavior::Procedure procedure (in Collaborations::Message message)
         raises (Reflective::MofError);
      MessageSet message (in CommonBehavior::Procedure procedure)
         raises (Reflective::MofError);
      void add (
         in CommonBehavior::Procedure procedure,
         in Collaborations::Message message)
         raises (Reflective::MofError);
      void modify_procedure (
         in CommonBehavior::Procedure procedure,
         in Collaborations::Message message,
         in CommonBehavior::Procedure new_procedure)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_message (
         in CommonBehavior::Procedure procedure,
         in Collaborations::Message message,
         in Collaborations::Message new_message)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CommonBehavior::Procedure procedure,
         in Collaborations::Message message)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AProcedureMessage

   struct AAssociationEndRoleAvailableQualifierLink
   {
      AssociationEndRole association_end_role;
      Core::UmlAttribute available_qualifier;
   };
   typedef sequence<AAssociationEndRoleAvailableQualifierLink> AAssociationEndRoleAvailableQualifierLinkSet;

   interface AAssociationEndRoleAvailableQualifier : Reflective::RefAssociation
   {
      AAssociationEndRoleAvailableQualifierLinkSet all_a_association_end_role_available_qualifier_links()
         raises (Reflective::MofError);
      boolean exists (
         in AssociationEndRole association_end_role,
         in Core::UmlAttribute available_qualifier)
         raises (Reflective::MofError);
      AssociationEndRoleSet association_end_role (in Core::UmlAttribute available_qualifier)
         raises (Reflective::MofError);
      UmlAttributeSet available_qualifier (in AssociationEndRole association_end_role)
         raises (Reflective::MofError);
      void add (
         in AssociationEndRole association_end_role,
         in Core::UmlAttribute available_qualifier)
         raises (Reflective::MofError);
      void modify_association_end_role (
         in AssociationEndRole association_end_role,
         in Core::UmlAttribute available_qualifier,
         in AssociationEndRole new_association_end_role)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_available_qualifier (
         in AssociationEndRole association_end_role,
         in Core::UmlAttribute available_qualifier,
         in Core::UmlAttribute new_available_qualifier)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in AssociationEndRole association_end_role,
         in Core::UmlAttribute available_qualifier)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AAssociationEndRoleAvailableQualifier

   struct ARepresentedOperationCollaborationLink
   {
      Core::Operation represented_operation;
      Collaborations::Collaboration collaboration;
   };
   typedef sequence<ARepresentedOperationCollaborationLink> ARepresentedOperationCollaborationLinkSet;

   interface ARepresentedOperationCollaboration : Reflective::RefAssociation
   {
      ARepresentedOperationCollaborationLinkSet all_a_represented_operation_collaboration_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Operation represented_operation,
         in Collaborations::Collaboration collaboration)
         raises (Reflective::MofError);
      Core::Operation represented_operation (in Collaborations::Collaboration collaboration)
         raises (Reflective::MofError);
      CollaborationSet collaboration (in Core::Operation represented_operation)
         raises (Reflective::MofError);
      void add (
         in Core::Operation represented_operation,
         in Collaborations::Collaboration collaboration)
         raises (Reflective::MofError);
      void modify_represented_operation (
         in Core::Operation represented_operation,
         in Collaborations::Collaboration collaboration,
         in Core::Operation new_represented_operation)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_collaboration (
         in Core::Operation represented_operation,
         in Collaborations::Collaboration collaboration,
         in Collaborations::Collaboration new_collaboration)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Operation represented_operation,
         in Collaborations::Collaboration collaboration)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ARepresentedOperationCollaboration

   struct ACollaborationConstrainingElementLink
   {
      Collaborations::Collaboration collaboration;
      Core::ModelElement constraining_element;
   };
   typedef sequence<ACollaborationConstrainingElementLink> ACollaborationConstrainingElementLinkSet;

   interface ACollaborationConstrainingElement : Reflective::RefAssociation
   {
      ACollaborationConstrainingElementLinkSet all_a_collaboration_constraining_element_links()
         raises (Reflective::MofError);
      boolean exists (
         in Collaborations::Collaboration collaboration,
         in Core::ModelElement constraining_element)
         raises (Reflective::MofError);
      CollaborationSet collaboration (in Core::ModelElement constraining_element)
         raises (Reflective::MofError);
      ModelElementSet constraining_element (in Collaborations::Collaboration collaboration)
         raises (Reflective::MofError);
      void add (
         in Collaborations::Collaboration collaboration,
         in Core::ModelElement constraining_element)
         raises (Reflective::MofError);
      void modify_collaboration (
         in Collaborations::Collaboration collaboration,
         in Core::ModelElement constraining_element,
         in Collaborations::Collaboration new_collaboration)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_constraining_element (
         in Collaborations::Collaboration collaboration,
         in Core::ModelElement constraining_element,
         in Core::ModelElement new_constraining_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Collaborations::Collaboration collaboration,
         in Core::ModelElement constraining_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ACollaborationConstrainingElement

   struct AContextInteractionInstanceSetLink
   {
      CollaborationInstanceSet uml_context;
      InteractionInstanceSet interaction_instance_set;
   };
   typedef sequence<AContextInteractionInstanceSetLink> AContextInteractionInstanceSetLinkSet;

   interface AContextInteractionInstanceSet : Reflective::RefAssociation
   {
      AContextInteractionInstanceSetLinkSet all_a_context_interaction_instance_set_links()
         raises (Reflective::MofError);
      boolean exists (
         in CollaborationInstanceSet uml_context,
         in InteractionInstanceSet interaction_instance_set)
         raises (Reflective::MofError);
      CollaborationInstanceSet uml_context (in InteractionInstanceSet interaction_instance_set)
         raises (Reflective::MofError);
      InteractionInstanceSetSet interaction_instance_set (in CollaborationInstanceSet uml_context)
         raises (Reflective::MofError);
      void add (
         in CollaborationInstanceSet uml_context,
         in InteractionInstanceSet interaction_instance_set)
         raises (Reflective::MofError);
      void modify_uml_context (
         in CollaborationInstanceSet uml_context,
         in InteractionInstanceSet interaction_instance_set,
         in CollaborationInstanceSet new_uml_context)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_interaction_instance_set (
         in CollaborationInstanceSet uml_context,
         in InteractionInstanceSet interaction_instance_set,
         in InteractionInstanceSet new_interaction_instance_set)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CollaborationInstanceSet uml_context,
         in InteractionInstanceSet interaction_instance_set)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AContextInteractionInstanceSet

   struct APlayedRoleConformingStimulusLink
   {
      Message played_role;
      CommonBehavior::Stimulus conforming_stimulus;
   };
   typedef sequence<APlayedRoleConformingStimulusLink> APlayedRoleConformingStimulusLinkSet;

   interface APlayedRoleConformingStimulus : Reflective::RefAssociation
   {
      APlayedRoleConformingStimulusLinkSet all_a_played_role_conforming_stimulus_links()
         raises (Reflective::MofError);
      boolean exists (
         in Message played_role,
         in CommonBehavior::Stimulus conforming_stimulus)
         raises (Reflective::MofError);
      MessageSet played_role (in CommonBehavior::Stimulus conforming_stimulus)
         raises (Reflective::MofError);
      StimulusSet conforming_stimulus (in Message played_role)
         raises (Reflective::MofError);
      void add (
         in Message played_role,
         in CommonBehavior::Stimulus conforming_stimulus)
         raises (Reflective::MofError);
      void modify_played_role (
         in Message played_role,
         in CommonBehavior::Stimulus conforming_stimulus,
         in Message new_played_role)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_conforming_stimulus (
         in Message played_role,
         in CommonBehavior::Stimulus conforming_stimulus,
         in CommonBehavior::Stimulus new_conforming_stimulus)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Message played_role,
         in CommonBehavior::Stimulus conforming_stimulus)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface APlayedRoleConformingStimulus

   struct AInteractionInteractionInstanceSetLink
   {
      Collaborations::Interaction interaction;
      InteractionInstanceSet interaction_instance_set;
   };
   typedef sequence<AInteractionInteractionInstanceSetLink> AInteractionInteractionInstanceSetLinkSet;

   interface AInteractionInteractionInstanceSet : Reflective::RefAssociation
   {
      AInteractionInteractionInstanceSetLinkSet all_a_interaction_interaction_instance_set_links()
         raises (Reflective::MofError);
      boolean exists (
         in Collaborations::Interaction interaction,
         in InteractionInstanceSet interaction_instance_set)
         raises (Reflective::MofError);
      Collaborations::Interaction interaction (in InteractionInstanceSet interaction_instance_set)
         raises (Reflective::MofError);
      InteractionInstanceSetSet interaction_instance_set (in Collaborations::Interaction interaction)
         raises (Reflective::MofError);
      void add (
         in Collaborations::Interaction interaction,
         in InteractionInstanceSet interaction_instance_set)
         raises (Reflective::MofError);
      void modify_interaction (
         in Collaborations::Interaction interaction,
         in InteractionInstanceSet interaction_instance_set,
         in Collaborations::Interaction new_interaction)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_interaction_instance_set (
         in Collaborations::Interaction interaction,
         in InteractionInstanceSet interaction_instance_set,
         in InteractionInstanceSet new_interaction_instance_set)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Collaborations::Interaction interaction,
         in InteractionInstanceSet interaction_instance_set)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AInteractionInteractionInstanceSet

   struct ACollaborationCollaborationInstanceSetLink
   {
      Collaborations::Collaboration collaboration;
      CollaborationInstanceSet collaboration_instance_set;
   };
   typedef sequence<ACollaborationCollaborationInstanceSetLink> ACollaborationCollaborationInstanceSetLinkSet;

   interface ACollaborationCollaborationInstanceSet : Reflective::RefAssociation
   {
      ACollaborationCollaborationInstanceSetLinkSet all_a_collaboration_collaboration_instance_set_links()
         raises (Reflective::MofError);
      boolean exists (
         in Collaborations::Collaboration collaboration,
         in CollaborationInstanceSet collaboration_instance_set)
         raises (Reflective::MofError);
      Collaborations::Collaboration collaboration (in CollaborationInstanceSet collaboration_instance_set)
         raises (Reflective::MofError);
      CollaborationInstanceSetSet collaboration_instance_set (in Collaborations::Collaboration collaboration)
         raises (Reflective::MofError);
      void add (
         in Collaborations::Collaboration collaboration,
         in CollaborationInstanceSet collaboration_instance_set)
         raises (Reflective::MofError);
      void modify_collaboration (
         in Collaborations::Collaboration collaboration,
         in CollaborationInstanceSet collaboration_instance_set,
         in Collaborations::Collaboration new_collaboration)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_collaboration_instance_set (
         in Collaborations::Collaboration collaboration,
         in CollaborationInstanceSet collaboration_instance_set,
         in CollaborationInstanceSet new_collaboration_instance_set)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Collaborations::Collaboration collaboration,
         in CollaborationInstanceSet collaboration_instance_set)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ACollaborationCollaborationInstanceSet

   struct APlayedRoleConformingInstanceLink
   {
      ClassifierRole played_role;
      CommonBehavior::Instance conforming_instance;
   };
   typedef sequence<APlayedRoleConformingInstanceLink> APlayedRoleConformingInstanceLinkSet;

   interface APlayedRoleConformingInstance : Reflective::RefAssociation
   {
      APlayedRoleConformingInstanceLinkSet all_a_played_role_conforming_instance_links()
         raises (Reflective::MofError);
      boolean exists (
         in ClassifierRole played_role,
         in CommonBehavior::Instance conforming_instance)
         raises (Reflective::MofError);
      ClassifierRoleSet played_role (in CommonBehavior::Instance conforming_instance)
         raises (Reflective::MofError);
      InstanceSet conforming_instance (in ClassifierRole played_role)
         raises (Reflective::MofError);
      void add (
         in ClassifierRole played_role,
         in CommonBehavior::Instance conforming_instance)
         raises (Reflective::MofError);
      void modify_played_role (
         in ClassifierRole played_role,
         in CommonBehavior::Instance conforming_instance,
         in ClassifierRole new_played_role)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_conforming_instance (
         in ClassifierRole played_role,
         in CommonBehavior::Instance conforming_instance,
         in CommonBehavior::Instance new_conforming_instance)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ClassifierRole played_role,
         in CommonBehavior::Instance conforming_instance)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface APlayedRoleConformingInstance

   struct APlayedRoleConformingLinkLink
   {
      AssociationRole played_role;
      CommonBehavior::Link conforming_link;
   };
   typedef sequence<APlayedRoleConformingLinkLink> APlayedRoleConformingLinkLinkSet;

   interface APlayedRoleConformingLink : Reflective::RefAssociation
   {
      APlayedRoleConformingLinkLinkSet all_a_played_role_conforming_link_links()
         raises (Reflective::MofError);
      boolean exists (
         in AssociationRole played_role,
         in CommonBehavior::Link conforming_link)
         raises (Reflective::MofError);
      AssociationRoleSet played_role (in CommonBehavior::Link conforming_link)
         raises (Reflective::MofError);
      LinkSet conforming_link (in AssociationRole played_role)
         raises (Reflective::MofError);
      void add (
         in AssociationRole played_role,
         in CommonBehavior::Link conforming_link)
         raises (Reflective::MofError);
      void modify_played_role (
         in AssociationRole played_role,
         in CommonBehavior::Link conforming_link,
         in AssociationRole new_played_role)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_conforming_link (
         in AssociationRole played_role,
         in CommonBehavior::Link conforming_link,
         in CommonBehavior::Link new_conforming_link)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in AssociationRole played_role,
         in CommonBehavior::Link conforming_link)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface APlayedRoleConformingLink

   struct AInteractionInstanceSetParticipatingStimulusLink
   {
      InteractionInstanceSet interaction_instance_set;
      CommonBehavior::Stimulus participating_stimulus;
   };
   typedef sequence<AInteractionInstanceSetParticipatingStimulusLink> AInteractionInstanceSetParticipatingStimulusLinkSet;

   interface AInteractionInstanceSetParticipatingStimulus : Reflective::RefAssociation
   {
      AInteractionInstanceSetParticipatingStimulusLinkSet all_a_interaction_instance_set_participating_stimulus_links()
         raises (Reflective::MofError);
      boolean exists (
         in InteractionInstanceSet interaction_instance_set,
         in CommonBehavior::Stimulus participating_stimulus)
         raises (Reflective::MofError);
      InteractionInstanceSetSet interaction_instance_set (in CommonBehavior::Stimulus participating_stimulus)
         raises (Reflective::MofError);
      StimulusSet participating_stimulus (in InteractionInstanceSet interaction_instance_set)
         raises (Reflective::MofError);
      void add (
         in InteractionInstanceSet interaction_instance_set,
         in CommonBehavior::Stimulus participating_stimulus)
         raises (Reflective::MofError);
      void modify_interaction_instance_set (
         in InteractionInstanceSet interaction_instance_set,
         in CommonBehavior::Stimulus participating_stimulus,
         in InteractionInstanceSet new_interaction_instance_set)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_participating_stimulus (
         in InteractionInstanceSet interaction_instance_set,
         in CommonBehavior::Stimulus participating_stimulus,
         in CommonBehavior::Stimulus new_participating_stimulus)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in InteractionInstanceSet interaction_instance_set,
         in CommonBehavior::Stimulus participating_stimulus)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AInteractionInstanceSetParticipatingStimulus

   struct ACollaborationInstanceSetParticipatingInstanceLink
   {
      CollaborationInstanceSet collaboration_instance_set;
      CommonBehavior::Instance participating_instance;
   };
   typedef sequence<ACollaborationInstanceSetParticipatingInstanceLink> ACollaborationInstanceSetParticipatingInstanceLinkSet;

   interface ACollaborationInstanceSetParticipatingInstance : Reflective::RefAssociation
   {
      ACollaborationInstanceSetParticipatingInstanceLinkSet all_a_collaboration_instance_set_participating_instance_links()
         raises (Reflective::MofError);
      boolean exists (
         in CollaborationInstanceSet collaboration_instance_set,
         in CommonBehavior::Instance participating_instance)
         raises (Reflective::MofError);
      CollaborationInstanceSetSet collaboration_instance_set (in CommonBehavior::Instance participating_instance)
         raises (Reflective::MofError);
      InstanceSet participating_instance (in CollaborationInstanceSet collaboration_instance_set)
         raises (Reflective::MofError);
      void add (
         in CollaborationInstanceSet collaboration_instance_set,
         in CommonBehavior::Instance participating_instance)
         raises (Reflective::MofError);
      void modify_collaboration_instance_set (
         in CollaborationInstanceSet collaboration_instance_set,
         in CommonBehavior::Instance participating_instance,
         in CollaborationInstanceSet new_collaboration_instance_set)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_participating_instance (
         in CollaborationInstanceSet collaboration_instance_set,
         in CommonBehavior::Instance participating_instance,
         in CommonBehavior::Instance new_participating_instance)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CollaborationInstanceSet collaboration_instance_set,
         in CommonBehavior::Instance participating_instance)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ACollaborationInstanceSetParticipatingInstance

   struct AParticipatingLinkCollaborationInstanceSetLink
   {
      CommonBehavior::Link participating_link;
      CollaborationInstanceSet collaboration_instance_set;
   };
   typedef sequence<AParticipatingLinkCollaborationInstanceSetLink> AParticipatingLinkCollaborationInstanceSetLinkSet;

   interface AParticipatingLinkCollaborationInstanceSet : Reflective::RefAssociation
   {
      AParticipatingLinkCollaborationInstanceSetLinkSet all_a_participating_link_collaboration_instance_set_links()
         raises (Reflective::MofError);
      boolean exists (
         in CommonBehavior::Link participating_link,
         in CollaborationInstanceSet collaboration_instance_set)
         raises (Reflective::MofError);
      LinkSet participating_link (in CollaborationInstanceSet collaboration_instance_set)
         raises (Reflective::MofError);
      CollaborationInstanceSetSet collaboration_instance_set (in CommonBehavior::Link participating_link)
         raises (Reflective::MofError);
      void add (
         in CommonBehavior::Link participating_link,
         in CollaborationInstanceSet collaboration_instance_set)
         raises (Reflective::MofError);
      void modify_participating_link (
         in CommonBehavior::Link participating_link,
         in CollaborationInstanceSet collaboration_instance_set,
         in CommonBehavior::Link new_participating_link)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_collaboration_instance_set (
         in CommonBehavior::Link participating_link,
         in CollaborationInstanceSet collaboration_instance_set,
         in CollaborationInstanceSet new_collaboration_instance_set)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CommonBehavior::Link participating_link,
         in CollaborationInstanceSet collaboration_instance_set)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AParticipatingLinkCollaborationInstanceSet

   struct AUsedCollaborationCollaborationLink
   {
      Collaborations::Collaboration used_collaboration;
      Collaborations::Collaboration collaboration;
   };
   typedef sequence<AUsedCollaborationCollaborationLink> AUsedCollaborationCollaborationLinkSet;

   interface AUsedCollaborationCollaboration : Reflective::RefAssociation
   {
      AUsedCollaborationCollaborationLinkSet all_a_used_collaboration_collaboration_links()
         raises (Reflective::MofError);
      boolean exists (
         in Collaborations::Collaboration used_collaboration,
         in Collaborations::Collaboration collaboration)
         raises (Reflective::MofError);
      CollaborationSet used_collaboration (in Collaborations::Collaboration collaboration)
         raises (Reflective::MofError);
      CollaborationSet collaboration (in Collaborations::Collaboration used_collaboration)
         raises (Reflective::MofError);
      void add (
         in Collaborations::Collaboration used_collaboration,
         in Collaborations::Collaboration collaboration)
         raises (Reflective::MofError);
      void modify_used_collaboration (
         in Collaborations::Collaboration used_collaboration,
         in Collaborations::Collaboration collaboration,
         in Collaborations::Collaboration new_used_collaboration)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_collaboration (
         in Collaborations::Collaboration used_collaboration,
         in Collaborations::Collaboration collaboration,
         in Collaborations::Collaboration new_collaboration)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Collaborations::Collaboration used_collaboration,
         in Collaborations::Collaboration collaboration)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AUsedCollaborationCollaboration

   struct ARepresentedClassifierCollaborationLink
   {
      Core::Classifier represented_classifier;
      Collaborations::Collaboration collaboration;
   };
   typedef sequence<ARepresentedClassifierCollaborationLink> ARepresentedClassifierCollaborationLinkSet;

   interface ARepresentedClassifierCollaboration : Reflective::RefAssociation
   {
      ARepresentedClassifierCollaborationLinkSet all_a_represented_classifier_collaboration_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Classifier represented_classifier,
         in Collaborations::Collaboration collaboration)
         raises (Reflective::MofError);
      Core::Classifier represented_classifier (in Collaborations::Collaboration collaboration)
         raises (Reflective::MofError);
      CollaborationSet collaboration (in Core::Classifier represented_classifier)
         raises (Reflective::MofError);
      void add (
         in Core::Classifier represented_classifier,
         in Collaborations::Collaboration collaboration)
         raises (Reflective::MofError);
      void modify_represented_classifier (
         in Core::Classifier represented_classifier,
         in Collaborations::Collaboration collaboration,
         in Core::Classifier new_represented_classifier)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_collaboration (
         in Core::Classifier represented_classifier,
         in Collaborations::Collaboration collaboration,
         in Collaborations::Collaboration new_collaboration)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Classifier represented_classifier,
         in Collaborations::Collaboration collaboration)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ARepresentedClassifierCollaboration

   struct ACollaborationInstanceSetConstrainingElementLink
   {
      CollaborationInstanceSet collaboration_instance_set;
      Core::ModelElement constraining_element;
   };
   typedef sequence<ACollaborationInstanceSetConstrainingElementLink> ACollaborationInstanceSetConstrainingElementLinkSet;

   interface ACollaborationInstanceSetConstrainingElement : Reflective::RefAssociation
   {
      ACollaborationInstanceSetConstrainingElementLinkSet all_a_collaboration_instance_set_constraining_element_links()
         raises (Reflective::MofError);
      boolean exists (
         in CollaborationInstanceSet collaboration_instance_set,
         in Core::ModelElement constraining_element)
         raises (Reflective::MofError);
      CollaborationInstanceSetSet collaboration_instance_set (in Core::ModelElement constraining_element)
         raises (Reflective::MofError);
      ModelElementSet constraining_element (in CollaborationInstanceSet collaboration_instance_set)
         raises (Reflective::MofError);
      void add (
         in CollaborationInstanceSet collaboration_instance_set,
         in Core::ModelElement constraining_element)
         raises (Reflective::MofError);
      void modify_collaboration_instance_set (
         in CollaborationInstanceSet collaboration_instance_set,
         in Core::ModelElement constraining_element,
         in CollaborationInstanceSet new_collaboration_instance_set)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_constraining_element (
         in CollaborationInstanceSet collaboration_instance_set,
         in Core::ModelElement constraining_element,
         in Core::ModelElement new_constraining_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CollaborationInstanceSet collaboration_instance_set,
         in Core::ModelElement constraining_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ACollaborationInstanceSetConstrainingElement

   interface CollaborationsPackageFactory
   {
      CollaborationsPackage create_collaborations_package ()
         raises (Reflective::MofError);
   };

   interface CollaborationsPackage : Reflective::RefPackage
   {
      readonly attribute DataTypes::DataTypesPackage data_types_ref;
      readonly attribute Core::CorePackage core_ref;
      readonly attribute CommonBehavior::CommonBehaviorPackage common_behavior_ref;
      readonly attribute CollaborationClass collaboration_ref;
      readonly attribute ClassifierRoleClass classifier_role_ref;
      readonly attribute AssociationRoleClass association_role_ref;
      readonly attribute AssociationEndRoleClass association_end_role_ref;
      readonly attribute MessageClass message_ref;
      readonly attribute InteractionClass interaction_ref;
      readonly attribute InteractionInstanceSetClass interaction_instance_set_ref;
      readonly attribute CollaborationInstanceSetClass collaboration_instance_set_ref;
      readonly attribute AInteractionMessage a_interaction_message_ref;
      readonly attribute AContextInteraction a_context_interaction_ref;
      readonly attribute AClassifierRoleBase a_classifier_role_base_ref;
      readonly attribute ABaseAssociationEndRole a_base_association_end_role_ref;
      readonly attribute ABaseAssociationRole a_base_association_role_ref;
      readonly attribute AClassifierRoleAvailableFeature a_classifier_role_available_feature_ref;
      readonly attribute AMessageActivator a_message_activator_ref;
      readonly attribute AMessageSender a_message_sender_ref;
      readonly attribute AReceiverMessage a_receiver_message_ref;
      readonly attribute APredecessorSuccessor a_predecessor_successor_ref;
      readonly attribute AMessageCommunicationConnection a_message_communication_connection_ref;
      readonly attribute AClassifierRoleAvailableContents a_classifier_role_available_contents_ref;
      readonly attribute AProcedureMessage a_procedure_message_ref;
      readonly attribute AAssociationEndRoleAvailableQualifier a_association_end_role_available_qualifier_ref;
      readonly attribute ARepresentedOperationCollaboration a_represented_operation_collaboration_ref;
      readonly attribute ACollaborationConstrainingElement a_collaboration_constraining_element_ref;
      readonly attribute AContextInteractionInstanceSet a_context_interaction_instance_set_ref;
      readonly attribute APlayedRoleConformingStimulus a_played_role_conforming_stimulus_ref;
      readonly attribute AInteractionInteractionInstanceSet a_interaction_interaction_instance_set_ref;
      readonly attribute ACollaborationCollaborationInstanceSet a_collaboration_collaboration_instance_set_ref;
      readonly attribute APlayedRoleConformingInstance a_played_role_conforming_instance_ref;
      readonly attribute APlayedRoleConformingLink a_played_role_conforming_link_ref;
      readonly attribute AInteractionInstanceSetParticipatingStimulus a_interaction_instance_set_participating_stimulus_ref;
      readonly attribute ACollaborationInstanceSetParticipatingInstance a_collaboration_instance_set_participating_instance_ref;
      readonly attribute AParticipatingLinkCollaborationInstanceSet a_participating_link_collaboration_instance_set_ref;
      readonly attribute AUsedCollaborationCollaboration a_used_collaboration_collaboration_ref;
      readonly attribute ARepresentedClassifierCollaboration a_represented_classifier_collaboration_ref;
      readonly attribute ACollaborationInstanceSetConstrainingElement a_collaboration_instance_set_constraining_element_ref;
   };
};

#endif