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

module StateMachines
{
   typedef sequence<Core::Parameter> ParameterUList;
   interface StateMachineClass;
   interface StateMachine;
   typedef sequence<StateMachine> StateMachineSet;
   interface EventClass;
   interface Event;
   typedef sequence<Event> EventSet;
   interface StateVertexClass;
   interface StateVertex;
   typedef sequence<StateVertex> StateVertexSet;
   interface StateClass;
   interface State;
   typedef sequence<State> StateSet;
   interface TimeEventClass;
   interface TimeEvent;
   typedef sequence<TimeEvent> TimeEventSet;
   interface CallEventClass;
   interface CallEvent;
   typedef sequence<CallEvent> CallEventSet;
   interface SignalEventClass;
   interface SignalEvent;
   typedef sequence<SignalEvent> SignalEventSet;
   interface TransitionClass;
   interface Transition;
   typedef sequence<Transition> TransitionSet;
   interface CompositeStateClass;
   interface CompositeState;
   typedef sequence<CompositeState> CompositeStateSet;
   interface ChangeEventClass;
   interface ChangeEvent;
   typedef sequence<ChangeEvent> ChangeEventSet;
   interface GuardClass;
   interface Guard;
   typedef sequence<Guard> GuardSet;
   interface PseudostateClass;
   interface Pseudostate;
   typedef sequence<Pseudostate> PseudostateSet;
   interface SimpleStateClass;
   interface SimpleState;
   typedef sequence<SimpleState> SimpleStateSet;
   interface SubmachineStateClass;
   interface SubmachineState;
   typedef sequence<SubmachineState> SubmachineStateSet;
   interface SynchStateClass;
   interface SynchState;
   typedef sequence<SynchState> SynchStateSet;
   interface StubStateClass;
   interface StubState;
   typedef sequence<StubState> StubStateSet;
   interface FinalStateClass;
   interface FinalState;
   typedef sequence<FinalState> FinalStateSet;
   interface StateMachinesPackage;

