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

module ActivityGraphs
{
   typedef sequence<Core::Parameter> ParameterSet;
   typedef sequence<Core::ModelElement> ModelElementSet;
   typedef sequence<StateMachines::State> StateSet;
   interface ActivityGraphClass;
   interface ActivityGraph;
   typedef sequence<ActivityGraph> ActivityGraphSet;
   interface PartitionClass;
   interface Partition;
   typedef sequence<Partition> PartitionSet;
   interface SubactivityStateClass;
   interface SubactivityState;
   typedef sequence<SubactivityState> SubactivityStateSet;
   interface ActionStateClass;
   interface ActionState;
   typedef sequence<ActionState> ActionStateSet;
   interface CallStateClass;
   interface CallState;
   typedef sequence<CallState> CallStateSet;
   interface ObjectFlowStateClass;
   interface ObjectFlowState;
   typedef sequence<ObjectFlowState> ObjectFlowStateSet;
   interface ClassifierInStateClass;
   interface ClassifierInState;
   typedef sequence<ClassifierInState> ClassifierInStateSet;
   interface ActivityGraphsPackage;

   interface ActivityGraphClass : StateMachines::StateMachineClass
   {
      readonly attribute ActivityGraphSet all_of_type_activity_graph;
      readonly attribute ActivityGraphSet all_of_class_activity_graph;
      ActivityGraph create_activity_graph (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface ActivityGraph : ActivityGraphClass, StateMachines::StateMachine
   {
      PartitionSet partition ()
         raises (Reflective::MofError);
      void set_partition (in PartitionSet new_value)
         raises (Reflective::MofError);
      void unset_partition ()
         raises (Reflective::MofError);
      void add_partition (in ActivityGraphs::Partition new_element)
         raises (Reflective::MofError);
      void modify_partition (
         in ActivityGraphs::Partition old_element,
         in ActivityGraphs::Partition new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_partition (in ActivityGraphs::Partition old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ActivityGraph

   interface PartitionClass : Core::ModelElementClass
   {
      readonly attribute PartitionSet all_of_type_partition;
      readonly attribute PartitionSet all_of_class_partition;
      Partition create_partition (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface Partition : PartitionClass, Core::ModelElement
   {
      ModelElementSet contents ()
         raises (Reflective::MofError);
      void set_contents (in ModelElementSet new_value)
         raises (Reflective::MofError);
      void unset_contents ()
         raises (Reflective::MofError);
      void add_contents (in Core::ModelElement new_element)
         raises (Reflective::MofError);
      void modify_contents (
         in Core::ModelElement old_element,
         in Core::ModelElement new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_contents (in Core::ModelElement old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ActivityGraph activity_graph ()
         raises (Reflective::MofError);
      void set_activity_graph (in ActivityGraph new_value)
         raises (Reflective::MofError);
   }; // end of interface Partition

   interface SubactivityStateClass : StateMachines::SubmachineStateClass
   {
      readonly attribute SubactivityStateSet all_of_type_subactivity_state;
      readonly attribute SubactivityStateSet all_of_class_subactivity_state;
      SubactivityState create_subactivity_state (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_concurrent,
         in boolean is_dynamic,
         in DataTypes::ArgListsExpression dynamic_arguments,
         in DataTypes::Multiplicity dynamic_multiplicity)
         raises (Reflective::MofError);
   };

   interface SubactivityState : SubactivityStateClass, StateMachines::SubmachineState
   {
      boolean is_dynamic ()
         raises (Reflective::MofError);
      void set_is_dynamic (in boolean new_value)
         raises (Reflective::MofError);
      DataTypes::ArgListsExpression dynamic_arguments ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_dynamic_arguments (in DataTypes::ArgListsExpression new_value)
         raises (Reflective::MofError);
      void unset_dynamic_arguments ()
         raises (Reflective::MofError);
      DataTypes::Multiplicity dynamic_multiplicity ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_dynamic_multiplicity (in DataTypes::Multiplicity new_value)
         raises (Reflective::MofError);
      void unset_dynamic_multiplicity ()
         raises (Reflective::MofError);
   }; // end of interface SubactivityState

   interface ActionStateClass : StateMachines::SimpleStateClass
   {
      readonly attribute ActionStateSet all_of_type_action_state;
      readonly attribute ActionStateSet all_of_class_action_state;
      ActionState create_action_state (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_dynamic,
         in DataTypes::ArgListsExpression dynamic_arguments,
         in DataTypes::Multiplicity dynamic_multiplicity)
         raises (Reflective::MofError);
   };

   interface ActionState : ActionStateClass, StateMachines::SimpleState
   {
      boolean is_dynamic ()
         raises (Reflective::MofError);
      void set_is_dynamic (in boolean new_value)
         raises (Reflective::MofError);
      DataTypes::ArgListsExpression dynamic_arguments ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_dynamic_arguments (in DataTypes::ArgListsExpression new_value)
         raises (Reflective::MofError);
      void unset_dynamic_arguments ()
         raises (Reflective::MofError);
      DataTypes::Multiplicity dynamic_multiplicity ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_dynamic_multiplicity (in DataTypes::Multiplicity new_value)
         raises (Reflective::MofError);
      void unset_dynamic_multiplicity ()
         raises (Reflective::MofError);
   }; // end of interface ActionState

   interface CallStateClass : ActionStateClass
   {
      readonly attribute CallStateSet all_of_type_call_state;
      readonly attribute CallStateSet all_of_class_call_state;
      CallState create_call_state (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_dynamic,
         in DataTypes::ArgListsExpression dynamic_arguments,
         in DataTypes::Multiplicity dynamic_multiplicity)
         raises (Reflective::MofError);
   };

   interface CallState : CallStateClass, ActionState
   {
   }; // end of interface CallState

   interface ObjectFlowStateClass : StateMachines::SimpleStateClass
   {
      readonly attribute ObjectFlowStateSet all_of_type_object_flow_state;
      readonly attribute ObjectFlowStateSet all_of_class_object_flow_state;
      ObjectFlowState create_object_flow_state (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_synch)
         raises (Reflective::MofError);
   };

   interface ObjectFlowState : ObjectFlowStateClass, StateMachines::SimpleState
   {
      boolean is_synch ()
         raises (Reflective::MofError);
      void set_is_synch (in boolean new_value)
         raises (Reflective::MofError);
      ParameterSet parameter ()
         raises (Reflective::MofError);
      void set_parameter (in ParameterSet new_value)
         raises (Reflective::MofError);
      void unset_parameter ()
         raises (Reflective::MofError);
      void add_parameter (in Core::Parameter new_element)
         raises (Reflective::MofError);
      void modify_parameter (
         in Core::Parameter old_element,
         in Core::Parameter new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_parameter (in Core::Parameter old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      Core::Classifier type ()
         raises (Reflective::MofError);
      void set_type (in Core::Classifier new_value)
         raises (Reflective::MofError);
   }; // end of interface ObjectFlowState

   interface ClassifierInStateClass : Core::ClassifierClass
   {
      readonly attribute ClassifierInStateSet all_of_type_classifier_in_state;
      readonly attribute ClassifierInStateSet all_of_class_classifier_in_state;
      ClassifierInState create_classifier_in_state (
         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 ClassifierInState : ClassifierInStateClass, Core::Classifier
   {
      Core::Classifier type ()
         raises (Reflective::MofError);
      void set_type (in Core::Classifier new_value)
         raises (Reflective::MofError);
      StateSet in_state ()
         raises (Reflective::MofError);
      void set_in_state (in StateSet new_value)
         raises (Reflective::MofError);
      void add_in_state (in StateMachines::State new_element)
         raises (Reflective::MofError);
      void modify_in_state (
         in StateMachines::State old_element,
         in StateMachines::State new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_in_state (in StateMachines::State old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ClassifierInState

   struct AParameterStateLink
   {
      Core::Parameter parameter;
      ObjectFlowState state;
   };
   typedef sequence<AParameterStateLink> AParameterStateLinkSet;

   interface AParameterState : Reflective::RefAssociation
   {
      AParameterStateLinkSet all_a_parameter_state_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Parameter parameter,
         in ObjectFlowState state)
         raises (Reflective::MofError);
      ParameterSet parameter (in ObjectFlowState state)
         raises (Reflective::MofError);
      ObjectFlowStateSet state (in Core::Parameter parameter)
         raises (Reflective::MofError);
      void add (
         in Core::Parameter parameter,
         in ObjectFlowState state)
         raises (Reflective::MofError);
      void modify_parameter (
         in Core::Parameter parameter,
         in ObjectFlowState state,
         in Core::Parameter new_parameter)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_state (
         in Core::Parameter parameter,
         in ObjectFlowState state,
         in ObjectFlowState new_state)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Parameter parameter,
         in ObjectFlowState state)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AParameterState

   struct ATypeClassifierInStateLink
   {
      Core::Classifier type;
      ClassifierInState classifier_in_state;
   };
   typedef sequence<ATypeClassifierInStateLink> ATypeClassifierInStateLinkSet;

   interface ATypeClassifierInState : Reflective::RefAssociation
   {
      ATypeClassifierInStateLinkSet all_a_type_classifier_in_state_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Classifier type,
         in ClassifierInState classifier_in_state)
         raises (Reflective::MofError);
      Core::Classifier type (in ClassifierInState classifier_in_state)
         raises (Reflective::MofError);
      ClassifierInStateSet classifier_in_state (in Core::Classifier type)
         raises (Reflective::MofError);
      void add (
         in Core::Classifier type,
         in ClassifierInState classifier_in_state)
         raises (Reflective::MofError);
      void modify_type (
         in Core::Classifier type,
         in ClassifierInState classifier_in_state,
         in Core::Classifier new_type)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_classifier_in_state (
         in Core::Classifier type,
         in ClassifierInState classifier_in_state,
         in ClassifierInState new_classifier_in_state)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Classifier type,
         in ClassifierInState classifier_in_state)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ATypeClassifierInState

   struct AContentsPartitionLink
   {
      Core::ModelElement contents;
      ActivityGraphs::Partition partition;
   };
   typedef sequence<AContentsPartitionLink> AContentsPartitionLinkSet;

   interface AContentsPartition : Reflective::RefAssociation
   {
      AContentsPartitionLinkSet all_a_contents_partition_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::ModelElement contents,
         in ActivityGraphs::Partition partition)
         raises (Reflective::MofError);
      ModelElementSet contents (in ActivityGraphs::Partition partition)
         raises (Reflective::MofError);
      PartitionSet partition (in Core::ModelElement contents)
         raises (Reflective::MofError);
      void add (
         in Core::ModelElement contents,
         in ActivityGraphs::Partition partition)
         raises (Reflective::MofError);
      void modify_contents (
         in Core::ModelElement contents,
         in ActivityGraphs::Partition partition,
         in Core::ModelElement new_contents)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_partition (
         in Core::ModelElement contents,
         in ActivityGraphs::Partition partition,
         in ActivityGraphs::Partition new_partition)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::ModelElement contents,
         in ActivityGraphs::Partition partition)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AContentsPartition

   struct AActivityGraphPartitionLink
   {
      ActivityGraph activity_graph;
      ActivityGraphs::Partition partition;
   };
   typedef sequence<AActivityGraphPartitionLink> AActivityGraphPartitionLinkSet;

   interface AActivityGraphPartition : Reflective::RefAssociation
   {
      AActivityGraphPartitionLinkSet all_a_activity_graph_partition_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActivityGraph activity_graph,
         in ActivityGraphs::Partition partition)
         raises (Reflective::MofError);
      ActivityGraph activity_graph (in ActivityGraphs::Partition partition)
         raises (Reflective::MofError);
      PartitionSet partition (in ActivityGraph activity_graph)
         raises (Reflective::MofError);
      void add (
         in ActivityGraph activity_graph,
         in ActivityGraphs::Partition partition)
         raises (Reflective::MofError);
      void modify_activity_graph (
         in ActivityGraph activity_graph,
         in ActivityGraphs::Partition partition,
         in ActivityGraph new_activity_graph)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_partition (
         in ActivityGraph activity_graph,
         in ActivityGraphs::Partition partition,
         in ActivityGraphs::Partition new_partition)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActivityGraph activity_graph,
         in ActivityGraphs::Partition partition)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AActivityGraphPartition

   struct ATypeObjectFlowStateLink
   {
      Core::Classifier type;
      ObjectFlowState object_flow_state;
   };
   typedef sequence<ATypeObjectFlowStateLink> ATypeObjectFlowStateLinkSet;

   interface ATypeObjectFlowState : Reflective::RefAssociation
   {
      ATypeObjectFlowStateLinkSet all_a_type_object_flow_state_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Classifier type,
         in ObjectFlowState object_flow_state)
         raises (Reflective::MofError);
      Core::Classifier type (in ObjectFlowState object_flow_state)
         raises (Reflective::MofError);
      ObjectFlowStateSet object_flow_state (in Core::Classifier type)
         raises (Reflective::MofError);
      void add (
         in Core::Classifier type,
         in ObjectFlowState object_flow_state)
         raises (Reflective::MofError);
      void modify_type (
         in Core::Classifier type,
         in ObjectFlowState object_flow_state,
         in Core::Classifier new_type)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_object_flow_state (
         in Core::Classifier type,
         in ObjectFlowState object_flow_state,
         in ObjectFlowState new_object_flow_state)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Classifier type,
         in ObjectFlowState object_flow_state)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ATypeObjectFlowState

   struct AClassifierInStateInStateLink
   {
      ClassifierInState classifier_in_state;
      StateMachines::State in_state;
   };
   typedef sequence<AClassifierInStateInStateLink> AClassifierInStateInStateLinkSet;

   interface AClassifierInStateInState : Reflective::RefAssociation
   {
      AClassifierInStateInStateLinkSet all_a_classifier_in_state_in_state_links()
         raises (Reflective::MofError);
      boolean exists (
         in ClassifierInState classifier_in_state,
         in StateMachines::State in_state)
         raises (Reflective::MofError);
      ClassifierInStateSet classifier_in_state (in StateMachines::State in_state)
         raises (Reflective::MofError);
      StateSet in_state (in ClassifierInState classifier_in_state)
         raises (Reflective::MofError);
      void add (
         in ClassifierInState classifier_in_state,
         in StateMachines::State in_state)
         raises (Reflective::MofError);
      void modify_classifier_in_state (
         in ClassifierInState classifier_in_state,
         in StateMachines::State in_state,
         in ClassifierInState new_classifier_in_state)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_in_state (
         in ClassifierInState classifier_in_state,
         in StateMachines::State in_state,
         in StateMachines::State new_in_state)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ClassifierInState classifier_in_state,
         in StateMachines::State in_state)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AClassifierInStateInState

   interface ActivityGraphsPackageFactory
   {
      ActivityGraphsPackage create_activity_graphs_package ()
         raises (Reflective::MofError);
   };

   interface ActivityGraphsPackage : Reflective::RefPackage
   {
      readonly attribute DataTypes::DataTypesPackage data_types_ref;
      readonly attribute Core::CorePackage core_ref;
      readonly attribute CommonBehavior::CommonBehaviorPackage common_behavior_ref;
      readonly attribute StateMachines::StateMachinesPackage state_machines_ref;
      readonly attribute ActivityGraphClass activity_graph_ref;
      readonly attribute PartitionClass partition_ref;
      readonly attribute SubactivityStateClass subactivity_state_ref;
      readonly attribute ActionStateClass action_state_ref;
      readonly attribute CallStateClass call_state_ref;
      readonly attribute ObjectFlowStateClass object_flow_state_ref;
      readonly attribute ClassifierInStateClass classifier_in_state_ref;
      readonly attribute AParameterState a_parameter_state_ref;
      readonly attribute ATypeClassifierInState a_type_classifier_in_state_ref;
      readonly attribute AContentsPartition a_contents_partition_ref;
      readonly attribute AActivityGraphPartition a_activity_graph_partition_ref;
      readonly attribute ATypeObjectFlowState a_type_object_flow_state_ref;
      readonly attribute AClassifierInStateInState a_classifier_in_state_in_state_ref;
   };
};

#endif