   interface StateMachineClass : Core::ModelElementClass
   {
      readonly attribute StateMachineSet all_of_type_state_machine;
      readonly attribute StateMachineSet all_of_class_state_machine;
      StateMachine create_state_machine (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface StateMachine : StateMachineClass, Core::ModelElement
   {
      Core::ModelElement uml_context ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_uml_context (in Core::ModelElement new_value)
         raises (Reflective::MofError);
      void unset_uml_context ()
         raises (Reflective::MofError);
      State top ()
         raises (Reflective::MofError);
      void set_top (in State new_value)
         raises (Reflective::MofError);
      TransitionSet transitions ()
         raises (Reflective::MofError);
      void set_transitions (in TransitionSet new_value)
         raises (Reflective::MofError);
      void unset_transitions ()
         raises (Reflective::MofError);
      void add_transitions (in Transition new_element)
         raises (Reflective::MofError);
      void modify_transitions (
         in Transition old_element,
         in Transition new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_transitions (in Transition old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      SubmachineStateSet submachine_state ()
         raises (Reflective::MofError);
      void set_submachine_state (in SubmachineStateSet new_value)
         raises (Reflective::MofError);
      void unset_submachine_state ()
         raises (Reflective::MofError);
      void add_submachine_state (in SubmachineState new_element)
         raises (Reflective::MofError);
      void modify_submachine_state (
         in SubmachineState old_element,
         in SubmachineState new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_submachine_state (in SubmachineState old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface StateMachine

   interface EventClass : Core::ModelElementClass
   {
      readonly attribute EventSet all_of_type_event;
   };

   interface Event : EventClass, Core::ModelElement
   {
      ParameterUList parameter ()
         raises (Reflective::MofError);
      void set_parameter (in ParameterUList new_value)
         raises (Reflective::MofError);
      void unset_parameter ()
         raises (Reflective::MofError);
      void add_parameter (in Core::Parameter new_element)
         raises (Reflective::MofError);
      void add_parameter_before (
         in Core::Parameter new_element,
         in Core::Parameter before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_parameter (
         in Core::Parameter old_element,
         in Core::Parameter new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_parameter (in Core::Parameter old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Event

   interface StateVertexClass : Core::ModelElementClass
   {
      readonly attribute StateVertexSet all_of_type_state_vertex;
   };

   interface StateVertex : StateVertexClass, Core::ModelElement
   {
      CompositeState container ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_container (in CompositeState new_value)
         raises (Reflective::MofError);
      void unset_container ()
         raises (Reflective::MofError);
      TransitionSet outgoing ()
         raises (Reflective::MofError);
      void set_outgoing (in TransitionSet new_value)
         raises (Reflective::MofError);
      void unset_outgoing ()
         raises (Reflective::MofError);
      void add_outgoing (in Transition new_element)
         raises (Reflective::MofError);
      void modify_outgoing (
         in Transition old_element,
         in Transition new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_outgoing (in Transition old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      TransitionSet incoming ()
         raises (Reflective::MofError);
      void set_incoming (in TransitionSet new_value)
         raises (Reflective::MofError);
      void unset_incoming ()
         raises (Reflective::MofError);
      void add_incoming (in Transition new_element)
         raises (Reflective::MofError);
      void modify_incoming (
         in Transition old_element,
         in Transition new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_incoming (in Transition old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface StateVertex

   interface StateClass : StateVertexClass
   {
      readonly attribute StateSet all_of_type_state;
   };

   interface State : StateClass, StateVertex
   {
      CommonBehavior::Procedure entry ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_entry (in CommonBehavior::Procedure new_value)
         raises (Reflective::MofError);
      void unset_entry ()
         raises (Reflective::MofError);
      CommonBehavior::Procedure exit ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_exit (in CommonBehavior::Procedure new_value)
         raises (Reflective::MofError);
      void unset_exit ()
         raises (Reflective::MofError);
      EventSet deferrable_event ()
         raises (Reflective::MofError);
      void set_deferrable_event (in EventSet new_value)
         raises (Reflective::MofError);
      void unset_deferrable_event ()
         raises (Reflective::MofError);
      void add_deferrable_event (in Event new_element)
         raises (Reflective::MofError);
      void modify_deferrable_event (
         in Event old_element,
         in Event new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_deferrable_event (in Event old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      TransitionSet internal_transition ()
         raises (Reflective::MofError);
      void set_internal_transition (in TransitionSet new_value)
         raises (Reflective::MofError);
      void unset_internal_transition ()
         raises (Reflective::MofError);
      void add_internal_transition (in Transition new_element)
         raises (Reflective::MofError);
      void modify_internal_transition (
         in Transition old_element,
         in Transition new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_internal_transition (in Transition old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      CommonBehavior::Procedure do_activity ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_do_activity (in CommonBehavior::Procedure new_value)
         raises (Reflective::MofError);
      void unset_do_activity ()
         raises (Reflective::MofError);
      StateMachine state_machine ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_state_machine (in StateMachine new_value)
         raises (Reflective::MofError);
      void unset_state_machine ()
         raises (Reflective::MofError);
   }; // end of interface State

   interface TimeEventClass : EventClass
   {
      readonly attribute TimeEventSet all_of_type_time_event;
      readonly attribute TimeEventSet all_of_class_time_event;
      TimeEvent create_time_event (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::TimeExpression when)
         raises (Reflective::MofError);
   };

   interface TimeEvent : TimeEventClass, Event
   {
      DataTypes::TimeExpression when ()
         raises (Reflective::MofError);
      void set_when (in DataTypes::TimeExpression new_value)
         raises (Reflective::MofError);
   }; // end of interface TimeEvent

   interface CallEventClass : EventClass
   {
      readonly attribute CallEventSet all_of_type_call_event;
      readonly attribute CallEventSet all_of_class_call_event;
      CallEvent create_call_event (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface CallEvent : CallEventClass, Event
   {
      Core::Operation operation ()
         raises (Reflective::MofError);
      void set_operation (in Core::Operation new_value)
         raises (Reflective::MofError);
   }; // end of interface CallEvent

   interface SignalEventClass : EventClass
   {
      readonly attribute SignalEventSet all_of_type_signal_event;
      readonly attribute SignalEventSet all_of_class_signal_event;
      SignalEvent create_signal_event (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface SignalEvent : SignalEventClass, Event
   {
      CommonBehavior::Signal signal ()
         raises (Reflective::MofError);
      void set_signal (in CommonBehavior::Signal new_value)
         raises (Reflective::MofError);
   }; // end of interface SignalEvent

   interface TransitionClass : Core::ModelElementClass
   {
      readonly attribute TransitionSet all_of_type_transition;
      readonly attribute TransitionSet all_of_class_transition;
      Transition create_transition (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface Transition : TransitionClass, Core::ModelElement
   {
      StateMachines::Guard guard ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_guard (in StateMachines::Guard new_value)
         raises (Reflective::MofError);
      void unset_guard ()
         raises (Reflective::MofError);
      CommonBehavior::Procedure effect ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_effect (in CommonBehavior::Procedure new_value)
         raises (Reflective::MofError);
      void unset_effect ()
         raises (Reflective::MofError);
      Event trigger ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_trigger (in Event new_value)
         raises (Reflective::MofError);
      void unset_trigger ()
         raises (Reflective::MofError);
      StateVertex source ()
         raises (Reflective::MofError);
      void set_source (in StateVertex new_value)
         raises (Reflective::MofError);
      StateVertex target ()
         raises (Reflective::MofError);
      void set_target (in StateVertex new_value)
         raises (Reflective::MofError);
      StateMachine state_machine ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_state_machine (in StateMachine new_value)
         raises (Reflective::MofError);
      void unset_state_machine ()
         raises (Reflective::MofError);
   }; // end of interface Transition

   interface CompositeStateClass : StateClass
   {
      readonly attribute CompositeStateSet all_of_type_composite_state;
      readonly attribute CompositeStateSet all_of_class_composite_state;
      CompositeState create_composite_state (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_concurrent)
         raises (Reflective::MofError);
   };

   interface CompositeState : CompositeStateClass, State
   {
      boolean is_concurrent ()
         raises (Reflective::MofError);
      void set_is_concurrent (in boolean new_value)
         raises (Reflective::MofError);
      StateVertexSet subvertex ()
         raises (Reflective::MofError);
      void set_subvertex (in StateVertexSet new_value)
         raises (Reflective::MofError);
      void unset_subvertex ()
         raises (Reflective::MofError);
      void add_subvertex (in StateVertex new_element)
         raises (Reflective::MofError);
      void modify_subvertex (
         in StateVertex old_element,
         in StateVertex new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_subvertex (in StateVertex old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface CompositeState

   interface ChangeEventClass : EventClass
   {
      readonly attribute ChangeEventSet all_of_type_change_event;
      readonly attribute ChangeEventSet all_of_class_change_event;
      ChangeEvent create_change_event (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::BooleanExpression change_expression)
         raises (Reflective::MofError);
   };

   interface ChangeEvent : ChangeEventClass, Event
   {
      DataTypes::BooleanExpression change_expression ()
         raises (Reflective::MofError);
      void set_change_expression (in DataTypes::BooleanExpression new_value)
         raises (Reflective::MofError);
   }; // end of interface ChangeEvent

   interface GuardClass : Core::ModelElementClass
   {
      readonly attribute GuardSet all_of_type_guard;
      readonly attribute GuardSet all_of_class_guard;
      Guard create_guard (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::BooleanExpression expression)
         raises (Reflective::MofError);
   };

   interface Guard : GuardClass, Core::ModelElement
   {
      DataTypes::BooleanExpression expression ()
         raises (Reflective::MofError);
      void set_expression (in DataTypes::BooleanExpression new_value)
         raises (Reflective::MofError);
      StateMachines::Transition transition ()
         raises (Reflective::MofError);
      void set_transition (in StateMachines::Transition new_value)
         raises (Reflective::MofError);
   }; // end of interface Guard

   interface PseudostateClass : StateVertexClass
   {
      readonly attribute PseudostateSet all_of_type_pseudostate;
      readonly attribute PseudostateSet all_of_class_pseudostate;
      Pseudostate create_pseudostate (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::PseudostateKind kind)
         raises (Reflective::MofError);
   };

   interface Pseudostate : PseudostateClass, StateVertex
   {
      DataTypes::PseudostateKind kind ()
         raises (Reflective::MofError);
      void set_kind (in DataTypes::PseudostateKind new_value)
         raises (Reflective::MofError);
   }; // end of interface Pseudostate

   interface SimpleStateClass : StateClass
   {
      readonly attribute SimpleStateSet all_of_type_simple_state;
      readonly attribute SimpleStateSet all_of_class_simple_state;
      SimpleState create_simple_state (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface SimpleState : SimpleStateClass, State
   {
   }; // end of interface SimpleState

   interface SubmachineStateClass : CompositeStateClass
   {
      readonly attribute SubmachineStateSet all_of_type_submachine_state;
      readonly attribute SubmachineStateSet all_of_class_submachine_state;
      SubmachineState create_submachine_state (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_concurrent)
         raises (Reflective::MofError);
   };

   interface SubmachineState : SubmachineStateClass, CompositeState
   {
      StateMachine submachine ()
         raises (Reflective::MofError);
      void set_submachine (in StateMachine new_value)
         raises (Reflective::MofError);
   }; // end of interface SubmachineState

   interface SynchStateClass : StateVertexClass
   {
      readonly attribute SynchStateSet all_of_type_synch_state;
      readonly attribute SynchStateSet all_of_class_synch_state;
      SynchState create_synch_state (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::UnlimitedInteger bound)
         raises (Reflective::MofError);
   };

   interface SynchState : SynchStateClass, StateVertex
   {
      DataTypes::UnlimitedInteger bound ()
         raises (Reflective::MofError);
      void set_bound (in DataTypes::UnlimitedInteger new_value)
         raises (Reflective::MofError);
   }; // end of interface SynchState

   interface StubStateClass : StateVertexClass
   {
      readonly attribute StubStateSet all_of_type_stub_state;
      readonly attribute StubStateSet all_of_class_stub_state;
      StubState create_stub_state (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::Name reference_state)
         raises (Reflective::MofError);
   };

   interface StubState : StubStateClass, StateVertex
   {
      DataTypes::Name reference_state ()
         raises (Reflective::MofError);
      void set_reference_state (in DataTypes::Name new_value)
         raises (Reflective::MofError);
   }; // end of interface StubState

   interface FinalStateClass : StateClass
   {
      readonly attribute FinalStateSet all_of_type_final_state;
      readonly attribute FinalStateSet all_of_class_final_state;
      FinalState create_final_state (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface FinalState : FinalStateClass, State
   {
   }; // end of interface FinalState

   struct AEventParameterLink
   {
      StateMachines::Event event;
      Core::Parameter parameter;
   };
   typedef sequence<AEventParameterLink> AEventParameterLinkSet;

   interface AEventParameter : Reflective::RefAssociation
   {
      AEventParameterLinkSet all_a_event_parameter_links()
         raises (Reflective::MofError);
      boolean exists (
         in StateMachines::Event event,
         in Core::Parameter parameter)
         raises (Reflective::MofError);
      StateMachines::Event event (in Core::Parameter parameter)
         raises (Reflective::MofError);
      ParameterUList parameter (in StateMachines::Event event)
         raises (Reflective::MofError);
      void add (
         in StateMachines::Event event,
         in Core::Parameter parameter)
         raises (Reflective::MofError);
      void add_before_parameter (
         in StateMachines::Event event,
         in Core::Parameter parameter,
         in Core::Parameter before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_event (
         in StateMachines::Event event,
         in Core::Parameter parameter,
         in StateMachines::Event new_event)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_parameter (
         in StateMachines::Event event,
         in Core::Parameter parameter,
         in Core::Parameter new_parameter)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in StateMachines::Event event,
         in Core::Parameter parameter)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AEventParameter

   struct AGuardTransitionLink
   {
      StateMachines::Guard guard;
      StateMachines::Transition transition;
   };
   typedef sequence<AGuardTransitionLink> AGuardTransitionLinkSet;

   interface AGuardTransition : Reflective::RefAssociation
   {
      AGuardTransitionLinkSet all_a_guard_transition_links()
         raises (Reflective::MofError);
      boolean exists (
         in StateMachines::Guard guard,
         in StateMachines::Transition transition)
         raises (Reflective::MofError);
      StateMachines::Guard guard (in StateMachines::Transition transition)
         raises (Reflective::MofError);
      StateMachines::Transition transition (in StateMachines::Guard guard)
         raises (Reflective::MofError);
      void add (
         in StateMachines::Guard guard,
         in StateMachines::Transition transition)
         raises (Reflective::MofError);
      void modify_guard (
         in StateMachines::Guard guard,
         in StateMachines::Transition transition,
         in StateMachines::Guard new_guard)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_transition (
         in StateMachines::Guard guard,
         in StateMachines::Transition transition,
         in StateMachines::Transition new_transition)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in StateMachines::Guard guard,
         in StateMachines::Transition transition)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AGuardTransition

   struct ASignalOccurrenceLink
   {
      CommonBehavior::Signal signal;
      SignalEvent occurrence;
   };
   typedef sequence<ASignalOccurrenceLink> ASignalOccurrenceLinkSet;

   interface ASignalOccurrence : Reflective::RefAssociation
   {
      ASignalOccurrenceLinkSet all_a_signal_occurrence_links()
         raises (Reflective::MofError);
      boolean exists (
         in CommonBehavior::Signal signal,
         in SignalEvent occurrence)
         raises (Reflective::MofError);
      CommonBehavior::Signal signal (in SignalEvent occurrence)
         raises (Reflective::MofError);
      SignalEventSet occurrence (in CommonBehavior::Signal signal)
         raises (Reflective::MofError);
      void add (
         in CommonBehavior::Signal signal,
         in SignalEvent occurrence)
         raises (Reflective::MofError);
      void modify_signal (
         in CommonBehavior::Signal signal,
         in SignalEvent occurrence,
         in CommonBehavior::Signal new_signal)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_occurrence (
         in CommonBehavior::Signal signal,
         in SignalEvent occurrence,
         in SignalEvent new_occurrence)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CommonBehavior::Signal signal,
         in SignalEvent occurrence)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASignalOccurrence

   struct ABehaviorContextLink
   {
      StateMachine behavior;
      Core::ModelElement uml_context;
   };
   typedef sequence<ABehaviorContextLink> ABehaviorContextLinkSet;

   interface ABehaviorContext : Reflective::RefAssociation
   {
      ABehaviorContextLinkSet all_a_behavior_context_links()
         raises (Reflective::MofError);
      boolean exists (
         in StateMachine behavior,
         in Core::ModelElement uml_context)
         raises (Reflective::MofError);
      StateMachineSet behavior (in Core::ModelElement uml_context)
         raises (Reflective::MofError);
      Core::ModelElement uml_context (in StateMachine behavior)
         raises (Reflective::MofError);
      void add (
         in StateMachine behavior,
         in Core::ModelElement uml_context)
         raises (Reflective::MofError);
      void modify_behavior (
         in StateMachine behavior,
         in Core::ModelElement uml_context,
         in StateMachine new_behavior)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_uml_context (
         in StateMachine behavior,
         in Core::ModelElement uml_context,
         in Core::ModelElement new_uml_context)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in StateMachine behavior,
         in Core::ModelElement uml_context)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ABehaviorContext

   struct ATopStateMachineLink
   {
      State top;
      StateMachine state_machine;
   };
   typedef sequence<ATopStateMachineLink> ATopStateMachineLinkSet;

   interface ATopStateMachine : Reflective::RefAssociation
   {
      ATopStateMachineLinkSet all_a_top_state_machine_links()
         raises (Reflective::MofError);
      boolean exists (
         in State top,
         in StateMachine state_machine)
         raises (Reflective::MofError);
      State top (in StateMachine state_machine)
         raises (Reflective::MofError);
      StateMachine state_machine (in State top)
         raises (Reflective::MofError);
      void add (
         in State top,
         in StateMachine state_machine)
         raises (Reflective::MofError);
      void modify_top (
         in State top,
         in StateMachine state_machine,
         in State new_top)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_state_machine (
         in State top,
         in StateMachine state_machine,
         in StateMachine new_state_machine)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in State top,
         in StateMachine state_machine)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ATopStateMachine

   struct AStateDeferrableEventLink
   {
      StateMachines::State state;
      Event deferrable_event;
   };
   typedef sequence<AStateDeferrableEventLink> AStateDeferrableEventLinkSet;

   interface AStateDeferrableEvent : Reflective::RefAssociation
   {
      AStateDeferrableEventLinkSet all_a_state_deferrable_event_links()
         raises (Reflective::MofError);
      boolean exists (
         in StateMachines::State state,
         in Event deferrable_event)
         raises (Reflective::MofError);
      StateSet state (in Event deferrable_event)
         raises (Reflective::MofError);
      EventSet deferrable_event (in StateMachines::State state)
         raises (Reflective::MofError);
      void add (
         in StateMachines::State state,
         in Event deferrable_event)
         raises (Reflective::MofError);
      void modify_state (
         in StateMachines::State state,
         in Event deferrable_event,
         in StateMachines::State new_state)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_deferrable_event (
         in StateMachines::State state,
         in Event deferrable_event,
         in Event new_deferrable_event)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in StateMachines::State state,
         in Event deferrable_event)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AStateDeferrableEvent

   struct AOccurrenceOperationLink
   {
      CallEvent occurrence;
      Core::Operation operation;
   };
   typedef sequence<AOccurrenceOperationLink> AOccurrenceOperationLinkSet;

   interface AOccurrenceOperation : Reflective::RefAssociation
   {
      AOccurrenceOperationLinkSet all_a_occurrence_operation_links()
         raises (Reflective::MofError);
      boolean exists (
         in CallEvent occurrence,
         in Core::Operation operation)
         raises (Reflective::MofError);
      CallEventSet occurrence (in Core::Operation operation)
         raises (Reflective::MofError);
      Core::Operation operation (in CallEvent occurrence)
         raises (Reflective::MofError);
      void add (
         in CallEvent occurrence,
         in Core::Operation operation)
         raises (Reflective::MofError);
      void modify_occurrence (
         in CallEvent occurrence,
         in Core::Operation operation,
         in CallEvent new_occurrence)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_operation (
         in CallEvent occurrence,
         in Core::Operation operation,
         in Core::Operation new_operation)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CallEvent occurrence,
         in Core::Operation operation)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AOccurrenceOperation

   struct AContainerSubvertexLink
   {
      CompositeState container;
      StateVertex subvertex;
   };
   typedef sequence<AContainerSubvertexLink> AContainerSubvertexLinkSet;

   interface AContainerSubvertex : Reflective::RefAssociation
   {
      AContainerSubvertexLinkSet all_a_container_subvertex_links()
         raises (Reflective::MofError);
      boolean exists (
         in CompositeState container,
         in StateVertex subvertex)
         raises (Reflective::MofError);
      CompositeState container (in StateVertex subvertex)
         raises (Reflective::MofError);
      StateVertexSet subvertex (in CompositeState container)
         raises (Reflective::MofError);
      void add (
         in CompositeState container,
         in StateVertex subvertex)
         raises (Reflective::MofError);
      void modify_container (
         in CompositeState container,
         in StateVertex subvertex,
         in CompositeState new_container)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_subvertex (
         in CompositeState container,
         in StateVertex subvertex,
         in StateVertex new_subvertex)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CompositeState container,
         in StateVertex subvertex)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AContainerSubvertex

   struct ATransitionEffectLink
   {
      StateMachines::Transition transition;
      CommonBehavior::Procedure effect;
   };
   typedef sequence<ATransitionEffectLink> ATransitionEffectLinkSet;

   interface ATransitionEffect : Reflective::RefAssociation
   {
      ATransitionEffectLinkSet all_a_transition_effect_links()
         raises (Reflective::MofError);
      boolean exists (
         in StateMachines::Transition transition,
         in CommonBehavior::Procedure effect)
         raises (Reflective::MofError);
      StateMachines::Transition transition (in CommonBehavior::Procedure effect)
         raises (Reflective::MofError);
      CommonBehavior::Procedure effect (in StateMachines::Transition transition)
         raises (Reflective::MofError);
      void add (
         in StateMachines::Transition transition,
         in CommonBehavior::Procedure effect)
         raises (Reflective::MofError);
      void modify_transition (
         in StateMachines::Transition transition,
         in CommonBehavior::Procedure effect,
         in StateMachines::Transition new_transition)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_effect (
         in StateMachines::Transition transition,
         in CommonBehavior::Procedure effect,
         in CommonBehavior::Procedure new_effect)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in StateMachines::Transition transition,
         in CommonBehavior::Procedure effect)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ATransitionEffect

   struct AStateInternalTransitionLink
   {
      StateMachines::State state;
      Transition internal_transition;
   };
   typedef sequence<AStateInternalTransitionLink> AStateInternalTransitionLinkSet;

   interface AStateInternalTransition : Reflective::RefAssociation
   {
      AStateInternalTransitionLinkSet all_a_state_internal_transition_links()
         raises (Reflective::MofError);
      boolean exists (
         in StateMachines::State state,
         in Transition internal_transition)
         raises (Reflective::MofError);
      StateMachines::State state (in Transition internal_transition)
         raises (Reflective::MofError);
      TransitionSet internal_transition (in StateMachines::State state)
         raises (Reflective::MofError);
      void add (
         in StateMachines::State state,
         in Transition internal_transition)
         raises (Reflective::MofError);
      void modify_state (
         in StateMachines::State state,
         in Transition internal_transition,
         in StateMachines::State new_state)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_internal_transition (
         in StateMachines::State state,
         in Transition internal_transition,
         in Transition new_internal_transition)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in StateMachines::State state,
         in Transition internal_transition)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AStateInternalTransition

   struct ATransitionTriggerLink
   {
      StateMachines::Transition transition;
      Event trigger;
   };
   typedef sequence<ATransitionTriggerLink> ATransitionTriggerLinkSet;

   interface ATransitionTrigger : Reflective::RefAssociation
   {
      ATransitionTriggerLinkSet all_a_transition_trigger_links()
         raises (Reflective::MofError);
      boolean exists (
         in StateMachines::Transition transition,
         in Event trigger)
         raises (Reflective::MofError);
      TransitionSet transition (in Event trigger)
         raises (Reflective::MofError);
      Event trigger (in StateMachines::Transition transition)
         raises (Reflective::MofError);
      void add (
         in StateMachines::Transition transition,
         in Event trigger)
         raises (Reflective::MofError);
      void modify_transition (
         in StateMachines::Transition transition,
         in Event trigger,
         in StateMachines::Transition new_transition)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_trigger (
         in StateMachines::Transition transition,
         in Event trigger,
         in Event new_trigger)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in StateMachines::Transition transition,
         in Event trigger)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ATransitionTrigger

   struct AStateMachineTransitionsLink
   {
      StateMachine state_machine;
      Transition transitions;
   };
   typedef sequence<AStateMachineTransitionsLink> AStateMachineTransitionsLinkSet;

   interface AStateMachineTransitions : Reflective::RefAssociation
   {
      AStateMachineTransitionsLinkSet all_a_state_machine_transitions_links()
         raises (Reflective::MofError);
      boolean exists (
         in StateMachine state_machine,
         in Transition transitions)
         raises (Reflective::MofError);
      StateMachine state_machine (in Transition transitions)
         raises (Reflective::MofError);
      TransitionSet transitions (in StateMachine state_machine)
         raises (Reflective::MofError);
      void add (
         in StateMachine state_machine,
         in Transition transitions)
         raises (Reflective::MofError);
      void modify_state_machine (
         in StateMachine state_machine,
         in Transition transitions,
         in StateMachine new_state_machine)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_transitions (
         in StateMachine state_machine,
         in Transition transitions,
         in Transition new_transitions)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in StateMachine state_machine,
         in Transition transitions)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AStateMachineTransitions

   struct AOutgoingSourceLink
   {
      Transition outgoing;
      StateVertex source;
   };
   typedef sequence<AOutgoingSourceLink> AOutgoingSourceLinkSet;

   interface AOutgoingSource : Reflective::RefAssociation
   {
      AOutgoingSourceLinkSet all_a_outgoing_source_links()
         raises (Reflective::MofError);
      boolean exists (
         in Transition outgoing,
         in StateVertex source)
         raises (Reflective::MofError);
      TransitionSet outgoing (in StateVertex source)
         raises (Reflective::MofError);
      StateVertex source (in Transition outgoing)
         raises (Reflective::MofError);
      void add (
         in Transition outgoing,
         in StateVertex source)
         raises (Reflective::MofError);
      void modify_outgoing (
         in Transition outgoing,
         in StateVertex source,
         in Transition new_outgoing)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_source (
         in Transition outgoing,
         in StateVertex source,
         in StateVertex new_source)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Transition outgoing,
         in StateVertex source)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AOutgoingSource

   struct AIncomingTargetLink
   {
      Transition incoming;
      StateVertex target;
   };
   typedef sequence<AIncomingTargetLink> AIncomingTargetLinkSet;

   interface AIncomingTarget : Reflective::RefAssociation
   {
      AIncomingTargetLinkSet all_a_incoming_target_links()
         raises (Reflective::MofError);
      boolean exists (
         in Transition incoming,
         in StateVertex target)
         raises (Reflective::MofError);
      TransitionSet incoming (in StateVertex target)
         raises (Reflective::MofError);
      StateVertex target (in Transition incoming)
         raises (Reflective::MofError);
      void add (
         in Transition incoming,
         in StateVertex target)
         raises (Reflective::MofError);
      void modify_incoming (
         in Transition incoming,
         in StateVertex target,
         in Transition new_incoming)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_target (
         in Transition incoming,
         in StateVertex target,
         in StateVertex new_target)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Transition incoming,
         in StateVertex target)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AIncomingTarget

   struct ASubmachineStateSubmachineLink
   {
      SubmachineState submachine_state;
      StateMachine submachine;
   };
   typedef sequence<ASubmachineStateSubmachineLink> ASubmachineStateSubmachineLinkSet;

   interface ASubmachineStateSubmachine : Reflective::RefAssociation
   {
      ASubmachineStateSubmachineLinkSet all_a_submachine_state_submachine_links()
         raises (Reflective::MofError);
      boolean exists (
         in SubmachineState submachine_state,
         in StateMachine submachine)
         raises (Reflective::MofError);
      SubmachineStateSet submachine_state (in StateMachine submachine)
         raises (Reflective::MofError);
      StateMachine submachine (in SubmachineState submachine_state)
         raises (Reflective::MofError);
      void add (
         in SubmachineState submachine_state,
         in StateMachine submachine)
         raises (Reflective::MofError);
      void modify_submachine_state (
         in SubmachineState submachine_state,
         in StateMachine submachine,
         in SubmachineState new_submachine_state)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_submachine (
         in SubmachineState submachine_state,
         in StateMachine submachine,
         in StateMachine new_submachine)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in SubmachineState submachine_state,
         in StateMachine submachine)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASubmachineStateSubmachine

   struct AStateDoActivityLink
   {
      StateMachines::State state;
      CommonBehavior::Procedure do_activity;
   };
   typedef sequence<AStateDoActivityLink> AStateDoActivityLinkSet;

   interface AStateDoActivity : Reflective::RefAssociation
   {
      AStateDoActivityLinkSet all_a_state_do_activity_links()
         raises (Reflective::MofError);
      boolean exists (
         in StateMachines::State state,
         in CommonBehavior::Procedure do_activity)
         raises (Reflective::MofError);
      StateMachines::State state (in CommonBehavior::Procedure do_activity)
         raises (Reflective::MofError);
      CommonBehavior::Procedure do_activity (in StateMachines::State state)
         raises (Reflective::MofError);
      void add (
         in StateMachines::State state,
         in CommonBehavior::Procedure do_activity)
         raises (Reflective::MofError);
      void modify_state (
         in StateMachines::State state,
         in CommonBehavior::Procedure do_activity,
         in StateMachines::State new_state)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_do_activity (
         in StateMachines::State state,
         in CommonBehavior::Procedure do_activity,
         in CommonBehavior::Procedure new_do_activity)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in StateMachines::State state,
         in CommonBehavior::Procedure do_activity)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AStateDoActivity

   struct AEntryStateLink
   {
      CommonBehavior::Procedure entry;
      StateMachines::State state;
   };
   typedef sequence<AEntryStateLink> AEntryStateLinkSet;

   interface AEntryState : Reflective::RefAssociation
   {
      AEntryStateLinkSet all_a_entry_state_links()
         raises (Reflective::MofError);
      boolean exists (
         in CommonBehavior::Procedure entry,
         in StateMachines::State state)
         raises (Reflective::MofError);
      CommonBehavior::Procedure entry (in StateMachines::State state)
         raises (Reflective::MofError);
      StateMachines::State state (in CommonBehavior::Procedure entry)
         raises (Reflective::MofError);
      void add (
         in CommonBehavior::Procedure entry,
         in StateMachines::State state)
         raises (Reflective::MofError);
      void modify_entry (
         in CommonBehavior::Procedure entry,
         in StateMachines::State state,
         in CommonBehavior::Procedure new_entry)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_state (
         in CommonBehavior::Procedure entry,
         in StateMachines::State state,
         in StateMachines::State new_state)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CommonBehavior::Procedure entry,
         in StateMachines::State state)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AEntryState

   struct AExitStateLink
   {
      CommonBehavior::Procedure exit;
      StateMachines::State state;
   };
   typedef sequence<AExitStateLink> AExitStateLinkSet;

   interface AExitState : Reflective::RefAssociation
   {
      AExitStateLinkSet all_a_exit_state_links()
         raises (Reflective::MofError);
      boolean exists (
         in CommonBehavior::Procedure exit,
         in StateMachines::State state)
         raises (Reflective::MofError);
      CommonBehavior::Procedure exit (in StateMachines::State state)
         raises (Reflective::MofError);
      StateMachines::State state (in CommonBehavior::Procedure exit)
         raises (Reflective::MofError);
      void add (
         in CommonBehavior::Procedure exit,
         in StateMachines::State state)
         raises (Reflective::MofError);
      void modify_exit (
         in CommonBehavior::Procedure exit,
         in StateMachines::State state,
         in CommonBehavior::Procedure new_exit)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_state (
         in CommonBehavior::Procedure exit,
         in StateMachines::State state,
         in StateMachines::State new_state)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CommonBehavior::Procedure exit,
         in StateMachines::State state)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AExitState

   interface StateMachinesPackageFactory
   {
      StateMachinesPackage create_state_machines_package ()
         raises (Reflective::MofError);
   };

   interface StateMachinesPackage : Reflective::RefPackage
   {
      readonly attribute DataTypes::DataTypesPackage data_types_ref;
      readonly attribute Core::CorePackage core_ref;
      readonly attribute CommonBehavior::CommonBehaviorPackage common_behavior_ref;
      readonly attribute Actions::ActionsPackage actions_ref;
      readonly attribute StateMachineClass state_machine_ref;
      readonly attribute EventClass event_ref;
      readonly attribute StateVertexClass state_vertex_ref;
      readonly attribute StateClass state_ref;
      readonly attribute TimeEventClass time_event_ref;
      readonly attribute CallEventClass call_event_ref;
      readonly attribute SignalEventClass signal_event_ref;
      readonly attribute TransitionClass transition_ref;
      readonly attribute CompositeStateClass composite_state_ref;
      readonly attribute ChangeEventClass change_event_ref;
      readonly attribute GuardClass guard_ref;
      readonly attribute PseudostateClass pseudostate_ref;
      readonly attribute SimpleStateClass simple_state_ref;
      readonly attribute SubmachineStateClass submachine_state_ref;
      readonly attribute SynchStateClass synch_state_ref;
      readonly attribute StubStateClass stub_state_ref;
      readonly attribute FinalStateClass final_state_ref;
      readonly attribute AEventParameter a_event_parameter_ref;
      readonly attribute AGuardTransition a_guard_transition_ref;
      readonly attribute ASignalOccurrence a_signal_occurrence_ref;
      readonly attribute ABehaviorContext a_behavior_context_ref;
      readonly attribute ATopStateMachine a_top_state_machine_ref;
      readonly attribute AStateDeferrableEvent a_state_deferrable_event_ref;
      readonly attribute AOccurrenceOperation a_occurrence_operation_ref;
      readonly attribute AContainerSubvertex a_container_subvertex_ref;
      readonly attribute ATransitionEffect a_transition_effect_ref;
      readonly attribute AStateInternalTransition a_state_internal_transition_ref;
      readonly attribute ATransitionTrigger a_transition_trigger_ref;
      readonly attribute AStateMachineTransitions a_state_machine_transitions_ref;
      readonly attribute AOutgoingSource a_outgoing_source_ref;
      readonly attribute AIncomingTarget a_incoming_target_ref;
      readonly attribute ASubmachineStateSubmachine a_submachine_state_submachine_ref;
      readonly attribute AStateDoActivity a_state_do_activity_ref;
      readonly attribute AEntryState a_entry_state_ref;
      readonly attribute AExitState a_exit_state_ref;
   };
};

#endif