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

module Actions
{
   typedef sequence<Core::Classifier> ClassifierSet;
   typedef sequence<ActionFoundation::InputPin> InputPinSet;
   typedef sequence<ActionFoundation::InputPin> InputPinUList;
   typedef sequence<ActionFoundation::Action> ActionSet;
   typedef sequence<ActionFoundation::OutputPin> OutputPinSet;
   typedef sequence<ActionFoundation::OutputPin> OutputPinUList;
   interface CollectionActionClass;
   interface CollectionAction;
   typedef sequence<CollectionAction> CollectionActionSet;
   interface FilterActionClass;
   interface FilterAction;
   typedef sequence<FilterAction> FilterActionSet;
   interface IterateActionClass;
   interface IterateAction;
   typedef sequence<IterateAction> IterateActionSet;
   interface MapActionClass;
   interface MapAction;
   typedef sequence<MapAction> MapActionSet;
   interface ReduceActionClass;
   interface ReduceAction;
   typedef sequence<ReduceAction> ReduceActionSet;
   interface ClauseClass;
   interface Clause;
   typedef sequence<Clause> ClauseSet;
   interface ConditionalActionClass;
   interface ConditionalAction;
   typedef sequence<ConditionalAction> ConditionalActionSet;
   interface GroupActionClass;
   interface GroupAction;
   typedef sequence<GroupAction> GroupActionSet;
   interface LoopActionClass;
   interface LoopAction;
   typedef sequence<LoopAction> LoopActionSet;
   interface VariableClass;
   interface Variable;
   typedef sequence<Variable> VariableSet;
   interface ApplyFunctionActionClass;
   interface ApplyFunctionAction;
   typedef sequence<ApplyFunctionAction> ApplyFunctionActionSet;
   interface ArgumentSpecificationClass;
   interface ArgumentSpecification;
   typedef sequence<ArgumentSpecification> ArgumentSpecificationSet;
   interface CodeActionClass;
   interface CodeAction;
   typedef sequence<CodeAction> CodeActionSet;
   interface LiteralValueActionClass;
   interface LiteralValueAction;
   typedef sequence<LiteralValueAction> LiteralValueActionSet;
   interface MarshalActionClass;
   interface MarshalAction;
   typedef sequence<MarshalAction> MarshalActionSet;
   interface NullActionClass;
   interface NullAction;
   typedef sequence<NullAction> NullActionSet;
   interface PrimitiveFunctionClass;
   interface PrimitiveFunction;
   typedef sequence<PrimitiveFunction> PrimitiveFunctionSet;
   interface TestIdentityActionClass;
   interface TestIdentityAction;
   typedef sequence<TestIdentityAction> TestIdentityActionSet;
   interface UnmarshalActionClass;
   interface UnmarshalAction;
   typedef sequence<UnmarshalAction> UnmarshalActionSet;
   interface JumpHandlerClass;
   interface JumpHandler;
   typedef sequence<JumpHandler> JumpHandlerSet;
   interface HandlerActionClass;
   interface HandlerAction;
   typedef sequence<HandlerAction> HandlerActionSet;
   interface JumpActionClass;
   interface JumpAction;
   typedef sequence<JumpAction> JumpActionSet;
   interface InvocationActionClass;
   interface InvocationAction;
   typedef sequence<InvocationAction> InvocationActionSet;
   interface AsynchronousInvocationActionClass;
   interface AsynchronousInvocationAction;
   typedef sequence<AsynchronousInvocationAction> AsynchronousInvocationActionSet;
   interface ExplicitInvocationActtionClass;
   interface ExplicitInvocationActtion;
   typedef sequence<ExplicitInvocationActtion> ExplicitInvocationActtionSet;
   interface CallOperationActionClass;
   interface CallOperationAction;
   typedef sequence<CallOperationAction> CallOperationActionSet;
   interface SynchronousInvocationActionClass;
   interface SynchronousInvocationAction;
   typedef sequence<SynchronousInvocationAction> SynchronousInvocationActionSet;
   interface ClearAssociationActionClass;
   interface ClearAssociationAction;
   typedef sequence<ClearAssociationAction> ClearAssociationActionSet;
   interface LinkActionClass;
   interface LinkAction;
   typedef sequence<LinkAction> LinkActionSet;
   interface WriteLinkActionClass;
   interface WriteLinkAction;
   typedef sequence<WriteLinkAction> WriteLinkActionSet;
   interface CreateLinkActionClass;
   interface CreateLinkAction;
   typedef sequence<CreateLinkAction> CreateLinkActionSet;
   interface CreateLinkObjectActionClass;
   interface CreateLinkObjectAction;
   typedef sequence<CreateLinkObjectAction> CreateLinkObjectActionSet;
   interface DestroyLinkActionClass;
   interface DestroyLinkAction;
   typedef sequence<DestroyLinkAction> DestroyLinkActionSet;
   interface LinkEndDataClass;
   interface LinkEndData;
   typedef sequence<LinkEndData> LinkEndDataSet;
   interface LinkEndCreationDataClass;
   interface LinkEndCreationData;
   typedef sequence<LinkEndCreationData> LinkEndCreationDataSet;
   interface QualifierValueClass;
   interface QualifierValue;
   typedef sequence<QualifierValue> QualifierValueSet;
   interface ReadLinkActionClass;
   interface ReadLinkAction;
   typedef sequence<ReadLinkAction> ReadLinkActionSet;
   interface ReadLinkObjectEndActionClass;
   interface ReadLinkObjectEndAction;
   typedef sequence<ReadLinkObjectEndAction> ReadLinkObjectEndActionSet;
   interface ReadLinkObjectQualifierActionClass;
   interface ReadLinkObjectQualifierAction;
   typedef sequence<ReadLinkObjectQualifierAction> ReadLinkObjectQualifierActionSet;
   interface AttributeActionClass;
   interface AttributeAction;
   typedef sequence<AttributeAction> AttributeActionSet;
   interface WriteAttributeActionClass;
   interface WriteAttributeAction;
   typedef sequence<WriteAttributeAction> WriteAttributeActionSet;
   interface AddAttributeValueActionClass;
   interface AddAttributeValueAction;
   typedef sequence<AddAttributeValueAction> AddAttributeValueActionSet;
   interface ClearAttributeActionClass;
   interface ClearAttributeAction;
   typedef sequence<ClearAttributeAction> ClearAttributeActionSet;
   interface ReadAttributeActionClass;
   interface ReadAttributeAction;
   typedef sequence<ReadAttributeAction> ReadAttributeActionSet;
   interface RemoveAttributeValueActionClass;
   interface RemoveAttributeValueAction;
   typedef sequence<RemoveAttributeValueAction> RemoveAttributeValueActionSet;
   interface CreateObjectActionClass;
   interface CreateObjectAction;
   typedef sequence<CreateObjectAction> CreateObjectActionSet;
   interface DestroyObjectActionClass;
   interface DestroyObjectAction;
   typedef sequence<DestroyObjectAction> DestroyObjectActionSet;
   interface ReadIsClassifiedObjectActionClass;
   interface ReadIsClassifiedObjectAction;
   typedef sequence<ReadIsClassifiedObjectAction> ReadIsClassifiedObjectActionSet;
   interface ReclassifyObjectActionClass;
   interface ReclassifyObjectAction;
   typedef sequence<ReclassifyObjectAction> ReclassifyObjectActionSet;
   interface ReadExtentActionClass;
   interface ReadExtentAction;
   typedef sequence<ReadExtentAction> ReadExtentActionSet;
   interface ReadSelfActionClass;
   interface ReadSelfAction;
   typedef sequence<ReadSelfAction> ReadSelfActionSet;
   interface StartObjectStateMachineActionClass;
   interface StartObjectStateMachineAction;
   typedef sequence<StartObjectStateMachineAction> StartObjectStateMachineActionSet;
   interface VariableActionClass;
   interface VariableAction;
   typedef sequence<VariableAction> VariableActionSet;
   interface WriteVariableActionClass;
   interface WriteVariableAction;
   typedef sequence<WriteVariableAction> WriteVariableActionSet;
   interface AddVariableValueActionClass;
   interface AddVariableValueAction;
   typedef sequence<AddVariableValueAction> AddVariableValueActionSet;
   interface ClearVariableActionClass;
   interface ClearVariableAction;
   typedef sequence<ClearVariableAction> ClearVariableActionSet;
   interface ReadVariableActionClass;
   interface ReadVariableAction;
   typedef sequence<ReadVariableAction> ReadVariableActionSet;
   interface RemoveVariableValueActionClass;
   interface RemoveVariableValueAction;
   typedef sequence<RemoveVariableValueAction> RemoveVariableValueActionSet;
   interface SendSignalActionClass;
   interface SendSignalAction;
   typedef sequence<SendSignalAction> SendSignalActionSet;
   interface BroadcastSignalActionClass;
   interface BroadcastSignalAction;
   typedef sequence<BroadcastSignalAction> BroadcastSignalActionSet;
   interface CallProcedureActionClass;
   interface CallProcedureAction;
   typedef sequence<CallProcedureAction> CallProcedureActionSet;
   interface ActionsPackage;

   interface CollectionActionClass : ActionFoundation::ActionClass
   {
      readonly attribute CollectionActionSet all_of_type_collection_action;
   };

   interface CollectionAction : CollectionActionClass, ActionFoundation::Action
   {
      ActionFoundation::Action subaction ()
         raises (Reflective::MofError);
      void set_subaction (in ActionFoundation::Action new_value)
         raises (Reflective::MofError);
   }; // end of interface CollectionAction

   interface FilterActionClass : CollectionActionClass
   {
      readonly attribute FilterActionSet all_of_type_filter_action;
      readonly attribute FilterActionSet all_of_class_filter_action;
      FilterAction create_filter_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface FilterAction : FilterActionClass, CollectionAction
   {
      OutputPinUList subinput ()
         raises (Reflective::MofError);
      void set_subinput (in OutputPinUList new_value)
         raises (Reflective::MofError);
      void add_subinput (in ActionFoundation::OutputPin new_element)
         raises (Reflective::MofError);
      void add_subinput_before (
         in ActionFoundation::OutputPin new_element,
         in ActionFoundation::OutputPin before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_subinput (
         in ActionFoundation::OutputPin old_element,
         in ActionFoundation::OutputPin new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_subinput (in ActionFoundation::OutputPin old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ActionFoundation::OutputPin subtest ()
         raises (Reflective::MofError);
      void set_subtest (in ActionFoundation::OutputPin new_value)
         raises (Reflective::MofError);
      InputPinUList argument ()
         raises (Reflective::MofError);
      OutputPinUList result ()
         raises (Reflective::MofError);
   }; // end of interface FilterAction

   interface IterateActionClass : CollectionActionClass
   {
      readonly attribute IterateActionSet all_of_type_iterate_action;
      readonly attribute IterateActionSet all_of_class_iterate_action;
      IterateAction create_iterate_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only,
         in boolean is_unordered)
         raises (Reflective::MofError);
   };

   interface IterateAction : IterateActionClass, CollectionAction
   {
      OutputPinUList result ()
         raises (Reflective::MofError);
      InputPinUList loop_variable_input ()
         raises (Reflective::MofError);
      OutputPinSet subinput ()
         raises (Reflective::MofError);
      void set_subinput (in OutputPinSet new_value)
         raises (Reflective::MofError);
      void add_subinput (in ActionFoundation::OutputPin new_element)
         raises (Reflective::MofError);
      void modify_subinput (
         in ActionFoundation::OutputPin old_element,
         in ActionFoundation::OutputPin new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_subinput (in ActionFoundation::OutputPin old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      OutputPinUList loop_variable ()
         raises (Reflective::MofError);
      void set_loop_variable (in OutputPinUList new_value)
         raises (Reflective::MofError);
      void unset_loop_variable ()
         raises (Reflective::MofError);
      void add_loop_variable (in ActionFoundation::OutputPin new_element)
         raises (Reflective::MofError);
      void add_loop_variable_before (
         in ActionFoundation::OutputPin new_element,
         in ActionFoundation::OutputPin before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_loop_variable (
         in ActionFoundation::OutputPin old_element,
         in ActionFoundation::OutputPin new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_loop_variable (in ActionFoundation::OutputPin old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      InputPinUList collection_input ()
         raises (Reflective::MofError);
      OutputPinUList suboutput ()
         raises (Reflective::MofError);
      void set_suboutput (in OutputPinUList new_value)
         raises (Reflective::MofError);
      void unset_suboutput ()
         raises (Reflective::MofError);
      void add_suboutput (in ActionFoundation::OutputPin new_element)
         raises (Reflective::MofError);
      void add_suboutput_before (
         in ActionFoundation::OutputPin new_element,
         in ActionFoundation::OutputPin before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_suboutput (
         in ActionFoundation::OutputPin old_element,
         in ActionFoundation::OutputPin new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_suboutput (in ActionFoundation::OutputPin old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      boolean is_unordered ()
         raises (Reflective::MofError);
      void set_is_unordered (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface IterateAction

   interface MapActionClass : CollectionActionClass
   {
      readonly attribute MapActionSet all_of_type_map_action;
      readonly attribute MapActionSet all_of_class_map_action;
      MapAction create_map_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface MapAction : MapActionClass, CollectionAction
   {
      OutputPinUList result ()
         raises (Reflective::MofError);
      InputPinUList argument ()
         raises (Reflective::MofError);
      OutputPinUList subinput ()
         raises (Reflective::MofError);
      void set_subinput (in OutputPinUList new_value)
         raises (Reflective::MofError);
      void add_subinput (in ActionFoundation::OutputPin new_element)
         raises (Reflective::MofError);
      void add_subinput_before (
         in ActionFoundation::OutputPin new_element,
         in ActionFoundation::OutputPin before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_subinput (
         in ActionFoundation::OutputPin old_element,
         in ActionFoundation::OutputPin new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_subinput (in ActionFoundation::OutputPin old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      OutputPinUList suboutput ()
         raises (Reflective::MofError);
      void set_suboutput (in OutputPinUList new_value)
         raises (Reflective::MofError);
      void unset_suboutput ()
         raises (Reflective::MofError);
      void add_suboutput (in ActionFoundation::OutputPin new_element)
         raises (Reflective::MofError);
      void add_suboutput_before (
         in ActionFoundation::OutputPin new_element,
         in ActionFoundation::OutputPin before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_suboutput (
         in ActionFoundation::OutputPin old_element,
         in ActionFoundation::OutputPin new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_suboutput (in ActionFoundation::OutputPin old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface MapAction

   interface ReduceActionClass : CollectionActionClass
   {
      readonly attribute ReduceActionSet all_of_type_reduce_action;
      readonly attribute ReduceActionSet all_of_class_reduce_action;
      ReduceAction create_reduce_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only,
         in boolean is_unordered)
         raises (Reflective::MofError);
   };

   interface ReduceAction : ReduceActionClass, CollectionAction
   {
      OutputPinUList left_subinput ()
         raises (Reflective::MofError);
      void set_left_subinput (in OutputPinUList new_value)
         raises (Reflective::MofError);
      void add_left_subinput (in ActionFoundation::OutputPin new_element)
         raises (Reflective::MofError);
      void add_left_subinput_before (
         in ActionFoundation::OutputPin new_element,
         in ActionFoundation::OutputPin before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_left_subinput (
         in ActionFoundation::OutputPin old_element,
         in ActionFoundation::OutputPin new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_left_subinput (in ActionFoundation::OutputPin old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      OutputPinUList suboutput ()
         raises (Reflective::MofError);
      void set_suboutput (in OutputPinUList new_value)
         raises (Reflective::MofError);
      void add_suboutput (in ActionFoundation::OutputPin new_element)
         raises (Reflective::MofError);
      void add_suboutput_before (
         in ActionFoundation::OutputPin new_element,
         in ActionFoundation::OutputPin before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_suboutput (
         in ActionFoundation::OutputPin old_element,
         in ActionFoundation::OutputPin new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_suboutput (in ActionFoundation::OutputPin old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      OutputPinUList right_subinput ()
         raises (Reflective::MofError);
      void set_right_subinput (in OutputPinUList new_value)
         raises (Reflective::MofError);
      void add_right_subinput (in ActionFoundation::OutputPin new_element)
         raises (Reflective::MofError);
      void add_right_subinput_before (
         in ActionFoundation::OutputPin new_element,
         in ActionFoundation::OutputPin before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_right_subinput (
         in ActionFoundation::OutputPin old_element,
         in ActionFoundation::OutputPin new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_right_subinput (in ActionFoundation::OutputPin old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      InputPinUList argument ()
         raises (Reflective::MofError);
      OutputPinUList result ()
         raises (Reflective::MofError);
      boolean is_unordered ()
         raises (Reflective::MofError);
      void set_is_unordered (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface ReduceAction

   interface ClauseClass : Core::ElementClass
   {
      readonly attribute ClauseSet all_of_type_clause;
      readonly attribute ClauseSet all_of_class_clause;
      Clause create_clause ()
         raises (Reflective::MofError);
   };

   interface Clause : ClauseClass, Core::Element
   {
      ActionFoundation::Action body ()
         raises (Reflective::MofError);
      void set_body (in ActionFoundation::Action new_value)
         raises (Reflective::MofError);
      ActionFoundation::Action test ()
         raises (Reflective::MofError);
      void set_test (in ActionFoundation::Action new_value)
         raises (Reflective::MofError);
      OutputPinUList body_output ()
         raises (Reflective::MofError);
      void set_body_output (in OutputPinUList new_value)
         raises (Reflective::MofError);
      void unset_body_output ()
         raises (Reflective::MofError);
      void add_body_output (in ActionFoundation::OutputPin new_element)
         raises (Reflective::MofError);
      void add_body_output_before (
         in ActionFoundation::OutputPin new_element,
         in ActionFoundation::OutputPin before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_body_output (
         in ActionFoundation::OutputPin old_element,
         in ActionFoundation::OutputPin new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_body_output (in ActionFoundation::OutputPin old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ActionFoundation::OutputPin test_output ()
         raises (Reflective::MofError);
      void set_test_output (in ActionFoundation::OutputPin new_value)
         raises (Reflective::MofError);
      ClauseSet successor_clause ()
         raises (Reflective::MofError);
      void set_successor_clause (in ClauseSet new_value)
         raises (Reflective::MofError);
      void unset_successor_clause ()
         raises (Reflective::MofError);
      void add_successor_clause (in Clause new_element)
         raises (Reflective::MofError);
      void modify_successor_clause (
         in Clause old_element,
         in Clause new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_successor_clause (in Clause old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ClauseSet predecessor_clause ()
         raises (Reflective::MofError);
      void set_predecessor_clause (in ClauseSet new_value)
         raises (Reflective::MofError);
      void unset_predecessor_clause ()
         raises (Reflective::MofError);
      void add_predecessor_clause (in Clause new_element)
         raises (Reflective::MofError);
      void modify_predecessor_clause (
         in Clause old_element,
         in Clause new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_predecessor_clause (in Clause old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Clause

   interface ConditionalActionClass : ActionFoundation::ActionClass
   {
      readonly attribute ConditionalActionSet all_of_type_conditional_action;
      readonly attribute ConditionalActionSet all_of_class_conditional_action;
      ConditionalAction create_conditional_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only,
         in boolean is_determinate)
         raises (Reflective::MofError);
   };

   interface ConditionalAction : ConditionalActionClass, ActionFoundation::Action
   {
      ClauseSet clause ()
         raises (Reflective::MofError);
      void set_clause (in ClauseSet new_value)
         raises (Reflective::MofError);
      void add_clause (in Actions::Clause new_element)
         raises (Reflective::MofError);
      void modify_clause (
         in Actions::Clause old_element,
         in Actions::Clause new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_clause (in Actions::Clause old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      boolean is_determinate ()
         raises (Reflective::MofError);
      void set_is_determinate (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface ConditionalAction

   interface GroupActionClass : ActionFoundation::ActionClass
   {
      readonly attribute GroupActionSet all_of_type_group_action;
      readonly attribute GroupActionSet all_of_class_group_action;
      GroupAction create_group_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only,
         in boolean must_isolate)
         raises (Reflective::MofError);
   };

   interface GroupAction : GroupActionClass, ActionFoundation::Action
   {
      ActionSet subaction ()
         raises (Reflective::MofError);
      void set_subaction (in ActionSet new_value)
         raises (Reflective::MofError);
      void unset_subaction ()
         raises (Reflective::MofError);
      void add_subaction (in ActionFoundation::Action new_element)
         raises (Reflective::MofError);
      void modify_subaction (
         in ActionFoundation::Action old_element,
         in ActionFoundation::Action new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_subaction (in ActionFoundation::Action old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      VariableSet variable ()
         raises (Reflective::MofError);
      void set_variable (in VariableSet new_value)
         raises (Reflective::MofError);
      void unset_variable ()
         raises (Reflective::MofError);
      void add_variable (in Actions::Variable new_element)
         raises (Reflective::MofError);
      void modify_variable (
         in Actions::Variable old_element,
         in Actions::Variable new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_variable (in Actions::Variable old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      boolean must_isolate ()
         raises (Reflective::MofError);
      void set_must_isolate (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface GroupAction

   interface LoopActionClass : ActionFoundation::ActionClass
   {
      readonly attribute LoopActionSet all_of_type_loop_action;
      readonly attribute LoopActionSet all_of_class_loop_action;
      LoopAction create_loop_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface LoopAction : LoopActionClass, ActionFoundation::Action
   {
      Actions::Clause clause ()
         raises (Reflective::MofError);
      void set_clause (in Actions::Clause new_value)
         raises (Reflective::MofError);
      OutputPinUList loop_variable ()
         raises (Reflective::MofError);
      void set_loop_variable (in OutputPinUList new_value)
         raises (Reflective::MofError);
      void unset_loop_variable ()
         raises (Reflective::MofError);
      void add_loop_variable (in ActionFoundation::OutputPin new_element)
         raises (Reflective::MofError);
      void add_loop_variable_before (
         in ActionFoundation::OutputPin new_element,
         in ActionFoundation::OutputPin before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_loop_variable (
         in ActionFoundation::OutputPin old_element,
         in ActionFoundation::OutputPin new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_loop_variable (in ActionFoundation::OutputPin old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface LoopAction

   interface VariableClass : Core::ModelElementClass
   {
      readonly attribute VariableSet all_of_type_variable;
      readonly attribute VariableSet all_of_class_variable;
      Variable create_variable (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::Multiplicity multiplicity,
         in DataTypes::OrderingKind ordering)
         raises (Reflective::MofError);
   };

   interface Variable : VariableClass, Core::ModelElement
   {
      Core::Classifier type ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_type (in Core::Classifier new_value)
         raises (Reflective::MofError);
      void unset_type ()
         raises (Reflective::MofError);
      GroupAction scope ()
         raises (Reflective::MofError);
      void set_scope (in GroupAction new_value)
         raises (Reflective::MofError);
      DataTypes::Multiplicity multiplicity ()
         raises (Reflective::MofError);
      void set_multiplicity (in DataTypes::Multiplicity new_value)
         raises (Reflective::MofError);
      DataTypes::OrderingKind ordering ()
         raises (Reflective::MofError);
      void set_ordering (in DataTypes::OrderingKind new_value)
         raises (Reflective::MofError);
   }; // end of interface Variable

   interface ApplyFunctionActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute ApplyFunctionActionSet all_of_type_apply_function_action;
      readonly attribute ApplyFunctionActionSet all_of_class_apply_function_action;
      ApplyFunctionAction create_apply_function_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface ApplyFunctionAction : ApplyFunctionActionClass, ActionFoundation::PrimitiveAction
   {
      InputPinUList argument ()
         raises (Reflective::MofError);
      PrimitiveFunction function ()
         raises (Reflective::MofError);
      void set_function (in PrimitiveFunction new_value)
         raises (Reflective::MofError);
      OutputPinUList result ()
         raises (Reflective::MofError);
   }; // end of interface ApplyFunctionAction

   interface ArgumentSpecificationClass : Core::ModelElementClass
   {
      readonly attribute ArgumentSpecificationSet all_of_type_argument_specification;
      readonly attribute ArgumentSpecificationSet all_of_class_argument_specification;
      ArgumentSpecification create_argument_specification (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::Multiplicity multiplicity,
         in DataTypes::OrderingKind ordering)
         raises (Reflective::MofError);
   };

   interface ArgumentSpecification : ArgumentSpecificationClass, Core::ModelElement
   {
      Core::DataType type ()
         raises (Reflective::MofError);
      void set_type (in Core::DataType new_value)
         raises (Reflective::MofError);
      DataTypes::Multiplicity multiplicity ()
         raises (Reflective::MofError);
      void set_multiplicity (in DataTypes::Multiplicity new_value)
         raises (Reflective::MofError);
      DataTypes::OrderingKind ordering ()
         raises (Reflective::MofError);
      void set_ordering (in DataTypes::OrderingKind new_value)
         raises (Reflective::MofError);
   }; // end of interface ArgumentSpecification

   interface CodeActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute CodeActionSet all_of_type_code_action;
      readonly attribute CodeActionSet all_of_class_code_action;
      CodeAction create_code_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only,
         in string language,
         in string encoding)
         raises (Reflective::MofError);
   };

   interface CodeAction : CodeActionClass, ActionFoundation::PrimitiveAction
   {
      InputPinUList argument ()
         raises (Reflective::MofError);
      OutputPinUList result ()
         raises (Reflective::MofError);
      string language ()
         raises (Reflective::MofError);
      void set_language (in string new_value)
         raises (Reflective::MofError);
      string encoding ()
         raises (Reflective::MofError);
      void set_encoding (in string new_value)
         raises (Reflective::MofError);
   }; // end of interface CodeAction

   interface LiteralValueActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute LiteralValueActionSet all_of_type_literal_value_action;
      readonly attribute LiteralValueActionSet all_of_class_literal_value_action;
      LiteralValueAction create_literal_value_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface LiteralValueAction : LiteralValueActionClass, ActionFoundation::PrimitiveAction
   {
      CommonBehavior::DataValue value ()
         raises (Reflective::MofError);
      void set_value (in CommonBehavior::DataValue new_value)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin result ()
         raises (Reflective::MofError);
   }; // end of interface LiteralValueAction

   interface MarshalActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute MarshalActionSet all_of_type_marshal_action;
      readonly attribute MarshalActionSet all_of_class_marshal_action;
      MarshalAction create_marshal_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface MarshalAction : MarshalActionClass, ActionFoundation::PrimitiveAction
   {
      InputPinUList argument ()
         raises (Reflective::MofError);
      ActionFoundation::OutputPin result ()
         raises (Reflective::MofError);
      Core::Class marshal_type ()
         raises (Reflective::MofError);
      void set_marshal_type (in Core::Class new_value)
         raises (Reflective::MofError);
   }; // end of interface MarshalAction

   interface NullActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute NullActionSet all_of_type_null_action;
      readonly attribute NullActionSet all_of_class_null_action;
      NullAction create_null_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface NullAction : NullActionClass, ActionFoundation::PrimitiveAction
   {
   }; // end of interface NullAction

   interface PrimitiveFunctionClass : Core::ModelElementClass
   {
      readonly attribute PrimitiveFunctionSet all_of_type_primitive_function;
      readonly attribute PrimitiveFunctionSet all_of_class_primitive_function;
      PrimitiveFunction create_primitive_function (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in string language,
         in string encoding)
         raises (Reflective::MofError);
   };

   interface PrimitiveFunction : PrimitiveFunctionClass, Core::ModelElement
   {
      ArgumentSpecificationSet input_spec ()
         raises (Reflective::MofError);
      void set_input_spec (in ArgumentSpecificationSet new_value)
         raises (Reflective::MofError);
      void unset_input_spec ()
         raises (Reflective::MofError);
      void add_input_spec (in ArgumentSpecification new_element)
         raises (Reflective::MofError);
      void modify_input_spec (
         in ArgumentSpecification old_element,
         in ArgumentSpecification new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_input_spec (in ArgumentSpecification old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ArgumentSpecificationSet output_spec ()
         raises (Reflective::MofError);
      void set_output_spec (in ArgumentSpecificationSet new_value)
         raises (Reflective::MofError);
      void add_output_spec (in ArgumentSpecification new_element)
         raises (Reflective::MofError);
      void modify_output_spec (
         in ArgumentSpecification old_element,
         in ArgumentSpecification new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_output_spec (in ArgumentSpecification old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      string language ()
         raises (Reflective::MofError);
      void set_language (in string new_value)
         raises (Reflective::MofError);
      string encoding ()
         raises (Reflective::MofError);
      void set_encoding (in string new_value)
         raises (Reflective::MofError);
   }; // end of interface PrimitiveFunction

   interface TestIdentityActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute TestIdentityActionSet all_of_type_test_identity_action;
      readonly attribute TestIdentityActionSet all_of_class_test_identity_action;
      TestIdentityAction create_test_identity_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface TestIdentityAction : TestIdentityActionClass, ActionFoundation::PrimitiveAction
   {
      InputPinSet first ()
         raises (Reflective::MofError);
      InputPinSet second ()
         raises (Reflective::MofError);
      ActionFoundation::OutputPin result ()
         raises (Reflective::MofError);
   }; // end of interface TestIdentityAction

   interface UnmarshalActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute UnmarshalActionSet all_of_type_unmarshal_action;
      readonly attribute UnmarshalActionSet all_of_class_unmarshal_action;
      UnmarshalAction create_unmarshal_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface UnmarshalAction : UnmarshalActionClass, ActionFoundation::PrimitiveAction
   {
      ActionFoundation::InputPin argument ()
         raises (Reflective::MofError);
      OutputPinUList result ()
         raises (Reflective::MofError);
      Core::Class unmarshal_type ()
         raises (Reflective::MofError);
      void set_unmarshal_type (in Core::Class new_value)
         raises (Reflective::MofError);
   }; // end of interface UnmarshalAction

   interface JumpHandlerClass : Reflective::RefObject
   {
      readonly attribute JumpHandlerSet all_of_type_jump_handler;
      readonly attribute JumpHandlerSet all_of_class_jump_handler;
      JumpHandler create_jump_handler ()
         raises (Reflective::MofError);
   };

   interface JumpHandler : JumpHandlerClass
   {
      ActionSet protected_action ()
         raises (Reflective::MofError);
      void set_protected_action (in ActionSet new_value)
         raises (Reflective::MofError);
      void unset_protected_action ()
         raises (Reflective::MofError);
      void add_protected_action (in ActionFoundation::Action new_element)
         raises (Reflective::MofError);
      void modify_protected_action (
         in ActionFoundation::Action old_element,
         in ActionFoundation::Action new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_protected_action (in ActionFoundation::Action old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      Core::Classifier jump_type ()
         raises (Reflective::MofError);
      void set_jump_type (in Core::Classifier new_value)
         raises (Reflective::MofError);
      HandlerAction body ()
         raises (Reflective::MofError);
      void set_body (in HandlerAction new_value)
         raises (Reflective::MofError);
   }; // end of interface JumpHandler

   interface HandlerActionClass : ActionFoundation::ActionClass
   {
      readonly attribute HandlerActionSet all_of_type_handler_action;
      readonly attribute HandlerActionSet all_of_class_handler_action;
      HandlerAction create_handler_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface HandlerAction : HandlerActionClass, ActionFoundation::Action
   {
      OutputPinUList handler_output ()
         raises (Reflective::MofError);
      void set_handler_output (in OutputPinUList new_value)
         raises (Reflective::MofError);
      void unset_handler_output ()
         raises (Reflective::MofError);
      void add_handler_output (in ActionFoundation::OutputPin new_element)
         raises (Reflective::MofError);
      void add_handler_output_before (
         in ActionFoundation::OutputPin new_element,
         in ActionFoundation::OutputPin before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_handler_output (
         in ActionFoundation::OutputPin old_element,
         in ActionFoundation::OutputPin new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_handler_output (in ActionFoundation::OutputPin old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ActionFoundation::Action body ()
         raises (Reflective::MofError);
      void set_body (in ActionFoundation::Action new_value)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin occurrence ()
         raises (Reflective::MofError);
   }; // end of interface HandlerAction

   interface JumpActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute JumpActionSet all_of_type_jump_action;
      readonly attribute JumpActionSet all_of_class_jump_action;
      JumpAction create_jump_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface JumpAction : JumpActionClass, ActionFoundation::PrimitiveAction
   {
      CommonBehavior::UmlException uml_exception ()
         raises (Reflective::MofError);
      void set_uml_exception (in CommonBehavior::UmlException new_value)
         raises (Reflective::MofError);
      ActionFoundation::InputPin jump_occurence ()
         raises (Reflective::MofError);
   }; // end of interface JumpAction

   interface InvocationActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute InvocationActionSet all_of_type_invocation_action;
   };

   interface InvocationAction : InvocationActionClass, ActionFoundation::PrimitiveAction
   {
      ActionFoundation::InputPin target ()
         raises (Reflective::MofError);
      ActionFoundation::InputPin request ()
         raises (Reflective::MofError);
   }; // end of interface InvocationAction

   interface AsynchronousInvocationActionClass : InvocationActionClass
   {
      readonly attribute AsynchronousInvocationActionSet all_of_type_asynchronous_invocation_action;
      readonly attribute AsynchronousInvocationActionSet all_of_class_asynchronous_invocation_action;
      AsynchronousInvocationAction create_asynchronous_invocation_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only,
         in boolean is_repliable)
         raises (Reflective::MofError);
   };

   interface AsynchronousInvocationAction : AsynchronousInvocationActionClass, InvocationAction
   {
      boolean is_repliable ()
         raises (Reflective::MofError);
      void set_is_repliable (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface AsynchronousInvocationAction

   interface ExplicitInvocationActtionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute ExplicitInvocationActtionSet all_of_type_explicit_invocation_acttion;
   };

   interface ExplicitInvocationActtion : ExplicitInvocationActtionClass, ActionFoundation::PrimitiveAction
   {
      InputPinSet argument ()
         raises (Reflective::MofError);
   }; // end of interface ExplicitInvocationActtion

   interface CallOperationActionClass : ExplicitInvocationActtionClass
   {
      readonly attribute CallOperationActionSet all_of_type_call_operation_action;
      readonly attribute CallOperationActionSet all_of_class_call_operation_action;
      CallOperationAction create_call_operation_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only,
         in boolean is_asynchronous)
         raises (Reflective::MofError);
   };

   interface CallOperationAction : CallOperationActionClass, ExplicitInvocationActtion
   {
      OutputPinSet result ()
         raises (Reflective::MofError);
      ActionFoundation::InputPin target ()
         raises (Reflective::MofError);
      Core::Operation operation ()
         raises (Reflective::MofError);
      void set_operation (in Core::Operation new_value)
         raises (Reflective::MofError);
      boolean is_asynchronous ()
         raises (Reflective::MofError);
      void set_is_asynchronous (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface CallOperationAction

   interface SynchronousInvocationActionClass : InvocationActionClass
   {
      readonly attribute SynchronousInvocationActionSet all_of_type_synchronous_invocation_action;
      readonly attribute SynchronousInvocationActionSet all_of_class_synchronous_invocation_action;
      SynchronousInvocationAction create_synchronous_invocation_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface SynchronousInvocationAction : SynchronousInvocationActionClass, InvocationAction
   {
      ActionFoundation::OutputPin reply ()
         raises (Reflective::MofError);
   }; // end of interface SynchronousInvocationAction

   interface ClearAssociationActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute ClearAssociationActionSet all_of_type_clear_association_action;
      readonly attribute ClearAssociationActionSet all_of_class_clear_association_action;
      ClearAssociationAction create_clear_association_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface ClearAssociationAction : ClearAssociationActionClass, ActionFoundation::PrimitiveAction
   {
      Core::Association association ()
         raises (Reflective::MofError);
      void set_association (in Core::Association new_value)
         raises (Reflective::MofError);
      ActionFoundation::InputPin action_object ()
         raises (Reflective::MofError);
   }; // end of interface ClearAssociationAction

   interface LinkActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute LinkActionSet all_of_type_link_action;
   };

   interface LinkAction : LinkActionClass, ActionFoundation::PrimitiveAction
   {
      LinkEndDataSet end_data ()
         raises (Reflective::MofError);
      void set_end_data (in LinkEndDataSet new_value)
         raises (Reflective::MofError);
      void add_end_data (in LinkEndData new_element)
         raises (Reflective::MofError);
      void modify_end_data (
         in LinkEndData old_element,
         in LinkEndData new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_end_data (in LinkEndData old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface LinkAction

   interface WriteLinkActionClass : LinkActionClass
   {
      readonly attribute WriteLinkActionSet all_of_type_write_link_action;
   };

   interface WriteLinkAction : WriteLinkActionClass, LinkAction
   {
   }; // end of interface WriteLinkAction

   interface CreateLinkActionClass : WriteLinkActionClass
   {
      readonly attribute CreateLinkActionSet all_of_type_create_link_action;
      readonly attribute CreateLinkActionSet all_of_class_create_link_action;
      CreateLinkAction create_create_link_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface CreateLinkAction : CreateLinkActionClass, WriteLinkAction
   {
   }; // end of interface CreateLinkAction

   interface CreateLinkObjectActionClass : CreateLinkActionClass
   {
      readonly attribute CreateLinkObjectActionSet all_of_type_create_link_object_action;
      readonly attribute CreateLinkObjectActionSet all_of_class_create_link_object_action;
      CreateLinkObjectAction create_create_link_object_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface CreateLinkObjectAction : CreateLinkObjectActionClass, CreateLinkAction
   {
      ActionFoundation::OutputPin result ()
         raises (Reflective::MofError);
   }; // end of interface CreateLinkObjectAction

   interface DestroyLinkActionClass : WriteLinkActionClass
   {
      readonly attribute DestroyLinkActionSet all_of_type_destroy_link_action;
      readonly attribute DestroyLinkActionSet all_of_class_destroy_link_action;
      DestroyLinkAction create_destroy_link_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface DestroyLinkAction : DestroyLinkActionClass, WriteLinkAction
   {
   }; // end of interface DestroyLinkAction

   interface LinkEndDataClass : Reflective::RefObject
   {
      readonly attribute LinkEndDataSet all_of_type_link_end_data;
      readonly attribute LinkEndDataSet all_of_class_link_end_data;
      LinkEndData create_link_end_data ()
         raises (Reflective::MofError);
   };

   interface LinkEndData : LinkEndDataClass
   {
      Core::AssociationEnd end ()
         raises (Reflective::MofError);
      void set_end (in Core::AssociationEnd new_value)
         raises (Reflective::MofError);
      ActionFoundation::InputPin value ()
         raises (Reflective::NotSet, Reflective::MofError);
      QualifierValueSet qualifier ()
         raises (Reflective::MofError);
      void set_qualifier (in QualifierValueSet new_value)
         raises (Reflective::MofError);
      void unset_qualifier ()
         raises (Reflective::MofError);
      void add_qualifier (in QualifierValue new_element)
         raises (Reflective::MofError);
      void modify_qualifier (
         in QualifierValue old_element,
         in QualifierValue new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_qualifier (in QualifierValue old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface LinkEndData

   interface LinkEndCreationDataClass : LinkEndDataClass
   {
      readonly attribute LinkEndCreationDataSet all_of_type_link_end_creation_data;
      readonly attribute LinkEndCreationDataSet all_of_class_link_end_creation_data;
      LinkEndCreationData create_link_end_creation_data (
         in boolean is_replace_all)
         raises (Reflective::MofError);
   };

   interface LinkEndCreationData : LinkEndCreationDataClass, LinkEndData
   {
      ActionFoundation::InputPin insert_at ()
         raises (Reflective::NotSet, Reflective::MofError);
      boolean is_replace_all ()
         raises (Reflective::MofError);
      void set_is_replace_all (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface LinkEndCreationData

   interface QualifierValueClass : Reflective::RefObject
   {
      readonly attribute QualifierValueSet all_of_type_qualifier_value;
      readonly attribute QualifierValueSet all_of_class_qualifier_value;
      QualifierValue create_qualifier_value ()
         raises (Reflective::MofError);
   };

   interface QualifierValue : QualifierValueClass
   {
      Core::UmlAttribute qualifier ()
         raises (Reflective::MofError);
      void set_qualifier (in Core::UmlAttribute new_value)
         raises (Reflective::MofError);
      ActionFoundation::InputPin value ()
         raises (Reflective::MofError);
   }; // end of interface QualifierValue

   interface ReadLinkActionClass : LinkActionClass
   {
      readonly attribute ReadLinkActionSet all_of_type_read_link_action;
      readonly attribute ReadLinkActionSet all_of_class_read_link_action;
      ReadLinkAction create_read_link_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface ReadLinkAction : ReadLinkActionClass, LinkAction
   {
      ActionFoundation::OutputPin result ()
         raises (Reflective::MofError);
   }; // end of interface ReadLinkAction

   interface ReadLinkObjectEndActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute ReadLinkObjectEndActionSet all_of_type_read_link_object_end_action;
      readonly attribute ReadLinkObjectEndActionSet all_of_class_read_link_object_end_action;
      ReadLinkObjectEndAction create_read_link_object_end_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface ReadLinkObjectEndAction : ReadLinkObjectEndActionClass, ActionFoundation::PrimitiveAction
   {
      ActionFoundation::OutputPin result ()
         raises (Reflective::MofError);
      ActionFoundation::InputPin action_object ()
         raises (Reflective::MofError);
      Core::AssociationEnd end ()
         raises (Reflective::MofError);
      void set_end (in Core::AssociationEnd new_value)
         raises (Reflective::MofError);
   }; // end of interface ReadLinkObjectEndAction

   interface ReadLinkObjectQualifierActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute ReadLinkObjectQualifierActionSet all_of_type_read_link_object_qualifier_action;
      readonly attribute ReadLinkObjectQualifierActionSet all_of_class_read_link_object_qualifier_action;
      ReadLinkObjectQualifierAction create_read_link_object_qualifier_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface ReadLinkObjectQualifierAction : ReadLinkObjectQualifierActionClass, ActionFoundation::PrimitiveAction
   {
      ActionFoundation::OutputPin result ()
         raises (Reflective::MofError);
      ActionFoundation::InputPin action_object ()
         raises (Reflective::MofError);
      Core::UmlAttribute qualifier ()
         raises (Reflective::MofError);
      void set_qualifier (in Core::UmlAttribute new_value)
         raises (Reflective::MofError);
   }; // end of interface ReadLinkObjectQualifierAction

   interface AttributeActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute AttributeActionSet all_of_type_attribute_action;
   };

   interface AttributeAction : AttributeActionClass, ActionFoundation::PrimitiveAction
   {
      ActionFoundation::InputPin action_object ()
         raises (Reflective::NotSet, Reflective::MofError);
      Core::UmlAttribute uml_attribute ()
         raises (Reflective::MofError);
      void set_uml_attribute (in Core::UmlAttribute new_value)
         raises (Reflective::MofError);
   }; // end of interface AttributeAction

   interface WriteAttributeActionClass : AttributeActionClass
   {
      readonly attribute WriteAttributeActionSet all_of_type_write_attribute_action;
   };

   interface WriteAttributeAction : WriteAttributeActionClass, AttributeAction
   {
      ActionFoundation::InputPin value ()
         raises (Reflective::MofError);
   }; // end of interface WriteAttributeAction

   interface AddAttributeValueActionClass : WriteAttributeActionClass
   {
      readonly attribute AddAttributeValueActionSet all_of_type_add_attribute_value_action;
      readonly attribute AddAttributeValueActionSet all_of_class_add_attribute_value_action;
      AddAttributeValueAction create_add_attribute_value_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only,
         in boolean is_replace_all)
         raises (Reflective::MofError);
   };

   interface AddAttributeValueAction : AddAttributeValueActionClass, WriteAttributeAction
   {
      ActionFoundation::InputPin insert_at ()
         raises (Reflective::NotSet, Reflective::MofError);
      boolean is_replace_all ()
         raises (Reflective::MofError);
      void set_is_replace_all (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface AddAttributeValueAction

   interface ClearAttributeActionClass : AttributeActionClass
   {
      readonly attribute ClearAttributeActionSet all_of_type_clear_attribute_action;
      readonly attribute ClearAttributeActionSet all_of_class_clear_attribute_action;
      ClearAttributeAction create_clear_attribute_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface ClearAttributeAction : ClearAttributeActionClass, AttributeAction
   {
   }; // end of interface ClearAttributeAction

   interface ReadAttributeActionClass : AttributeActionClass
   {
      readonly attribute ReadAttributeActionSet all_of_type_read_attribute_action;
      readonly attribute ReadAttributeActionSet all_of_class_read_attribute_action;
      ReadAttributeAction create_read_attribute_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface ReadAttributeAction : ReadAttributeActionClass, AttributeAction
   {
      ActionFoundation::OutputPin result ()
         raises (Reflective::MofError);
   }; // end of interface ReadAttributeAction

   interface RemoveAttributeValueActionClass : WriteAttributeActionClass
   {
      readonly attribute RemoveAttributeValueActionSet all_of_type_remove_attribute_value_action;
      readonly attribute RemoveAttributeValueActionSet all_of_class_remove_attribute_value_action;
      RemoveAttributeValueAction create_remove_attribute_value_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface RemoveAttributeValueAction : RemoveAttributeValueActionClass, WriteAttributeAction
   {
   }; // end of interface RemoveAttributeValueAction

   interface CreateObjectActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute CreateObjectActionSet all_of_type_create_object_action;
      readonly attribute CreateObjectActionSet all_of_class_create_object_action;
      CreateObjectAction create_create_object_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface CreateObjectAction : CreateObjectActionClass, ActionFoundation::PrimitiveAction
   {
      Core::Classifier classifier ()
         raises (Reflective::MofError);
      void set_classifier (in Core::Classifier new_value)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin result ()
         raises (Reflective::MofError);
   }; // end of interface CreateObjectAction

   interface DestroyObjectActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute DestroyObjectActionSet all_of_type_destroy_object_action;
      readonly attribute DestroyObjectActionSet all_of_class_destroy_object_action;
      DestroyObjectAction create_destroy_object_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface DestroyObjectAction : DestroyObjectActionClass, ActionFoundation::PrimitiveAction
   {
      ActionFoundation::InputPin input ()
         raises (Reflective::MofError);
   }; // end of interface DestroyObjectAction

   interface ReadIsClassifiedObjectActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute ReadIsClassifiedObjectActionSet all_of_type_read_is_classified_object_action;
      readonly attribute ReadIsClassifiedObjectActionSet all_of_class_read_is_classified_object_action;
      ReadIsClassifiedObjectAction create_read_is_classified_object_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only,
         in boolean is_direct)
         raises (Reflective::MofError);
   };

   interface ReadIsClassifiedObjectAction : ReadIsClassifiedObjectActionClass, ActionFoundation::PrimitiveAction
   {
      Core::Classifier classifier ()
         raises (Reflective::MofError);
      void set_classifier (in Core::Classifier new_value)
         raises (Reflective::MofError);
      ActionFoundation::InputPin input ()
         raises (Reflective::MofError);
      ActionFoundation::OutputPin result ()
         raises (Reflective::MofError);
      boolean is_direct ()
         raises (Reflective::MofError);
      void set_is_direct (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface ReadIsClassifiedObjectAction

   interface ReclassifyObjectActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute ReclassifyObjectActionSet all_of_type_reclassify_object_action;
      readonly attribute ReclassifyObjectActionSet all_of_class_reclassify_object_action;
      ReclassifyObjectAction create_reclassify_object_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only,
         in boolean is_replace_all)
         raises (Reflective::MofError);
   };

   interface ReclassifyObjectAction : ReclassifyObjectActionClass, ActionFoundation::PrimitiveAction
   {
      ClassifierSet old_classifier ()
         raises (Reflective::MofError);
      void set_old_classifier (in ClassifierSet new_value)
         raises (Reflective::MofError);
      void unset_old_classifier ()
         raises (Reflective::MofError);
      void add_old_classifier (in Core::Classifier new_element)
         raises (Reflective::MofError);
      void modify_old_classifier (
         in Core::Classifier old_element,
         in Core::Classifier new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_old_classifier (in Core::Classifier old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ClassifierSet new_classifier ()
         raises (Reflective::MofError);
      void set_new_classifier (in ClassifierSet new_value)
         raises (Reflective::MofError);
      void unset_new_classifier ()
         raises (Reflective::MofError);
      void add_new_classifier (in Core::Classifier new_element)
         raises (Reflective::MofError);
      void modify_new_classifier (
         in Core::Classifier old_element,
         in Core::Classifier new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_new_classifier (in Core::Classifier old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ActionFoundation::InputPin input ()
         raises (Reflective::MofError);
      boolean is_replace_all ()
         raises (Reflective::MofError);
      void set_is_replace_all (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface ReclassifyObjectAction

   interface ReadExtentActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute ReadExtentActionSet all_of_type_read_extent_action;
      readonly attribute ReadExtentActionSet all_of_class_read_extent_action;
      ReadExtentAction create_read_extent_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface ReadExtentAction : ReadExtentActionClass, ActionFoundation::PrimitiveAction
   {
      ActionFoundation::OutputPin result ()
         raises (Reflective::MofError);
      Core::Classifier classifier ()
         raises (Reflective::MofError);
      void set_classifier (in Core::Classifier new_value)
         raises (Reflective::MofError);
   }; // end of interface ReadExtentAction

   interface ReadSelfActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute ReadSelfActionSet all_of_type_read_self_action;
      readonly attribute ReadSelfActionSet all_of_class_read_self_action;
      ReadSelfAction create_read_self_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface ReadSelfAction : ReadSelfActionClass, ActionFoundation::PrimitiveAction
   {
      ActionFoundation::OutputPin result ()
         raises (Reflective::MofError);
   }; // end of interface ReadSelfAction

   interface StartObjectStateMachineActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute StartObjectStateMachineActionSet all_of_type_start_object_state_machine_action;
      readonly attribute StartObjectStateMachineActionSet all_of_class_start_object_state_machine_action;
      StartObjectStateMachineAction create_start_object_state_machine_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface StartObjectStateMachineAction : StartObjectStateMachineActionClass, ActionFoundation::PrimitiveAction
   {
      ActionFoundation::InputPin input ()
         raises (Reflective::MofError);
   }; // end of interface StartObjectStateMachineAction

   interface VariableActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute VariableActionSet all_of_type_variable_action;
   };

   interface VariableAction : VariableActionClass, ActionFoundation::PrimitiveAction
   {
      Actions::Variable variable ()
         raises (Reflective::MofError);
      void set_variable (in Actions::Variable new_value)
         raises (Reflective::MofError);
   }; // end of interface VariableAction

   interface WriteVariableActionClass : VariableActionClass
   {
      readonly attribute WriteVariableActionSet all_of_type_write_variable_action;
   };

   interface WriteVariableAction : WriteVariableActionClass, VariableAction
   {
      ActionFoundation::InputPin value ()
         raises (Reflective::MofError);
   }; // end of interface WriteVariableAction

   interface AddVariableValueActionClass : WriteVariableActionClass
   {
      readonly attribute AddVariableValueActionSet all_of_type_add_variable_value_action;
      readonly attribute AddVariableValueActionSet all_of_class_add_variable_value_action;
      AddVariableValueAction create_add_variable_value_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only,
         in boolean is_replace_all)
         raises (Reflective::MofError);
   };

   interface AddVariableValueAction : AddVariableValueActionClass, WriteVariableAction
   {
      ActionFoundation::InputPin insert_at ()
         raises (Reflective::NotSet, Reflective::MofError);
      boolean is_replace_all ()
         raises (Reflective::MofError);
      void set_is_replace_all (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface AddVariableValueAction

   interface ClearVariableActionClass : VariableActionClass
   {
      readonly attribute ClearVariableActionSet all_of_type_clear_variable_action;
      readonly attribute ClearVariableActionSet all_of_class_clear_variable_action;
      ClearVariableAction create_clear_variable_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface ClearVariableAction : ClearVariableActionClass, VariableAction
   {
   }; // end of interface ClearVariableAction

   interface ReadVariableActionClass : VariableActionClass
   {
      readonly attribute ReadVariableActionSet all_of_type_read_variable_action;
      readonly attribute ReadVariableActionSet all_of_class_read_variable_action;
      ReadVariableAction create_read_variable_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface ReadVariableAction : ReadVariableActionClass, VariableAction
   {
      ActionFoundation::OutputPin result ()
         raises (Reflective::MofError);
   }; // end of interface ReadVariableAction

   interface RemoveVariableValueActionClass : WriteVariableActionClass
   {
      readonly attribute RemoveVariableValueActionSet all_of_type_remove_variable_value_action;
      readonly attribute RemoveVariableValueActionSet all_of_class_remove_variable_value_action;
      RemoveVariableValueAction create_remove_variable_value_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface RemoveVariableValueAction : RemoveVariableValueActionClass, WriteVariableAction
   {
   }; // end of interface RemoveVariableValueAction

   interface SendSignalActionClass : ExplicitInvocationActtionClass
   {
      readonly attribute SendSignalActionSet all_of_type_send_signal_action;
      readonly attribute SendSignalActionSet all_of_class_send_signal_action;
      SendSignalAction create_send_signal_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface SendSignalAction : SendSignalActionClass, ExplicitInvocationActtion
   {
      CommonBehavior::Signal signal ()
         raises (Reflective::MofError);
      void set_signal (in CommonBehavior::Signal new_value)
         raises (Reflective::MofError);
      ActionFoundation::InputPin target ()
         raises (Reflective::MofError);
   }; // end of interface SendSignalAction

   interface BroadcastSignalActionClass : ExplicitInvocationActtionClass
   {
      readonly attribute BroadcastSignalActionSet all_of_type_broadcast_signal_action;
      readonly attribute BroadcastSignalActionSet all_of_class_broadcast_signal_action;
      BroadcastSignalAction create_broadcast_signal_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only)
         raises (Reflective::MofError);
   };

   interface BroadcastSignalAction : BroadcastSignalActionClass, ExplicitInvocationActtion
   {
      CommonBehavior::Signal signal ()
         raises (Reflective::MofError);
      void set_signal (in CommonBehavior::Signal new_value)
         raises (Reflective::MofError);
   }; // end of interface BroadcastSignalAction

   interface CallProcedureActionClass : ActionFoundation::PrimitiveActionClass
   {
      readonly attribute CallProcedureActionSet all_of_type_call_procedure_action;
      readonly attribute CallProcedureActionSet all_of_class_call_procedure_action;
      CallProcedureAction create_call_procedure_action (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_read_only,
         in boolean is_synchronous)
         raises (Reflective::MofError);
   };

   interface CallProcedureAction : CallProcedureActionClass, ActionFoundation::PrimitiveAction
   {
      OutputPinSet output ()
         raises (Reflective::MofError);
      InputPinSet input ()
         raises (Reflective::MofError);
      CommonBehavior::Procedure called_procedure ()
         raises (Reflective::MofError);
      void set_called_procedure (in CommonBehavior::Procedure new_value)
         raises (Reflective::MofError);
      boolean is_synchronous ()
         raises (Reflective::MofError);
      void set_is_synchronous (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface CallProcedureAction

   struct ATypeVariableLink
   {
      Core::Classifier type;
      Actions::Variable variable;
   };
   typedef sequence<ATypeVariableLink> ATypeVariableLinkSet;

   interface ATypeVariable : Reflective::RefAssociation
   {
      ATypeVariableLinkSet all_a_type_variable_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Classifier type,
         in Actions::Variable variable)
         raises (Reflective::MofError);
      Core::Classifier type (in Actions::Variable variable)
         raises (Reflective::MofError);
      void add (
         in Core::Classifier type,
         in Actions::Variable variable)
         raises (Reflective::MofError);
      void modify_type (
         in Core::Classifier type,
         in Actions::Variable variable,
         in Core::Classifier new_type)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Classifier type,
         in Actions::Variable variable)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ATypeVariable

   struct ASubinputFilterActionLink
   {
      ActionFoundation::OutputPin subinput;
      FilterAction filter_action;
   };
   typedef sequence<ASubinputFilterActionLink> ASubinputFilterActionLinkSet;

   interface ASubinputFilterAction : Reflective::RefAssociation
   {
      ASubinputFilterActionLinkSet all_a_subinput_filter_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin subinput,
         in FilterAction filter_action)
         raises (Reflective::MofError);
      OutputPinUList subinput (in FilterAction filter_action)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::OutputPin subinput,
         in FilterAction filter_action)
         raises (Reflective::MofError);
      void add_before_subinput (
         in ActionFoundation::OutputPin subinput,
         in FilterAction filter_action,
         in ActionFoundation::OutputPin before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_subinput (
         in ActionFoundation::OutputPin subinput,
         in FilterAction filter_action,
         in ActionFoundation::OutputPin new_subinput)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::OutputPin subinput,
         in FilterAction filter_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASubinputFilterAction

   struct ASubtestFilterActionLink
   {
      ActionFoundation::OutputPin subtest;
      FilterAction filter_action;
   };
   typedef sequence<ASubtestFilterActionLink> ASubtestFilterActionLinkSet;

   interface ASubtestFilterAction : Reflective::RefAssociation
   {
      ASubtestFilterActionLinkSet all_a_subtest_filter_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin subtest,
         in FilterAction filter_action)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin subtest (in FilterAction filter_action)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::OutputPin subtest,
         in FilterAction filter_action)
         raises (Reflective::MofError);
      void modify_subtest (
         in ActionFoundation::OutputPin subtest,
         in FilterAction filter_action,
         in ActionFoundation::OutputPin new_subtest)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::OutputPin subtest,
         in FilterAction filter_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASubtestFilterAction

   struct IterateActionResultLink
   {
      ActionFoundation::OutputPin result;
      IterateAction iterate_action;
   };
   typedef sequence<IterateActionResultLink> IterateActionResultLinkSet;

   interface IterateActionResult : Reflective::RefAssociation
   {
      IterateActionResultLinkSet all_iterate_action_result_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin result,
         in IterateAction iterate_action)
         raises (Reflective::MofError);
      OutputPinUList result (in IterateAction iterate_action)
         raises (Reflective::MofError);
   }; // end of interface IterateActionResult

   struct InterateActionLoopVariableInputLink
   {
      ActionFoundation::InputPin loop_variable_input;
      IterateAction iterate_action;
   };
   typedef sequence<InterateActionLoopVariableInputLink> InterateActionLoopVariableInputLinkSet;

   interface InterateActionLoopVariableInput : Reflective::RefAssociation
   {
      InterateActionLoopVariableInputLinkSet all_interate_action_loop_variable_input_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin loop_variable_input,
         in IterateAction iterate_action)
         raises (Reflective::MofError);
      InputPinUList loop_variable_input (in IterateAction iterate_action)
         raises (Reflective::MofError);
   }; // end of interface InterateActionLoopVariableInput

   struct ASubinputIterateActionLink
   {
      ActionFoundation::OutputPin subinput;
      IterateAction iterate_action;
   };
   typedef sequence<ASubinputIterateActionLink> ASubinputIterateActionLinkSet;

   interface ASubinputIterateAction : Reflective::RefAssociation
   {
      ASubinputIterateActionLinkSet all_a_subinput_iterate_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin subinput,
         in IterateAction iterate_action)
         raises (Reflective::MofError);
      OutputPinSet subinput (in IterateAction iterate_action)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::OutputPin subinput,
         in IterateAction iterate_action)
         raises (Reflective::MofError);
      void modify_subinput (
         in ActionFoundation::OutputPin subinput,
         in IterateAction iterate_action,
         in ActionFoundation::OutputPin new_subinput)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::OutputPin subinput,
         in IterateAction iterate_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASubinputIterateAction

   struct ALeftSubinputReduceActionLink
   {
      ActionFoundation::OutputPin left_subinput;
      ReduceAction reduce_action;
   };
   typedef sequence<ALeftSubinputReduceActionLink> ALeftSubinputReduceActionLinkSet;

   interface ALeftSubinputReduceAction : Reflective::RefAssociation
   {
      ALeftSubinputReduceActionLinkSet all_a_left_subinput_reduce_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin left_subinput,
         in ReduceAction reduce_action)
         raises (Reflective::MofError);
      OutputPinUList left_subinput (in ReduceAction reduce_action)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::OutputPin left_subinput,
         in ReduceAction reduce_action)
         raises (Reflective::MofError);
      void add_before_left_subinput (
         in ActionFoundation::OutputPin left_subinput,
         in ReduceAction reduce_action,
         in ActionFoundation::OutputPin before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_left_subinput (
         in ActionFoundation::OutputPin left_subinput,
         in ReduceAction reduce_action,
         in ActionFoundation::OutputPin new_left_subinput)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::OutputPin left_subinput,
         in ReduceAction reduce_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ALeftSubinputReduceAction

   struct ASuboutputReduceActionLink
   {
      ActionFoundation::OutputPin suboutput;
      ReduceAction reduce_action;
   };
   typedef sequence<ASuboutputReduceActionLink> ASuboutputReduceActionLinkSet;

   interface ASuboutputReduceAction : Reflective::RefAssociation
   {
      ASuboutputReduceActionLinkSet all_a_suboutput_reduce_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin suboutput,
         in ReduceAction reduce_action)
         raises (Reflective::MofError);
      OutputPinUList suboutput (in ReduceAction reduce_action)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::OutputPin suboutput,
         in ReduceAction reduce_action)
         raises (Reflective::MofError);
      void add_before_suboutput (
         in ActionFoundation::OutputPin suboutput,
         in ReduceAction reduce_action,
         in ActionFoundation::OutputPin before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_suboutput (
         in ActionFoundation::OutputPin suboutput,
         in ReduceAction reduce_action,
         in ActionFoundation::OutputPin new_suboutput)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::OutputPin suboutput,
         in ReduceAction reduce_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASuboutputReduceAction

   struct ARightSubinputReduceActionLink
   {
      ActionFoundation::OutputPin right_subinput;
      ReduceAction reduce_action;
   };
   typedef sequence<ARightSubinputReduceActionLink> ARightSubinputReduceActionLinkSet;

   interface ARightSubinputReduceAction : Reflective::RefAssociation
   {
      ARightSubinputReduceActionLinkSet all_a_right_subinput_reduce_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin right_subinput,
         in ReduceAction reduce_action)
         raises (Reflective::MofError);
      OutputPinUList right_subinput (in ReduceAction reduce_action)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::OutputPin right_subinput,
         in ReduceAction reduce_action)
         raises (Reflective::MofError);
      void add_before_right_subinput (
         in ActionFoundation::OutputPin right_subinput,
         in ReduceAction reduce_action,
         in ActionFoundation::OutputPin before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_right_subinput (
         in ActionFoundation::OutputPin right_subinput,
         in ReduceAction reduce_action,
         in ActionFoundation::OutputPin new_right_subinput)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::OutputPin right_subinput,
         in ReduceAction reduce_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ARightSubinputReduceAction

   struct ASubactionCollectionActionLink
   {
      ActionFoundation::Action subaction;
      CollectionAction collection_action;
   };
   typedef sequence<ASubactionCollectionActionLink> ASubactionCollectionActionLinkSet;

   interface ASubactionCollectionAction : Reflective::RefAssociation
   {
      ASubactionCollectionActionLinkSet all_a_subaction_collection_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::Action subaction,
         in CollectionAction collection_action)
         raises (Reflective::MofError);
      ActionFoundation::Action subaction (in CollectionAction collection_action)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::Action subaction,
         in CollectionAction collection_action)
         raises (Reflective::MofError);
      void modify_subaction (
         in ActionFoundation::Action subaction,
         in CollectionAction collection_action,
         in ActionFoundation::Action new_subaction)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::Action subaction,
         in CollectionAction collection_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASubactionCollectionAction

   struct MapActionOutputPinLink
   {
      ActionFoundation::OutputPin result;
      MapAction map_action;
   };
   typedef sequence<MapActionOutputPinLink> MapActionOutputPinLinkSet;

   interface MapActionOutputPin : Reflective::RefAssociation
   {
      MapActionOutputPinLinkSet all_map_action_output_pin_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin result,
         in MapAction map_action)
         raises (Reflective::MofError);
      OutputPinUList result (in MapAction map_action)
         raises (Reflective::MofError);
   }; // end of interface MapActionOutputPin

   struct MapActionArgumentLink
   {
      ActionFoundation::InputPin argument;
      MapAction map_action;
   };
   typedef sequence<MapActionArgumentLink> MapActionArgumentLinkSet;

   interface MapActionArgument : Reflective::RefAssociation
   {
      MapActionArgumentLinkSet all_map_action_argument_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin argument,
         in MapAction map_action)
         raises (Reflective::MofError);
      InputPinUList argument (in MapAction map_action)
         raises (Reflective::MofError);
   }; // end of interface MapActionArgument

   struct FilterActionArgumentLink
   {
      ActionFoundation::InputPin argument;
      FilterAction filter_action;
   };
   typedef sequence<FilterActionArgumentLink> FilterActionArgumentLinkSet;

   interface FilterActionArgument : Reflective::RefAssociation
   {
      FilterActionArgumentLinkSet all_filter_action_argument_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin argument,
         in FilterAction filter_action)
         raises (Reflective::MofError);
      InputPinUList argument (in FilterAction filter_action)
         raises (Reflective::MofError);
   }; // end of interface FilterActionArgument

   struct FilterActionResultLink
   {
      ActionFoundation::OutputPin result;
      FilterAction filter_action;
   };
   typedef sequence<FilterActionResultLink> FilterActionResultLinkSet;

   interface FilterActionResult : Reflective::RefAssociation
   {
      FilterActionResultLinkSet all_filter_action_result_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin result,
         in FilterAction filter_action)
         raises (Reflective::MofError);
      OutputPinUList result (in FilterAction filter_action)
         raises (Reflective::MofError);
   }; // end of interface FilterActionResult

   struct ReduceActionArgumentLink
   {
      ActionFoundation::InputPin argument;
      ReduceAction reduce_action;
   };
   typedef sequence<ReduceActionArgumentLink> ReduceActionArgumentLinkSet;

   interface ReduceActionArgument : Reflective::RefAssociation
   {
      ReduceActionArgumentLinkSet all_reduce_action_argument_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin argument,
         in ReduceAction reduce_action)
         raises (Reflective::MofError);
      InputPinUList argument (in ReduceAction reduce_action)
         raises (Reflective::MofError);
   }; // end of interface ReduceActionArgument

   struct ReduceActionOutputPinLink
   {
      ActionFoundation::OutputPin result;
      ReduceAction reduce_action;
   };
   typedef sequence<ReduceActionOutputPinLink> ReduceActionOutputPinLinkSet;

   interface ReduceActionOutputPin : Reflective::RefAssociation
   {
      ReduceActionOutputPinLinkSet all_reduce_action_output_pin_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin result,
         in ReduceAction reduce_action)
         raises (Reflective::MofError);
      OutputPinUList result (in ReduceAction reduce_action)
         raises (Reflective::MofError);
   }; // end of interface ReduceActionOutputPin

   struct ALoopVariableIterateActionLink
   {
      ActionFoundation::OutputPin loop_variable;
      IterateAction iterate_action;
   };
   typedef sequence<ALoopVariableIterateActionLink> ALoopVariableIterateActionLinkSet;

   interface ALoopVariableIterateAction : Reflective::RefAssociation
   {
      ALoopVariableIterateActionLinkSet all_a_loop_variable_iterate_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin loop_variable,
         in IterateAction iterate_action)
         raises (Reflective::MofError);
      OutputPinUList loop_variable (in IterateAction iterate_action)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::OutputPin loop_variable,
         in IterateAction iterate_action)
         raises (Reflective::MofError);
      void add_before_loop_variable (
         in ActionFoundation::OutputPin loop_variable,
         in IterateAction iterate_action,
         in ActionFoundation::OutputPin before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_loop_variable (
         in ActionFoundation::OutputPin loop_variable,
         in IterateAction iterate_action,
         in ActionFoundation::OutputPin new_loop_variable)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::OutputPin loop_variable,
         in IterateAction iterate_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ALoopVariableIterateAction

   struct IterateActionCollectionInputLink
   {
      ActionFoundation::InputPin collection_input;
      IterateAction iterate_action;
   };
   typedef sequence<IterateActionCollectionInputLink> IterateActionCollectionInputLinkSet;

   interface IterateActionCollectionInput : Reflective::RefAssociation
   {
      IterateActionCollectionInputLinkSet all_iterate_action_collection_input_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin collection_input,
         in IterateAction iterate_action)
         raises (Reflective::MofError);
      InputPinUList collection_input (in IterateAction iterate_action)
         raises (Reflective::MofError);
   }; // end of interface IterateActionCollectionInput

   struct ASuboutputIterateActionLink
   {
      ActionFoundation::OutputPin suboutput;
      IterateAction iterate_action;
   };
   typedef sequence<ASuboutputIterateActionLink> ASuboutputIterateActionLinkSet;

   interface ASuboutputIterateAction : Reflective::RefAssociation
   {
      ASuboutputIterateActionLinkSet all_a_suboutput_iterate_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin suboutput,
         in IterateAction iterate_action)
         raises (Reflective::MofError);
      OutputPinUList suboutput (in IterateAction iterate_action)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::OutputPin suboutput,
         in IterateAction iterate_action)
         raises (Reflective::MofError);
      void add_before_suboutput (
         in ActionFoundation::OutputPin suboutput,
         in IterateAction iterate_action,
         in ActionFoundation::OutputPin before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_suboutput (
         in ActionFoundation::OutputPin suboutput,
         in IterateAction iterate_action,
         in ActionFoundation::OutputPin new_suboutput)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::OutputPin suboutput,
         in IterateAction iterate_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASuboutputIterateAction

   struct ASubinputMapActionLink
   {
      ActionFoundation::OutputPin subinput;
      MapAction map_action;
   };
   typedef sequence<ASubinputMapActionLink> ASubinputMapActionLinkSet;

   interface ASubinputMapAction : Reflective::RefAssociation
   {
      ASubinputMapActionLinkSet all_a_subinput_map_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin subinput,
         in MapAction map_action)
         raises (Reflective::MofError);
      OutputPinUList subinput (in MapAction map_action)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::OutputPin subinput,
         in MapAction map_action)
         raises (Reflective::MofError);
      void add_before_subinput (
         in ActionFoundation::OutputPin subinput,
         in MapAction map_action,
         in ActionFoundation::OutputPin before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_subinput (
         in ActionFoundation::OutputPin subinput,
         in MapAction map_action,
         in ActionFoundation::OutputPin new_subinput)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::OutputPin subinput,
         in MapAction map_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASubinputMapAction

   struct ASuboutputMapActionLink
   {
      ActionFoundation::OutputPin suboutput;
      MapAction map_action;
   };
   typedef sequence<ASuboutputMapActionLink> ASuboutputMapActionLinkSet;

   interface ASuboutputMapAction : Reflective::RefAssociation
   {
      ASuboutputMapActionLinkSet all_a_suboutput_map_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin suboutput,
         in MapAction map_action)
         raises (Reflective::MofError);
      OutputPinUList suboutput (in MapAction map_action)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::OutputPin suboutput,
         in MapAction map_action)
         raises (Reflective::MofError);
      void add_before_suboutput (
         in ActionFoundation::OutputPin suboutput,
         in MapAction map_action,
         in ActionFoundation::OutputPin before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_suboutput (
         in ActionFoundation::OutputPin suboutput,
         in MapAction map_action,
         in ActionFoundation::OutputPin new_suboutput)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::OutputPin suboutput,
         in MapAction map_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASuboutputMapAction

   struct ASubactionGroupLink
   {
      ActionFoundation::Action subaction;
      GroupAction group;
   };
   typedef sequence<ASubactionGroupLink> ASubactionGroupLinkSet;

   interface ASubactionGroup : Reflective::RefAssociation
   {
      ASubactionGroupLinkSet all_a_subaction_group_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::Action subaction,
         in GroupAction group)
         raises (Reflective::MofError);
      ActionSet subaction (in GroupAction group)
         raises (Reflective::MofError);
      GroupAction group (in ActionFoundation::Action subaction)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::Action subaction,
         in GroupAction group)
         raises (Reflective::MofError);
      void modify_subaction (
         in ActionFoundation::Action subaction,
         in GroupAction group,
         in ActionFoundation::Action new_subaction)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_group (
         in ActionFoundation::Action subaction,
         in GroupAction group,
         in GroupAction new_group)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::Action subaction,
         in GroupAction group)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASubactionGroup

   struct ABodyClauseLink
   {
      ActionFoundation::Action body;
      Actions::Clause clause;
   };
   typedef sequence<ABodyClauseLink> ABodyClauseLinkSet;

   interface ABodyClause : Reflective::RefAssociation
   {
      ABodyClauseLinkSet all_a_body_clause_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::Action body,
         in Actions::Clause clause)
         raises (Reflective::MofError);
      ActionFoundation::Action body (in Actions::Clause clause)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::Action body,
         in Actions::Clause clause)
         raises (Reflective::MofError);
      void modify_body (
         in ActionFoundation::Action body,
         in Actions::Clause clause,
         in ActionFoundation::Action new_body)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::Action body,
         in Actions::Clause clause)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ABodyClause

   struct AClauseConditionalActionLink
   {
      Actions::Clause clause;
      ConditionalAction conditional_action;
   };
   typedef sequence<AClauseConditionalActionLink> AClauseConditionalActionLinkSet;

   interface AClauseConditionalAction : Reflective::RefAssociation
   {
      AClauseConditionalActionLinkSet all_a_clause_conditional_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in Actions::Clause clause,
         in ConditionalAction conditional_action)
         raises (Reflective::MofError);
      ClauseSet clause (in ConditionalAction conditional_action)
         raises (Reflective::MofError);
      void add (
         in Actions::Clause clause,
         in ConditionalAction conditional_action)
         raises (Reflective::MofError);
      void modify_clause (
         in Actions::Clause clause,
         in ConditionalAction conditional_action,
         in Actions::Clause new_clause)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Actions::Clause clause,
         in ConditionalAction conditional_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AClauseConditionalAction

   struct AClauseLoopActionLink
   {
      Actions::Clause clause;
      LoopAction loop_action;
   };
   typedef sequence<AClauseLoopActionLink> AClauseLoopActionLinkSet;

   interface AClauseLoopAction : Reflective::RefAssociation
   {
      AClauseLoopActionLinkSet all_a_clause_loop_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in Actions::Clause clause,
         in LoopAction loop_action)
         raises (Reflective::MofError);
      Actions::Clause clause (in LoopAction loop_action)
         raises (Reflective::MofError);
      void add (
         in Actions::Clause clause,
         in LoopAction loop_action)
         raises (Reflective::MofError);
      void modify_clause (
         in Actions::Clause clause,
         in LoopAction loop_action,
         in Actions::Clause new_clause)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Actions::Clause clause,
         in LoopAction loop_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AClauseLoopAction

   struct ATestClauseLink
   {
      ActionFoundation::Action test;
      Actions::Clause clause;
   };
   typedef sequence<ATestClauseLink> ATestClauseLinkSet;

   interface ATestClause : Reflective::RefAssociation
   {
      ATestClauseLinkSet all_a_test_clause_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::Action test,
         in Actions::Clause clause)
         raises (Reflective::MofError);
      ActionFoundation::Action test (in Actions::Clause clause)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::Action test,
         in Actions::Clause clause)
         raises (Reflective::MofError);
      void modify_test (
         in ActionFoundation::Action test,
         in Actions::Clause clause,
         in ActionFoundation::Action new_test)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::Action test,
         in Actions::Clause clause)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ATestClause

   struct ABodyOutputClauseLink
   {
      ActionFoundation::OutputPin body_output;
      Actions::Clause clause;
   };
   typedef sequence<ABodyOutputClauseLink> ABodyOutputClauseLinkSet;

   interface ABodyOutputClause : Reflective::RefAssociation
   {
      ABodyOutputClauseLinkSet all_a_body_output_clause_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin body_output,
         in Actions::Clause clause)
         raises (Reflective::MofError);
      OutputPinUList body_output (in Actions::Clause clause)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::OutputPin body_output,
         in Actions::Clause clause)
         raises (Reflective::MofError);
      void add_before_body_output (
         in ActionFoundation::OutputPin body_output,
         in Actions::Clause clause,
         in ActionFoundation::OutputPin before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_body_output (
         in ActionFoundation::OutputPin body_output,
         in Actions::Clause clause,
         in ActionFoundation::OutputPin new_body_output)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::OutputPin body_output,
         in Actions::Clause clause)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ABodyOutputClause

   struct ALoopVariableLoopLink
   {
      ActionFoundation::OutputPin loop_variable;
      LoopAction loop;
   };
   typedef sequence<ALoopVariableLoopLink> ALoopVariableLoopLinkSet;

   interface ALoopVariableLoop : Reflective::RefAssociation
   {
      ALoopVariableLoopLinkSet all_a_loop_variable_loop_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin loop_variable,
         in LoopAction loop)
         raises (Reflective::MofError);
      OutputPinUList loop_variable (in LoopAction loop)
         raises (Reflective::MofError);
      LoopActionSet loop (in ActionFoundation::OutputPin loop_variable)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::OutputPin loop_variable,
         in LoopAction loop)
         raises (Reflective::MofError);
      void add_before_loop_variable (
         in ActionFoundation::OutputPin loop_variable,
         in LoopAction loop,
         in ActionFoundation::OutputPin before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_loop_variable (
         in ActionFoundation::OutputPin loop_variable,
         in LoopAction loop,
         in ActionFoundation::OutputPin new_loop_variable)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_loop (
         in ActionFoundation::OutputPin loop_variable,
         in LoopAction loop,
         in LoopAction new_loop)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::OutputPin loop_variable,
         in LoopAction loop)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ALoopVariableLoop

   struct ATestOutputClauseLink
   {
      ActionFoundation::OutputPin test_output;
      Actions::Clause clause;
   };
   typedef sequence<ATestOutputClauseLink> ATestOutputClauseLinkSet;

   interface ATestOutputClause : Reflective::RefAssociation
   {
      ATestOutputClauseLinkSet all_a_test_output_clause_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin test_output,
         in Actions::Clause clause)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin test_output (in Actions::Clause clause)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::OutputPin test_output,
         in Actions::Clause clause)
         raises (Reflective::MofError);
      void modify_test_output (
         in ActionFoundation::OutputPin test_output,
         in Actions::Clause clause,
         in ActionFoundation::OutputPin new_test_output)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::OutputPin test_output,
         in Actions::Clause clause)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ATestOutputClause

   struct AScopeVariableLink
   {
      GroupAction scope;
      Actions::Variable variable;
   };
   typedef sequence<AScopeVariableLink> AScopeVariableLinkSet;

   interface AScopeVariable : Reflective::RefAssociation
   {
      AScopeVariableLinkSet all_a_scope_variable_links()
         raises (Reflective::MofError);
      boolean exists (
         in GroupAction scope,
         in Actions::Variable variable)
         raises (Reflective::MofError);
      GroupAction scope (in Actions::Variable variable)
         raises (Reflective::MofError);
      VariableSet variable (in GroupAction scope)
         raises (Reflective::MofError);
      void add (
         in GroupAction scope,
         in Actions::Variable variable)
         raises (Reflective::MofError);
      void modify_scope (
         in GroupAction scope,
         in Actions::Variable variable,
         in GroupAction new_scope)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_variable (
         in GroupAction scope,
         in Actions::Variable variable,
         in Actions::Variable new_variable)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in GroupAction scope,
         in Actions::Variable variable)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AScopeVariable

   struct APredecessorClauseSuccessorClauseLink
   {
      Clause predecessor_clause;
      Clause successor_clause;
   };
   typedef sequence<APredecessorClauseSuccessorClauseLink> APredecessorClauseSuccessorClauseLinkSet;

   interface APredecessorClauseSuccessorClause : Reflective::RefAssociation
   {
      APredecessorClauseSuccessorClauseLinkSet all_a_predecessor_clause_successor_clause_links()
         raises (Reflective::MofError);
      boolean exists (
         in Clause predecessor_clause,
         in Clause successor_clause)
         raises (Reflective::MofError);
      ClauseSet predecessor_clause (in Clause successor_clause)
         raises (Reflective::MofError);
      ClauseSet successor_clause (in Clause predecessor_clause)
         raises (Reflective::MofError);
      void add (
         in Clause predecessor_clause,
         in Clause successor_clause)
         raises (Reflective::MofError);
      void modify_predecessor_clause (
         in Clause predecessor_clause,
         in Clause successor_clause,
         in Clause new_predecessor_clause)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_successor_clause (
         in Clause predecessor_clause,
         in Clause successor_clause,
         in Clause new_successor_clause)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Clause predecessor_clause,
         in Clause successor_clause)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface APredecessorClauseSuccessorClause

   struct ApplyFunctionActionArgumentLink
   {
      ActionFoundation::InputPin argument;
      ApplyFunctionAction apply_function_action;
   };
   typedef sequence<ApplyFunctionActionArgumentLink> ApplyFunctionActionArgumentLinkSet;

   interface ApplyFunctionActionArgument : Reflective::RefAssociation
   {
      ApplyFunctionActionArgumentLinkSet all_apply_function_action_argument_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin argument,
         in ApplyFunctionAction apply_function_action)
         raises (Reflective::MofError);
      InputPinUList argument (in ApplyFunctionAction apply_function_action)
         raises (Reflective::MofError);
   }; // end of interface ApplyFunctionActionArgument

   struct AFunctionApplyFunctionActionLink
   {
      PrimitiveFunction function;
      ApplyFunctionAction apply_function_action;
   };
   typedef sequence<AFunctionApplyFunctionActionLink> AFunctionApplyFunctionActionLinkSet;

   interface AFunctionApplyFunctionAction : Reflective::RefAssociation
   {
      AFunctionApplyFunctionActionLinkSet all_a_function_apply_function_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in PrimitiveFunction function,
         in ApplyFunctionAction apply_function_action)
         raises (Reflective::MofError);
      PrimitiveFunction function (in ApplyFunctionAction apply_function_action)
         raises (Reflective::MofError);
      void add (
         in PrimitiveFunction function,
         in ApplyFunctionAction apply_function_action)
         raises (Reflective::MofError);
      void modify_function (
         in PrimitiveFunction function,
         in ApplyFunctionAction apply_function_action,
         in PrimitiveFunction new_function)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in PrimitiveFunction function,
         in ApplyFunctionAction apply_function_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AFunctionApplyFunctionAction

   struct AInputSpecPrimitiveFunctionLink
   {
      ArgumentSpecification input_spec;
      PrimitiveFunction primitive_function;
   };
   typedef sequence<AInputSpecPrimitiveFunctionLink> AInputSpecPrimitiveFunctionLinkSet;

   interface AInputSpecPrimitiveFunction : Reflective::RefAssociation
   {
      AInputSpecPrimitiveFunctionLinkSet all_a_input_spec_primitive_function_links()
         raises (Reflective::MofError);
      boolean exists (
         in ArgumentSpecification input_spec,
         in PrimitiveFunction primitive_function)
         raises (Reflective::MofError);
      ArgumentSpecificationSet input_spec (in PrimitiveFunction primitive_function)
         raises (Reflective::MofError);
      void add (
         in ArgumentSpecification input_spec,
         in PrimitiveFunction primitive_function)
         raises (Reflective::MofError);
      void modify_input_spec (
         in ArgumentSpecification input_spec,
         in PrimitiveFunction primitive_function,
         in ArgumentSpecification new_input_spec)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ArgumentSpecification input_spec,
         in PrimitiveFunction primitive_function)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AInputSpecPrimitiveFunction

   struct AOutputSpecPrimitiveFunctionLink
   {
      ArgumentSpecification output_spec;
      PrimitiveFunction primitive_function;
   };
   typedef sequence<AOutputSpecPrimitiveFunctionLink> AOutputSpecPrimitiveFunctionLinkSet;

   interface AOutputSpecPrimitiveFunction : Reflective::RefAssociation
   {
      AOutputSpecPrimitiveFunctionLinkSet all_a_output_spec_primitive_function_links()
         raises (Reflective::MofError);
      boolean exists (
         in ArgumentSpecification output_spec,
         in PrimitiveFunction primitive_function)
         raises (Reflective::MofError);
      ArgumentSpecificationSet output_spec (in PrimitiveFunction primitive_function)
         raises (Reflective::MofError);
      void add (
         in ArgumentSpecification output_spec,
         in PrimitiveFunction primitive_function)
         raises (Reflective::MofError);
      void modify_output_spec (
         in ArgumentSpecification output_spec,
         in PrimitiveFunction primitive_function,
         in ArgumentSpecification new_output_spec)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ArgumentSpecification output_spec,
         in PrimitiveFunction primitive_function)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AOutputSpecPrimitiveFunction

   struct AValueLiteralValueActionLink
   {
      CommonBehavior::DataValue value;
      LiteralValueAction literal_value_action;
   };
   typedef sequence<AValueLiteralValueActionLink> AValueLiteralValueActionLinkSet;

   interface AValueLiteralValueAction : Reflective::RefAssociation
   {
      AValueLiteralValueActionLinkSet all_a_value_literal_value_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in CommonBehavior::DataValue value,
         in LiteralValueAction literal_value_action)
         raises (Reflective::MofError);
      CommonBehavior::DataValue value (in LiteralValueAction literal_value_action)
         raises (Reflective::MofError);
      void add (
         in CommonBehavior::DataValue value,
         in LiteralValueAction literal_value_action)
         raises (Reflective::MofError);
      void modify_value (
         in CommonBehavior::DataValue value,
         in LiteralValueAction literal_value_action,
         in CommonBehavior::DataValue new_value)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CommonBehavior::DataValue value,
         in LiteralValueAction literal_value_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AValueLiteralValueAction

   struct ApplyFunctionActionResultLink
   {
      ActionFoundation::OutputPin result;
      ApplyFunctionAction apply_function_action;
   };
   typedef sequence<ApplyFunctionActionResultLink> ApplyFunctionActionResultLinkSet;

   interface ApplyFunctionActionResult : Reflective::RefAssociation
   {
      ApplyFunctionActionResultLinkSet all_apply_function_action_result_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin result,
         in ApplyFunctionAction apply_function_action)
         raises (Reflective::MofError);
      OutputPinUList result (in ApplyFunctionAction apply_function_action)
         raises (Reflective::MofError);
   }; // end of interface ApplyFunctionActionResult

   struct CodeActionArgumentLink
   {
      ActionFoundation::InputPin argument;
      CodeAction code_action;
   };
   typedef sequence<CodeActionArgumentLink> CodeActionArgumentLinkSet;

   interface CodeActionArgument : Reflective::RefAssociation
   {
      CodeActionArgumentLinkSet all_code_action_argument_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin argument,
         in CodeAction code_action)
         raises (Reflective::MofError);
      InputPinUList argument (in CodeAction code_action)
         raises (Reflective::MofError);
   }; // end of interface CodeActionArgument

   struct CodeActionResultLink
   {
      ActionFoundation::OutputPin result;
      CodeAction code_action;
   };
   typedef sequence<CodeActionResultLink> CodeActionResultLinkSet;

   interface CodeActionResult : Reflective::RefAssociation
   {
      CodeActionResultLinkSet all_code_action_result_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin result,
         in CodeAction code_action)
         raises (Reflective::MofError);
      OutputPinUList result (in CodeAction code_action)
         raises (Reflective::MofError);
   }; // end of interface CodeActionResult

   struct LiteralValueActionResultLink
   {
      ActionFoundation::OutputPin result;
      LiteralValueAction literal_value_action;
   };
   typedef sequence<LiteralValueActionResultLink> LiteralValueActionResultLinkSet;

   interface LiteralValueActionResult : Reflective::RefAssociation
   {
      LiteralValueActionResultLinkSet all_literal_value_action_result_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin result,
         in LiteralValueAction literal_value_action)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin result (in LiteralValueAction literal_value_action)
         raises (Reflective::MofError);
   }; // end of interface LiteralValueActionResult

   struct TestIdentityActionFirstLink
   {
      TestIdentityAction test_identity_action;
      ActionFoundation::InputPin first;
   };
   typedef sequence<TestIdentityActionFirstLink> TestIdentityActionFirstLinkSet;

   interface TestIdentityActionFirst : Reflective::RefAssociation
   {
      TestIdentityActionFirstLinkSet all_test_identity_action_first_links()
         raises (Reflective::MofError);
      boolean exists (
         in TestIdentityAction test_identity_action,
         in ActionFoundation::InputPin first)
         raises (Reflective::MofError);
      InputPinSet first (in TestIdentityAction test_identity_action)
         raises (Reflective::MofError);
   }; // end of interface TestIdentityActionFirst

   struct TestIdentityActionSecondLink
   {
      TestIdentityAction test_identity_action;
      ActionFoundation::InputPin second;
   };
   typedef sequence<TestIdentityActionSecondLink> TestIdentityActionSecondLinkSet;

   interface TestIdentityActionSecond : Reflective::RefAssociation
   {
      TestIdentityActionSecondLinkSet all_test_identity_action_second_links()
         raises (Reflective::MofError);
      boolean exists (
         in TestIdentityAction test_identity_action,
         in ActionFoundation::InputPin second)
         raises (Reflective::MofError);
      InputPinSet second (in TestIdentityAction test_identity_action)
         raises (Reflective::MofError);
   }; // end of interface TestIdentityActionSecond

   struct MarshalActionArgumentLink
   {
      MarshalAction marshal_action;
      ActionFoundation::InputPin argument;
   };
   typedef sequence<MarshalActionArgumentLink> MarshalActionArgumentLinkSet;

   interface MarshalActionArgument : Reflective::RefAssociation
   {
      MarshalActionArgumentLinkSet all_marshal_action_argument_links()
         raises (Reflective::MofError);
      boolean exists (
         in MarshalAction marshal_action,
         in ActionFoundation::InputPin argument)
         raises (Reflective::MofError);
      InputPinUList argument (in MarshalAction marshal_action)
         raises (Reflective::MofError);
   }; // end of interface MarshalActionArgument

   struct MarshalActionResultLink
   {
      MarshalAction marshal_action;
      ActionFoundation::OutputPin result;
   };
   typedef sequence<MarshalActionResultLink> MarshalActionResultLinkSet;

   interface MarshalActionResult : Reflective::RefAssociation
   {
      MarshalActionResultLinkSet all_marshal_action_result_links()
         raises (Reflective::MofError);
      boolean exists (
         in MarshalAction marshal_action,
         in ActionFoundation::OutputPin result)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin result (in MarshalAction marshal_action)
         raises (Reflective::MofError);
   }; // end of interface MarshalActionResult

   struct UnmarshalActionArgumentLink
   {
      UnmarshalAction unmarshal_action;
      ActionFoundation::InputPin argument;
   };
   typedef sequence<UnmarshalActionArgumentLink> UnmarshalActionArgumentLinkSet;

   interface UnmarshalActionArgument : Reflective::RefAssociation
   {
      UnmarshalActionArgumentLinkSet all_unmarshal_action_argument_links()
         raises (Reflective::MofError);
      boolean exists (
         in UnmarshalAction unmarshal_action,
         in ActionFoundation::InputPin argument)
         raises (Reflective::MofError);
      ActionFoundation::InputPin argument (in UnmarshalAction unmarshal_action)
         raises (Reflective::MofError);
   }; // end of interface UnmarshalActionArgument

   struct UnmarshalActionResultLink
   {
      UnmarshalAction unmarshal_action;
      ActionFoundation::OutputPin result;
   };
   typedef sequence<UnmarshalActionResultLink> UnmarshalActionResultLinkSet;

   interface UnmarshalActionResult : Reflective::RefAssociation
   {
      UnmarshalActionResultLinkSet all_unmarshal_action_result_links()
         raises (Reflective::MofError);
      boolean exists (
         in UnmarshalAction unmarshal_action,
         in ActionFoundation::OutputPin result)
         raises (Reflective::MofError);
      OutputPinUList result (in UnmarshalAction unmarshal_action)
         raises (Reflective::MofError);
   }; // end of interface UnmarshalActionResult

   struct ATypeArgumentSpecificationLink
   {
      Core::DataType type;
      ArgumentSpecification argument_specification;
   };
   typedef sequence<ATypeArgumentSpecificationLink> ATypeArgumentSpecificationLinkSet;

   interface ATypeArgumentSpecification : Reflective::RefAssociation
   {
      ATypeArgumentSpecificationLinkSet all_a_type_argument_specification_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::DataType type,
         in ArgumentSpecification argument_specification)
         raises (Reflective::MofError);
      Core::DataType type (in ArgumentSpecification argument_specification)
         raises (Reflective::MofError);
      void add (
         in Core::DataType type,
         in ArgumentSpecification argument_specification)
         raises (Reflective::MofError);
      void modify_type (
         in Core::DataType type,
         in ArgumentSpecification argument_specification,
         in Core::DataType new_type)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::DataType type,
         in ArgumentSpecification argument_specification)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ATypeArgumentSpecification

   struct AExceptionJumpActionLink
   {
      CommonBehavior::UmlException uml_exception;
      JumpAction jump_action;
   };
   typedef sequence<AExceptionJumpActionLink> AExceptionJumpActionLinkSet;

   interface AExceptionJumpAction : Reflective::RefAssociation
   {
      AExceptionJumpActionLinkSet all_a_exception_jump_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in CommonBehavior::UmlException uml_exception,
         in JumpAction jump_action)
         raises (Reflective::MofError);
      CommonBehavior::UmlException uml_exception (in JumpAction jump_action)
         raises (Reflective::MofError);
      void add (
         in CommonBehavior::UmlException uml_exception,
         in JumpAction jump_action)
         raises (Reflective::MofError);
      void modify_uml_exception (
         in CommonBehavior::UmlException uml_exception,
         in JumpAction jump_action,
         in CommonBehavior::UmlException new_uml_exception)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CommonBehavior::UmlException uml_exception,
         in JumpAction jump_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AExceptionJumpAction

   struct AJumpHandlerProtectedActionLink
   {
      JumpHandler jump_handler;
      ActionFoundation::Action protected_action;
   };
   typedef sequence<AJumpHandlerProtectedActionLink> AJumpHandlerProtectedActionLinkSet;

   interface AJumpHandlerProtectedAction : Reflective::RefAssociation
   {
      AJumpHandlerProtectedActionLinkSet all_a_jump_handler_protected_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in JumpHandler jump_handler,
         in ActionFoundation::Action protected_action)
         raises (Reflective::MofError);
      JumpHandlerSet jump_handler (in ActionFoundation::Action protected_action)
         raises (Reflective::MofError);
      ActionSet protected_action (in JumpHandler jump_handler)
         raises (Reflective::MofError);
      void add (
         in JumpHandler jump_handler,
         in ActionFoundation::Action protected_action)
         raises (Reflective::MofError);
      void modify_jump_handler (
         in JumpHandler jump_handler,
         in ActionFoundation::Action protected_action,
         in JumpHandler new_jump_handler)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_protected_action (
         in JumpHandler jump_handler,
         in ActionFoundation::Action protected_action,
         in ActionFoundation::Action new_protected_action)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in JumpHandler jump_handler,
         in ActionFoundation::Action protected_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AJumpHandlerProtectedAction

   struct JumpActionJumpOccurrenceLink
   {
      ActionFoundation::InputPin jump_occurence;
      JumpAction jump_action;
   };
   typedef sequence<JumpActionJumpOccurrenceLink> JumpActionJumpOccurrenceLinkSet;

   interface JumpActionJumpOccurrence : Reflective::RefAssociation
   {
      JumpActionJumpOccurrenceLinkSet all_jump_action_jump_occurrence_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin jump_occurence,
         in JumpAction jump_action)
         raises (Reflective::MofError);
      ActionFoundation::InputPin jump_occurence (in JumpAction jump_action)
         raises (Reflective::MofError);
   }; // end of interface JumpActionJumpOccurrence

   struct AHandlerOutputHandlerActionLink
   {
      ActionFoundation::OutputPin handler_output;
      HandlerAction handler_action;
   };
   typedef sequence<AHandlerOutputHandlerActionLink> AHandlerOutputHandlerActionLinkSet;

   interface AHandlerOutputHandlerAction : Reflective::RefAssociation
   {
      AHandlerOutputHandlerActionLinkSet all_a_handler_output_handler_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin handler_output,
         in HandlerAction handler_action)
         raises (Reflective::MofError);
      OutputPinUList handler_output (in HandlerAction handler_action)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::OutputPin handler_output,
         in HandlerAction handler_action)
         raises (Reflective::MofError);
      void add_before_handler_output (
         in ActionFoundation::OutputPin handler_output,
         in HandlerAction handler_action,
         in ActionFoundation::OutputPin before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_handler_output (
         in ActionFoundation::OutputPin handler_output,
         in HandlerAction handler_action,
         in ActionFoundation::OutputPin new_handler_output)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::OutputPin handler_output,
         in HandlerAction handler_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AHandlerOutputHandlerAction

   struct ABodyHandlerActionLink
   {
      ActionFoundation::Action body;
      HandlerAction handler_action;
   };
   typedef sequence<ABodyHandlerActionLink> ABodyHandlerActionLinkSet;

   interface ABodyHandlerAction : Reflective::RefAssociation
   {
      ABodyHandlerActionLinkSet all_a_body_handler_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::Action body,
         in HandlerAction handler_action)
         raises (Reflective::MofError);
      ActionFoundation::Action body (in HandlerAction handler_action)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::Action body,
         in HandlerAction handler_action)
         raises (Reflective::MofError);
      void modify_body (
         in ActionFoundation::Action body,
         in HandlerAction handler_action,
         in ActionFoundation::Action new_body)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::Action body,
         in HandlerAction handler_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ABodyHandlerAction

   struct HandlerActionOccurrenceLink
   {
      ActionFoundation::OutputPin occurrence;
      HandlerAction handler_action;
   };
   typedef sequence<HandlerActionOccurrenceLink> HandlerActionOccurrenceLinkSet;

   interface HandlerActionOccurrence : Reflective::RefAssociation
   {
      HandlerActionOccurrenceLinkSet all_handler_action_occurrence_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin occurrence,
         in HandlerAction handler_action)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin occurrence (in HandlerAction handler_action)
         raises (Reflective::MofError);
   }; // end of interface HandlerActionOccurrence

   struct AJumpTypeJumpHandlerLink
   {
      Core::Classifier jump_type;
      JumpHandler jump_handler;
   };
   typedef sequence<AJumpTypeJumpHandlerLink> AJumpTypeJumpHandlerLinkSet;

   interface AJumpTypeJumpHandler : Reflective::RefAssociation
   {
      AJumpTypeJumpHandlerLinkSet all_a_jump_type_jump_handler_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Classifier jump_type,
         in JumpHandler jump_handler)
         raises (Reflective::MofError);
      Core::Classifier jump_type (in JumpHandler jump_handler)
         raises (Reflective::MofError);
      void add (
         in Core::Classifier jump_type,
         in JumpHandler jump_handler)
         raises (Reflective::MofError);
      void modify_jump_type (
         in Core::Classifier jump_type,
         in JumpHandler jump_handler,
         in Core::Classifier new_jump_type)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Classifier jump_type,
         in JumpHandler jump_handler)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AJumpTypeJumpHandler

   struct ABodyJumpHandlerLink
   {
      HandlerAction body;
      JumpHandler jump_handler;
   };
   typedef sequence<ABodyJumpHandlerLink> ABodyJumpHandlerLinkSet;

   interface ABodyJumpHandler : Reflective::RefAssociation
   {
      ABodyJumpHandlerLinkSet all_a_body_jump_handler_links()
         raises (Reflective::MofError);
      boolean exists (
         in HandlerAction body,
         in JumpHandler jump_handler)
         raises (Reflective::MofError);
      HandlerAction body (in JumpHandler jump_handler)
         raises (Reflective::MofError);
      void add (
         in HandlerAction body,
         in JumpHandler jump_handler)
         raises (Reflective::MofError);
      void modify_body (
         in HandlerAction body,
         in JumpHandler jump_handler,
         in HandlerAction new_body)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in HandlerAction body,
         in JumpHandler jump_handler)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ABodyJumpHandler

   struct InvocationActionTargetLink
   {
      ActionFoundation::InputPin target;
      InvocationAction invocation_action;
   };
   typedef sequence<InvocationActionTargetLink> InvocationActionTargetLinkSet;

   interface InvocationActionTarget : Reflective::RefAssociation
   {
      InvocationActionTargetLinkSet all_invocation_action_target_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin target,
         in InvocationAction invocation_action)
         raises (Reflective::MofError);
      ActionFoundation::InputPin target (in InvocationAction invocation_action)
         raises (Reflective::MofError);
   }; // end of interface InvocationActionTarget

   struct InvocationActionRequestLink
   {
      ActionFoundation::InputPin request;
      InvocationAction invocation_action;
   };
   typedef sequence<InvocationActionRequestLink> InvocationActionRequestLinkSet;

   interface InvocationActionRequest : Reflective::RefAssociation
   {
      InvocationActionRequestLinkSet all_invocation_action_request_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin request,
         in InvocationAction invocation_action)
         raises (Reflective::MofError);
      ActionFoundation::InputPin request (in InvocationAction invocation_action)
         raises (Reflective::MofError);
   }; // end of interface InvocationActionRequest

   struct SynchronousInvocationActionOutputPinLink
   {
      ActionFoundation::OutputPin reply;
      SynchronousInvocationAction synchronous_invocation_action;
   };
   typedef sequence<SynchronousInvocationActionOutputPinLink> SynchronousInvocationActionOutputPinLinkSet;

   interface SynchronousInvocationActionOutputPin : Reflective::RefAssociation
   {
      SynchronousInvocationActionOutputPinLinkSet all_synchronous_invocation_action_output_pin_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin reply,
         in SynchronousInvocationAction synchronous_invocation_action)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin reply (in SynchronousInvocationAction synchronous_invocation_action)
         raises (Reflective::MofError);
   }; // end of interface SynchronousInvocationActionOutputPin

   struct ExplicitInvocationActionArgumentLink
   {
      ActionFoundation::InputPin argument;
      ExplicitInvocationActtion explicit_invocation_acttion;
   };
   typedef sequence<ExplicitInvocationActionArgumentLink> ExplicitInvocationActionArgumentLinkSet;

   interface ExplicitInvocationActionArgument : Reflective::RefAssociation
   {
      ExplicitInvocationActionArgumentLinkSet all_explicit_invocation_action_argument_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin argument,
         in ExplicitInvocationActtion explicit_invocation_acttion)
         raises (Reflective::MofError);
      InputPinSet argument (in ExplicitInvocationActtion explicit_invocation_acttion)
         raises (Reflective::MofError);
   }; // end of interface ExplicitInvocationActionArgument

   struct CallOperationActionResultLink
   {
      ActionFoundation::OutputPin result;
      CallOperationAction call_operation_action;
   };
   typedef sequence<CallOperationActionResultLink> CallOperationActionResultLinkSet;

   interface CallOperationActionResult : Reflective::RefAssociation
   {
      CallOperationActionResultLinkSet all_call_operation_action_result_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin result,
         in CallOperationAction call_operation_action)
         raises (Reflective::MofError);
      OutputPinSet result (in CallOperationAction call_operation_action)
         raises (Reflective::MofError);
   }; // end of interface CallOperationActionResult

   struct CallOperationActionTargetLink
   {
      ActionFoundation::InputPin target;
      CallOperationAction call_operation_action;
   };
   typedef sequence<CallOperationActionTargetLink> CallOperationActionTargetLinkSet;

   interface CallOperationActionTarget : Reflective::RefAssociation
   {
      CallOperationActionTargetLinkSet all_call_operation_action_target_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin target,
         in CallOperationAction call_operation_action)
         raises (Reflective::MofError);
      ActionFoundation::InputPin target (in CallOperationAction call_operation_action)
         raises (Reflective::MofError);
   }; // end of interface CallOperationActionTarget

   struct AOperationCallOperationActionLink
   {
      Core::Operation operation;
      CallOperationAction call_operation_action;
   };
   typedef sequence<AOperationCallOperationActionLink> AOperationCallOperationActionLinkSet;

   interface AOperationCallOperationAction : Reflective::RefAssociation
   {
      AOperationCallOperationActionLinkSet all_a_operation_call_operation_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Operation operation,
         in CallOperationAction call_operation_action)
         raises (Reflective::MofError);
      Core::Operation operation (in CallOperationAction call_operation_action)
         raises (Reflective::MofError);
      void add (
         in Core::Operation operation,
         in CallOperationAction call_operation_action)
         raises (Reflective::MofError);
      void modify_operation (
         in Core::Operation operation,
         in CallOperationAction call_operation_action,
         in Core::Operation new_operation)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Operation operation,
         in CallOperationAction call_operation_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AOperationCallOperationAction

   struct ReadLinkActionResultLink
   {
      ActionFoundation::OutputPin result;
      ReadLinkAction read_link_action;
   };
   typedef sequence<ReadLinkActionResultLink> ReadLinkActionResultLinkSet;

   interface ReadLinkActionResult : Reflective::RefAssociation
   {
      ReadLinkActionResultLinkSet all_read_link_action_result_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin result,
         in ReadLinkAction read_link_action)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin result (in ReadLinkAction read_link_action)
         raises (Reflective::MofError);
   }; // end of interface ReadLinkActionResult

   struct AResultReadLinkObjectEndActionLink
   {
      ActionFoundation::OutputPin result;
      ReadLinkObjectEndAction read_link_object_end_action;
   };
   typedef sequence<AResultReadLinkObjectEndActionLink> AResultReadLinkObjectEndActionLinkSet;

   interface AResultReadLinkObjectEndAction : Reflective::RefAssociation
   {
      AResultReadLinkObjectEndActionLinkSet all_a_result_read_link_object_end_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin result,
         in ReadLinkObjectEndAction read_link_object_end_action)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin result (in ReadLinkObjectEndAction read_link_object_end_action)
         raises (Reflective::MofError);
   }; // end of interface AResultReadLinkObjectEndAction

   struct AResultReadLinkObjectQualifierActionLink
   {
      ActionFoundation::OutputPin result;
      ReadLinkObjectQualifierAction read_link_object_qualifier_action;
   };
   typedef sequence<AResultReadLinkObjectQualifierActionLink> AResultReadLinkObjectQualifierActionLinkSet;

   interface AResultReadLinkObjectQualifierAction : Reflective::RefAssociation
   {
      AResultReadLinkObjectQualifierActionLinkSet all_a_result_read_link_object_qualifier_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin result,
         in ReadLinkObjectQualifierAction read_link_object_qualifier_action)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin result (in ReadLinkObjectQualifierAction read_link_object_qualifier_action)
         raises (Reflective::MofError);
   }; // end of interface AResultReadLinkObjectQualifierAction

   struct AInsertAtLinkEndCreationDataLink
   {
      ActionFoundation::InputPin insert_at;
      LinkEndCreationData link_end_creation_data;
   };
   typedef sequence<AInsertAtLinkEndCreationDataLink> AInsertAtLinkEndCreationDataLinkSet;

   interface AInsertAtLinkEndCreationData : Reflective::RefAssociation
   {
      AInsertAtLinkEndCreationDataLinkSet all_a_insert_at_link_end_creation_data_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin insert_at,
         in LinkEndCreationData link_end_creation_data)
         raises (Reflective::MofError);
      ActionFoundation::InputPin insert_at (in LinkEndCreationData link_end_creation_data)
         raises (Reflective::MofError);
   }; // end of interface AInsertAtLinkEndCreationData

   struct AEndLinkEndDataLink
   {
      Core::AssociationEnd end;
      LinkEndData link_end_data;
   };
   typedef sequence<AEndLinkEndDataLink> AEndLinkEndDataLinkSet;

   interface AEndLinkEndData : Reflective::RefAssociation
   {
      AEndLinkEndDataLinkSet all_a_end_link_end_data_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::AssociationEnd end,
         in LinkEndData link_end_data)
         raises (Reflective::MofError);
      Core::AssociationEnd end (in LinkEndData link_end_data)
         raises (Reflective::MofError);
      void add (
         in Core::AssociationEnd end,
         in LinkEndData link_end_data)
         raises (Reflective::MofError);
      void modify_end (
         in Core::AssociationEnd end,
         in LinkEndData link_end_data,
         in Core::AssociationEnd new_end)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::AssociationEnd end,
         in LinkEndData link_end_data)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AEndLinkEndData

   struct LinkEndDataValueLink
   {
      ActionFoundation::InputPin value;
      LinkEndData link_end_data;
   };
   typedef sequence<LinkEndDataValueLink> LinkEndDataValueLinkSet;

   interface LinkEndDataValue : Reflective::RefAssociation
   {
      LinkEndDataValueLinkSet all_link_end_data_value_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin value,
         in LinkEndData link_end_data)
         raises (Reflective::MofError);
      ActionFoundation::InputPin value (in LinkEndData link_end_data)
         raises (Reflective::MofError);
   }; // end of interface LinkEndDataValue

   struct AQualifierLinkEndDataLink
   {
      QualifierValue qualifier;
      LinkEndData link_end_data;
   };
   typedef sequence<AQualifierLinkEndDataLink> AQualifierLinkEndDataLinkSet;

   interface AQualifierLinkEndData : Reflective::RefAssociation
   {
      AQualifierLinkEndDataLinkSet all_a_qualifier_link_end_data_links()
         raises (Reflective::MofError);
      boolean exists (
         in QualifierValue qualifier,
         in LinkEndData link_end_data)
         raises (Reflective::MofError);
      QualifierValueSet qualifier (in LinkEndData link_end_data)
         raises (Reflective::MofError);
      void add (
         in QualifierValue qualifier,
         in LinkEndData link_end_data)
         raises (Reflective::MofError);
      void modify_qualifier (
         in QualifierValue qualifier,
         in LinkEndData link_end_data,
         in QualifierValue new_qualifier)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in QualifierValue qualifier,
         in LinkEndData link_end_data)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AQualifierLinkEndData

   struct AQualifierQualifierValueLink
   {
      Core::UmlAttribute qualifier;
      QualifierValue qualifier_value;
   };
   typedef sequence<AQualifierQualifierValueLink> AQualifierQualifierValueLinkSet;

   interface AQualifierQualifierValue : Reflective::RefAssociation
   {
      AQualifierQualifierValueLinkSet all_a_qualifier_qualifier_value_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::UmlAttribute qualifier,
         in QualifierValue qualifier_value)
         raises (Reflective::MofError);
      Core::UmlAttribute qualifier (in QualifierValue qualifier_value)
         raises (Reflective::MofError);
      void add (
         in Core::UmlAttribute qualifier,
         in QualifierValue qualifier_value)
         raises (Reflective::MofError);
      void modify_qualifier (
         in Core::UmlAttribute qualifier,
         in QualifierValue qualifier_value,
         in Core::UmlAttribute new_qualifier)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::UmlAttribute qualifier,
         in QualifierValue qualifier_value)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AQualifierQualifierValue

   struct AQualifierValueLink
   {
      ActionFoundation::InputPin value;
      QualifierValue qualifier_value;
   };
   typedef sequence<AQualifierValueLink> AQualifierValueLinkSet;

   interface AQualifierValue : Reflective::RefAssociation
   {
      AQualifierValueLinkSet all_a_qualifier_value_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin value,
         in QualifierValue qualifier_value)
         raises (Reflective::MofError);
      ActionFoundation::InputPin value (in QualifierValue qualifier_value)
         raises (Reflective::MofError);
   }; // end of interface AQualifierValue

   struct AObjectReadLinkObjectEndActionLink
   {
      ActionFoundation::InputPin action_object;
      ReadLinkObjectEndAction read_link_object_end_action;
   };
   typedef sequence<AObjectReadLinkObjectEndActionLink> AObjectReadLinkObjectEndActionLinkSet;

   interface AObjectReadLinkObjectEndAction : Reflective::RefAssociation
   {
      AObjectReadLinkObjectEndActionLinkSet all_a_object_read_link_object_end_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin action_object,
         in ReadLinkObjectEndAction read_link_object_end_action)
         raises (Reflective::MofError);
      ActionFoundation::InputPin action_object (in ReadLinkObjectEndAction read_link_object_end_action)
         raises (Reflective::MofError);
   }; // end of interface AObjectReadLinkObjectEndAction

   struct AEndReadLinkObjectEndActionLink
   {
      Core::AssociationEnd end;
      ReadLinkObjectEndAction read_link_object_end_action;
   };
   typedef sequence<AEndReadLinkObjectEndActionLink> AEndReadLinkObjectEndActionLinkSet;

   interface AEndReadLinkObjectEndAction : Reflective::RefAssociation
   {
      AEndReadLinkObjectEndActionLinkSet all_a_end_read_link_object_end_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::AssociationEnd end,
         in ReadLinkObjectEndAction read_link_object_end_action)
         raises (Reflective::MofError);
      Core::AssociationEnd end (in ReadLinkObjectEndAction read_link_object_end_action)
         raises (Reflective::MofError);
      void add (
         in Core::AssociationEnd end,
         in ReadLinkObjectEndAction read_link_object_end_action)
         raises (Reflective::MofError);
      void modify_end (
         in Core::AssociationEnd end,
         in ReadLinkObjectEndAction read_link_object_end_action,
         in Core::AssociationEnd new_end)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::AssociationEnd end,
         in ReadLinkObjectEndAction read_link_object_end_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AEndReadLinkObjectEndAction

   struct AObjectReadLinkObjectQualifierActionLink
   {
      ActionFoundation::InputPin action_object;
      ReadLinkObjectQualifierAction read_link_object_qualifier_action;
   };
   typedef sequence<AObjectReadLinkObjectQualifierActionLink> AObjectReadLinkObjectQualifierActionLinkSet;

   interface AObjectReadLinkObjectQualifierAction : Reflective::RefAssociation
   {
      AObjectReadLinkObjectQualifierActionLinkSet all_a_object_read_link_object_qualifier_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin action_object,
         in ReadLinkObjectQualifierAction read_link_object_qualifier_action)
         raises (Reflective::MofError);
      ActionFoundation::InputPin action_object (in ReadLinkObjectQualifierAction read_link_object_qualifier_action)
         raises (Reflective::MofError);
   }; // end of interface AObjectReadLinkObjectQualifierAction

   struct AQualifierReadLinkObjectQualifierActionLink
   {
      Core::UmlAttribute qualifier;
      ReadLinkObjectQualifierAction read_link_object_qualifier_action;
   };
   typedef sequence<AQualifierReadLinkObjectQualifierActionLink> AQualifierReadLinkObjectQualifierActionLinkSet;

   interface AQualifierReadLinkObjectQualifierAction : Reflective::RefAssociation
   {
      AQualifierReadLinkObjectQualifierActionLinkSet all_a_qualifier_read_link_object_qualifier_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::UmlAttribute qualifier,
         in ReadLinkObjectQualifierAction read_link_object_qualifier_action)
         raises (Reflective::MofError);
      Core::UmlAttribute qualifier (in ReadLinkObjectQualifierAction read_link_object_qualifier_action)
         raises (Reflective::MofError);
      void add (
         in Core::UmlAttribute qualifier,
         in ReadLinkObjectQualifierAction read_link_object_qualifier_action)
         raises (Reflective::MofError);
      void modify_qualifier (
         in Core::UmlAttribute qualifier,
         in ReadLinkObjectQualifierAction read_link_object_qualifier_action,
         in Core::UmlAttribute new_qualifier)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::UmlAttribute qualifier,
         in ReadLinkObjectQualifierAction read_link_object_qualifier_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AQualifierReadLinkObjectQualifierAction

   struct AResultCreateLinkObjectActionLink
   {
      ActionFoundation::OutputPin result;
      CreateLinkObjectAction create_link_object_action;
   };
   typedef sequence<AResultCreateLinkObjectActionLink> AResultCreateLinkObjectActionLinkSet;

   interface AResultCreateLinkObjectAction : Reflective::RefAssociation
   {
      AResultCreateLinkObjectActionLinkSet all_a_result_create_link_object_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin result,
         in CreateLinkObjectAction create_link_object_action)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin result (in CreateLinkObjectAction create_link_object_action)
         raises (Reflective::MofError);
   }; // end of interface AResultCreateLinkObjectAction

   struct AEndDataLinkActionLink
   {
      LinkEndData end_data;
      LinkAction link_action;
   };
   typedef sequence<AEndDataLinkActionLink> AEndDataLinkActionLinkSet;

   interface AEndDataLinkAction : Reflective::RefAssociation
   {
      AEndDataLinkActionLinkSet all_a_end_data_link_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in LinkEndData end_data,
         in LinkAction link_action)
         raises (Reflective::MofError);
      LinkEndDataSet end_data (in LinkAction link_action)
         raises (Reflective::MofError);
      void add (
         in LinkEndData end_data,
         in LinkAction link_action)
         raises (Reflective::MofError);
      void modify_end_data (
         in LinkEndData end_data,
         in LinkAction link_action,
         in LinkEndData new_end_data)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in LinkEndData end_data,
         in LinkAction link_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AEndDataLinkAction

   struct AAssociationClearAssociationActionLink
   {
      Core::Association association;
      ClearAssociationAction clear_association_action;
   };
   typedef sequence<AAssociationClearAssociationActionLink> AAssociationClearAssociationActionLinkSet;

   interface AAssociationClearAssociationAction : Reflective::RefAssociation
   {
      AAssociationClearAssociationActionLinkSet all_a_association_clear_association_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Association association,
         in ClearAssociationAction clear_association_action)
         raises (Reflective::MofError);
      Core::Association association (in ClearAssociationAction clear_association_action)
         raises (Reflective::MofError);
      void add (
         in Core::Association association,
         in ClearAssociationAction clear_association_action)
         raises (Reflective::MofError);
      void modify_association (
         in Core::Association association,
         in ClearAssociationAction clear_association_action,
         in Core::Association new_association)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Association association,
         in ClearAssociationAction clear_association_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AAssociationClearAssociationAction

   struct AObjectClearAssociationActionLink
   {
      ActionFoundation::InputPin action_object;
      ClearAssociationAction clear_association_action;
   };
   typedef sequence<AObjectClearAssociationActionLink> AObjectClearAssociationActionLinkSet;

   interface AObjectClearAssociationAction : Reflective::RefAssociation
   {
      AObjectClearAssociationActionLinkSet all_a_object_clear_association_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin action_object,
         in ClearAssociationAction clear_association_action)
         raises (Reflective::MofError);
      ActionFoundation::InputPin action_object (in ClearAssociationAction clear_association_action)
         raises (Reflective::MofError);
   }; // end of interface AObjectClearAssociationAction

   struct ReadAttributeActionResultLink
   {
      ActionFoundation::OutputPin result;
      ReadAttributeAction read_attribute_action;
   };
   typedef sequence<ReadAttributeActionResultLink> ReadAttributeActionResultLinkSet;

   interface ReadAttributeActionResult : Reflective::RefAssociation
   {
      ReadAttributeActionResultLinkSet all_read_attribute_action_result_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin result,
         in ReadAttributeAction read_attribute_action)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin result (in ReadAttributeAction read_attribute_action)
         raises (Reflective::MofError);
   }; // end of interface ReadAttributeActionResult

   struct AddAttributeValueActionInsertAtLink
   {
      ActionFoundation::InputPin insert_at;
      AddAttributeValueAction add_attribute_value_action;
   };
   typedef sequence<AddAttributeValueActionInsertAtLink> AddAttributeValueActionInsertAtLinkSet;

   interface AddAttributeValueActionInsertAt : Reflective::RefAssociation
   {
      AddAttributeValueActionInsertAtLinkSet all_add_attribute_value_action_insert_at_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin insert_at,
         in AddAttributeValueAction add_attribute_value_action)
         raises (Reflective::MofError);
      ActionFoundation::InputPin insert_at (in AddAttributeValueAction add_attribute_value_action)
         raises (Reflective::MofError);
   }; // end of interface AddAttributeValueActionInsertAt

   struct AttributeActionObjectLink
   {
      ActionFoundation::InputPin action_object;
      AttributeAction attribute_action;
   };
   typedef sequence<AttributeActionObjectLink> AttributeActionObjectLinkSet;

   interface AttributeActionObject : Reflective::RefAssociation
   {
      AttributeActionObjectLinkSet all_attribute_action_object_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin action_object,
         in AttributeAction attribute_action)
         raises (Reflective::MofError);
      ActionFoundation::InputPin action_object (in AttributeAction attribute_action)
         raises (Reflective::MofError);
   }; // end of interface AttributeActionObject

   struct AAttributeActionAttributeLink
   {
      AttributeAction attribute_action;
      Core::UmlAttribute uml_attribute;
   };
   typedef sequence<AAttributeActionAttributeLink> AAttributeActionAttributeLinkSet;

   interface AAttributeActionAttribute : Reflective::RefAssociation
   {
      AAttributeActionAttributeLinkSet all_a_attribute_action_attribute_links()
         raises (Reflective::MofError);
      boolean exists (
         in AttributeAction attribute_action,
         in Core::UmlAttribute uml_attribute)
         raises (Reflective::MofError);
      Core::UmlAttribute uml_attribute (in AttributeAction attribute_action)
         raises (Reflective::MofError);
      void add (
         in AttributeAction attribute_action,
         in Core::UmlAttribute uml_attribute)
         raises (Reflective::MofError);
      void modify_uml_attribute (
         in AttributeAction attribute_action,
         in Core::UmlAttribute uml_attribute,
         in Core::UmlAttribute new_uml_attribute)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in AttributeAction attribute_action,
         in Core::UmlAttribute uml_attribute)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AAttributeActionAttribute

   struct WriteAttributeActionValueLink
   {
      ActionFoundation::InputPin value;
      WriteAttributeAction write_attribute_action;
   };
   typedef sequence<WriteAttributeActionValueLink> WriteAttributeActionValueLinkSet;

   interface WriteAttributeActionValue : Reflective::RefAssociation
   {
      WriteAttributeActionValueLinkSet all_write_attribute_action_value_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin value,
         in WriteAttributeAction write_attribute_action)
         raises (Reflective::MofError);
      ActionFoundation::InputPin value (in WriteAttributeAction write_attribute_action)
         raises (Reflective::MofError);
   }; // end of interface WriteAttributeActionValue

   struct DestroyObjectActionInputLink
   {
      ActionFoundation::InputPin input;
      DestroyObjectAction destroy_object_action;
   };
   typedef sequence<DestroyObjectActionInputLink> DestroyObjectActionInputLinkSet;

   interface DestroyObjectActionInput : Reflective::RefAssociation
   {
      DestroyObjectActionInputLinkSet all_destroy_object_action_input_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin input,
         in DestroyObjectAction destroy_object_action)
         raises (Reflective::MofError);
      ActionFoundation::InputPin input (in DestroyObjectAction destroy_object_action)
         raises (Reflective::MofError);
   }; // end of interface DestroyObjectActionInput

   struct AClassifierCreateObjectActionLink
   {
      Core::Classifier classifier;
      CreateObjectAction create_object_action;
   };
   typedef sequence<AClassifierCreateObjectActionLink> AClassifierCreateObjectActionLinkSet;

   interface AClassifierCreateObjectAction : Reflective::RefAssociation
   {
      AClassifierCreateObjectActionLinkSet all_a_classifier_create_object_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Classifier classifier,
         in CreateObjectAction create_object_action)
         raises (Reflective::MofError);
      Core::Classifier classifier (in CreateObjectAction create_object_action)
         raises (Reflective::MofError);
      void add (
         in Core::Classifier classifier,
         in CreateObjectAction create_object_action)
         raises (Reflective::MofError);
      void modify_classifier (
         in Core::Classifier classifier,
         in CreateObjectAction create_object_action,
         in Core::Classifier new_classifier)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Classifier classifier,
         in CreateObjectAction create_object_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AClassifierCreateObjectAction

   struct CreateObjectActionResultLink
   {
      ActionFoundation::OutputPin result;
      CreateObjectAction create_object_action;
   };
   typedef sequence<CreateObjectActionResultLink> CreateObjectActionResultLinkSet;

   interface CreateObjectActionResult : Reflective::RefAssociation
   {
      CreateObjectActionResultLinkSet all_create_object_action_result_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin result,
         in CreateObjectAction create_object_action)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin result (in CreateObjectAction create_object_action)
         raises (Reflective::MofError);
   }; // end of interface CreateObjectActionResult

   struct AOldClassifierReclassifyObjectActionLink
   {
      Core::Classifier old_classifier;
      ReclassifyObjectAction reclassify_object_action;
   };
   typedef sequence<AOldClassifierReclassifyObjectActionLink> AOldClassifierReclassifyObjectActionLinkSet;

   interface AOldClassifierReclassifyObjectAction : Reflective::RefAssociation
   {
      AOldClassifierReclassifyObjectActionLinkSet all_a_old_classifier_reclassify_object_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Classifier old_classifier,
         in ReclassifyObjectAction reclassify_object_action)
         raises (Reflective::MofError);
      ClassifierSet old_classifier (in ReclassifyObjectAction reclassify_object_action)
         raises (Reflective::MofError);
      void add (
         in Core::Classifier old_classifier,
         in ReclassifyObjectAction reclassify_object_action)
         raises (Reflective::MofError);
      void modify_old_classifier (
         in Core::Classifier old_classifier,
         in ReclassifyObjectAction reclassify_object_action,
         in Core::Classifier new_old_classifier)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Classifier old_classifier,
         in ReclassifyObjectAction reclassify_object_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AOldClassifierReclassifyObjectAction

   struct ANewClassifierReclassifyObjectActionLink
   {
      Core::Classifier new_classifier;
      ReclassifyObjectAction reclassify_object_action;
   };
   typedef sequence<ANewClassifierReclassifyObjectActionLink> ANewClassifierReclassifyObjectActionLinkSet;

   interface ANewClassifierReclassifyObjectAction : Reflective::RefAssociation
   {
      ANewClassifierReclassifyObjectActionLinkSet all_a_new_classifier_reclassify_object_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Classifier new_classifier,
         in ReclassifyObjectAction reclassify_object_action)
         raises (Reflective::MofError);
      ClassifierSet new_classifier (in ReclassifyObjectAction reclassify_object_action)
         raises (Reflective::MofError);
      void add (
         in Core::Classifier new_classifier,
         in ReclassifyObjectAction reclassify_object_action)
         raises (Reflective::MofError);
      void modify_new_classifier (
         in Core::Classifier new_classifier,
         in ReclassifyObjectAction reclassify_object_action,
         in Core::Classifier new_new_classifier)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Classifier new_classifier,
         in ReclassifyObjectAction reclassify_object_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ANewClassifierReclassifyObjectAction

   struct ReclassifyObjectActionInputLink
   {
      ActionFoundation::InputPin input;
      ReclassifyObjectAction reclassify_object_action;
   };
   typedef sequence<ReclassifyObjectActionInputLink> ReclassifyObjectActionInputLinkSet;

   interface ReclassifyObjectActionInput : Reflective::RefAssociation
   {
      ReclassifyObjectActionInputLinkSet all_reclassify_object_action_input_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin input,
         in ReclassifyObjectAction reclassify_object_action)
         raises (Reflective::MofError);
      ActionFoundation::InputPin input (in ReclassifyObjectAction reclassify_object_action)
         raises (Reflective::MofError);
   }; // end of interface ReclassifyObjectActionInput

   struct AClassifierReadIsClassifiedObjectActionLink
   {
      Core::Classifier classifier;
      ReadIsClassifiedObjectAction read_is_classified_object_action;
   };
   typedef sequence<AClassifierReadIsClassifiedObjectActionLink> AClassifierReadIsClassifiedObjectActionLinkSet;

   interface AClassifierReadIsClassifiedObjectAction : Reflective::RefAssociation
   {
      AClassifierReadIsClassifiedObjectActionLinkSet all_a_classifier_read_is_classified_object_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Classifier classifier,
         in ReadIsClassifiedObjectAction read_is_classified_object_action)
         raises (Reflective::MofError);
      Core::Classifier classifier (in ReadIsClassifiedObjectAction read_is_classified_object_action)
         raises (Reflective::MofError);
      void add (
         in Core::Classifier classifier,
         in ReadIsClassifiedObjectAction read_is_classified_object_action)
         raises (Reflective::MofError);
      void modify_classifier (
         in Core::Classifier classifier,
         in ReadIsClassifiedObjectAction read_is_classified_object_action,
         in Core::Classifier new_classifier)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Classifier classifier,
         in ReadIsClassifiedObjectAction read_is_classified_object_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AClassifierReadIsClassifiedObjectAction

   struct ReadClassifiedObjectActionInputLink
   {
      ActionFoundation::InputPin input;
      ReadIsClassifiedObjectAction read_is_classified_object_action;
   };
   typedef sequence<ReadClassifiedObjectActionInputLink> ReadClassifiedObjectActionInputLinkSet;

   interface ReadClassifiedObjectActionInput : Reflective::RefAssociation
   {
      ReadClassifiedObjectActionInputLinkSet all_read_classified_object_action_input_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin input,
         in ReadIsClassifiedObjectAction read_is_classified_object_action)
         raises (Reflective::MofError);
      ActionFoundation::InputPin input (in ReadIsClassifiedObjectAction read_is_classified_object_action)
         raises (Reflective::MofError);
   }; // end of interface ReadClassifiedObjectActionInput

   struct ReadIsClassifiedObjectActionResultLink
   {
      ActionFoundation::OutputPin result;
      ReadIsClassifiedObjectAction read_is_classified_object_action;
   };
   typedef sequence<ReadIsClassifiedObjectActionResultLink> ReadIsClassifiedObjectActionResultLinkSet;

   interface ReadIsClassifiedObjectActionResult : Reflective::RefAssociation
   {
      ReadIsClassifiedObjectActionResultLinkSet all_read_is_classified_object_action_result_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin result,
         in ReadIsClassifiedObjectAction read_is_classified_object_action)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin result (in ReadIsClassifiedObjectAction read_is_classified_object_action)
         raises (Reflective::MofError);
   }; // end of interface ReadIsClassifiedObjectActionResult

   struct ReadSelfActionResultLink
   {
      ActionFoundation::OutputPin result;
      ReadSelfAction read_self_action;
   };
   typedef sequence<ReadSelfActionResultLink> ReadSelfActionResultLinkSet;

   interface ReadSelfActionResult : Reflective::RefAssociation
   {
      ReadSelfActionResultLinkSet all_read_self_action_result_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin result,
         in ReadSelfAction read_self_action)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin result (in ReadSelfAction read_self_action)
         raises (Reflective::MofError);
   }; // end of interface ReadSelfActionResult

   struct ReadExtentActionResultLink
   {
      ActionFoundation::OutputPin result;
      ReadExtentAction read_extent_action;
   };
   typedef sequence<ReadExtentActionResultLink> ReadExtentActionResultLinkSet;

   interface ReadExtentActionResult : Reflective::RefAssociation
   {
      ReadExtentActionResultLinkSet all_read_extent_action_result_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin result,
         in ReadExtentAction read_extent_action)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin result (in ReadExtentAction read_extent_action)
         raises (Reflective::MofError);
   }; // end of interface ReadExtentActionResult

   struct AClassifierReadExtentActionLink
   {
      Core::Classifier classifier;
      ReadExtentAction read_extent_action;
   };
   typedef sequence<AClassifierReadExtentActionLink> AClassifierReadExtentActionLinkSet;

   interface AClassifierReadExtentAction : Reflective::RefAssociation
   {
      AClassifierReadExtentActionLinkSet all_a_classifier_read_extent_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Classifier classifier,
         in ReadExtentAction read_extent_action)
         raises (Reflective::MofError);
      Core::Classifier classifier (in ReadExtentAction read_extent_action)
         raises (Reflective::MofError);
      void add (
         in Core::Classifier classifier,
         in ReadExtentAction read_extent_action)
         raises (Reflective::MofError);
      void modify_classifier (
         in Core::Classifier classifier,
         in ReadExtentAction read_extent_action,
         in Core::Classifier new_classifier)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Classifier classifier,
         in ReadExtentAction read_extent_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AClassifierReadExtentAction

   struct StartStateMachineActionInputLink
   {
      ActionFoundation::InputPin input;
      StartObjectStateMachineAction start_object_state_machine_action;
   };
   typedef sequence<StartStateMachineActionInputLink> StartStateMachineActionInputLinkSet;

   interface StartStateMachineActionInput : Reflective::RefAssociation
   {
      StartStateMachineActionInputLinkSet all_start_state_machine_action_input_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin input,
         in StartObjectStateMachineAction start_object_state_machine_action)
         raises (Reflective::MofError);
      ActionFoundation::InputPin input (in StartObjectStateMachineAction start_object_state_machine_action)
         raises (Reflective::MofError);
   }; // end of interface StartStateMachineActionInput

   struct AInsertAtAddVariableValueActionLink
   {
      ActionFoundation::InputPin insert_at;
      AddVariableValueAction add_variable_value_action;
   };
   typedef sequence<AInsertAtAddVariableValueActionLink> AInsertAtAddVariableValueActionLinkSet;

   interface AInsertAtAddVariableValueAction : Reflective::RefAssociation
   {
      AInsertAtAddVariableValueActionLinkSet all_a_insert_at_add_variable_value_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin insert_at,
         in AddVariableValueAction add_variable_value_action)
         raises (Reflective::MofError);
      ActionFoundation::InputPin insert_at (in AddVariableValueAction add_variable_value_action)
         raises (Reflective::MofError);
   }; // end of interface AInsertAtAddVariableValueAction

   struct AResultReadVariableActionLink
   {
      ActionFoundation::OutputPin result;
      ReadVariableAction read_variable_action;
   };
   typedef sequence<AResultReadVariableActionLink> AResultReadVariableActionLinkSet;

   interface AResultReadVariableAction : Reflective::RefAssociation
   {
      AResultReadVariableActionLinkSet all_a_result_read_variable_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin result,
         in ReadVariableAction read_variable_action)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin result (in ReadVariableAction read_variable_action)
         raises (Reflective::MofError);
   }; // end of interface AResultReadVariableAction

   struct AVariableVariableActionLink
   {
      Actions::Variable variable;
      VariableAction variable_action;
   };
   typedef sequence<AVariableVariableActionLink> AVariableVariableActionLinkSet;

   interface AVariableVariableAction : Reflective::RefAssociation
   {
      AVariableVariableActionLinkSet all_a_variable_variable_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in Actions::Variable variable,
         in VariableAction variable_action)
         raises (Reflective::MofError);
      Actions::Variable variable (in VariableAction variable_action)
         raises (Reflective::MofError);
      void add (
         in Actions::Variable variable,
         in VariableAction variable_action)
         raises (Reflective::MofError);
      void modify_variable (
         in Actions::Variable variable,
         in VariableAction variable_action,
         in Actions::Variable new_variable)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Actions::Variable variable,
         in VariableAction variable_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AVariableVariableAction

   struct AValueWriteVariableActionLink
   {
      ActionFoundation::InputPin value;
      WriteVariableAction write_variable_action;
   };
   typedef sequence<AValueWriteVariableActionLink> AValueWriteVariableActionLinkSet;

   interface AValueWriteVariableAction : Reflective::RefAssociation
   {
      AValueWriteVariableActionLinkSet all_a_value_write_variable_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin value,
         in WriteVariableAction write_variable_action)
         raises (Reflective::MofError);
      ActionFoundation::InputPin value (in WriteVariableAction write_variable_action)
         raises (Reflective::MofError);
   }; // end of interface AValueWriteVariableAction

   struct ASignalSendSignalActionLink
   {
      CommonBehavior::Signal signal;
      SendSignalAction send_signal_action;
   };
   typedef sequence<ASignalSendSignalActionLink> ASignalSendSignalActionLinkSet;

   interface ASignalSendSignalAction : Reflective::RefAssociation
   {
      ASignalSendSignalActionLinkSet all_a_signal_send_signal_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in CommonBehavior::Signal signal,
         in SendSignalAction send_signal_action)
         raises (Reflective::MofError);
      CommonBehavior::Signal signal (in SendSignalAction send_signal_action)
         raises (Reflective::MofError);
      void add (
         in CommonBehavior::Signal signal,
         in SendSignalAction send_signal_action)
         raises (Reflective::MofError);
      void modify_signal (
         in CommonBehavior::Signal signal,
         in SendSignalAction send_signal_action,
         in CommonBehavior::Signal new_signal)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CommonBehavior::Signal signal,
         in SendSignalAction send_signal_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASignalSendSignalAction

   struct ASignalBroadcastSignalActionLink
   {
      CommonBehavior::Signal signal;
      BroadcastSignalAction broadcast_signal_action;
   };
   typedef sequence<ASignalBroadcastSignalActionLink> ASignalBroadcastSignalActionLinkSet;

   interface ASignalBroadcastSignalAction : Reflective::RefAssociation
   {
      ASignalBroadcastSignalActionLinkSet all_a_signal_broadcast_signal_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in CommonBehavior::Signal signal,
         in BroadcastSignalAction broadcast_signal_action)
         raises (Reflective::MofError);
      CommonBehavior::Signal signal (in BroadcastSignalAction broadcast_signal_action)
         raises (Reflective::MofError);
      void add (
         in CommonBehavior::Signal signal,
         in BroadcastSignalAction broadcast_signal_action)
         raises (Reflective::MofError);
      void modify_signal (
         in CommonBehavior::Signal signal,
         in BroadcastSignalAction broadcast_signal_action,
         in CommonBehavior::Signal new_signal)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CommonBehavior::Signal signal,
         in BroadcastSignalAction broadcast_signal_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASignalBroadcastSignalAction

   struct SendSignalActionTargetLink
   {
      ActionFoundation::InputPin target;
      SendSignalAction send_signal_action;
   };
   typedef sequence<SendSignalActionTargetLink> SendSignalActionTargetLinkSet;

   interface SendSignalActionTarget : Reflective::RefAssociation
   {
      SendSignalActionTargetLinkSet all_send_signal_action_target_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin target,
         in SendSignalAction send_signal_action)
         raises (Reflective::MofError);
      ActionFoundation::InputPin target (in SendSignalAction send_signal_action)
         raises (Reflective::MofError);
   }; // end of interface SendSignalActionTarget

   struct TestIdentityActionResultLink
   {
      TestIdentityAction test_identity_action;
      ActionFoundation::OutputPin result;
   };
   typedef sequence<TestIdentityActionResultLink> TestIdentityActionResultLinkSet;

   interface TestIdentityActionResult : Reflective::RefAssociation
   {
      TestIdentityActionResultLinkSet all_test_identity_action_result_links()
         raises (Reflective::MofError);
      boolean exists (
         in TestIdentityAction test_identity_action,
         in ActionFoundation::OutputPin result)
         raises (Reflective::MofError);
      ActionFoundation::OutputPin result (in TestIdentityAction test_identity_action)
         raises (Reflective::MofError);
   }; // end of interface TestIdentityActionResult

   struct AUnmarshalTypeUnmarshalActionLink
   {
      Core::Class unmarshal_type;
      UnmarshalAction unmarshal_action;
   };
   typedef sequence<AUnmarshalTypeUnmarshalActionLink> AUnmarshalTypeUnmarshalActionLinkSet;

   interface AUnmarshalTypeUnmarshalAction : Reflective::RefAssociation
   {
      AUnmarshalTypeUnmarshalActionLinkSet all_a_unmarshal_type_unmarshal_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Class unmarshal_type,
         in UnmarshalAction unmarshal_action)
         raises (Reflective::MofError);
      Core::Class unmarshal_type (in UnmarshalAction unmarshal_action)
         raises (Reflective::MofError);
      void add (
         in Core::Class unmarshal_type,
         in UnmarshalAction unmarshal_action)
         raises (Reflective::MofError);
      void modify_unmarshal_type (
         in Core::Class unmarshal_type,
         in UnmarshalAction unmarshal_action,
         in Core::Class new_unmarshal_type)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Class unmarshal_type,
         in UnmarshalAction unmarshal_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AUnmarshalTypeUnmarshalAction

   struct AMarshalTypeMarshalActionLink
   {
      Core::Class marshal_type;
      MarshalAction marshal_action;
   };
   typedef sequence<AMarshalTypeMarshalActionLink> AMarshalTypeMarshalActionLinkSet;

   interface AMarshalTypeMarshalAction : Reflective::RefAssociation
   {
      AMarshalTypeMarshalActionLinkSet all_a_marshal_type_marshal_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Class marshal_type,
         in MarshalAction marshal_action)
         raises (Reflective::MofError);
      Core::Class marshal_type (in MarshalAction marshal_action)
         raises (Reflective::MofError);
      void add (
         in Core::Class marshal_type,
         in MarshalAction marshal_action)
         raises (Reflective::MofError);
      void modify_marshal_type (
         in Core::Class marshal_type,
         in MarshalAction marshal_action,
         in Core::Class new_marshal_type)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Class marshal_type,
         in MarshalAction marshal_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AMarshalTypeMarshalAction

   struct CallProcedureActionOutputPinLink
   {
      ActionFoundation::OutputPin output;
      CallProcedureAction call_procedure_action;
   };
   typedef sequence<CallProcedureActionOutputPinLink> CallProcedureActionOutputPinLinkSet;

   interface CallProcedureActionOutputPin : Reflective::RefAssociation
   {
      CallProcedureActionOutputPinLinkSet all_call_procedure_action_output_pin_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::OutputPin output,
         in CallProcedureAction call_procedure_action)
         raises (Reflective::MofError);
      OutputPinSet output (in CallProcedureAction call_procedure_action)
         raises (Reflective::MofError);
   }; // end of interface CallProcedureActionOutputPin

   struct CallProcedureActionInputPinLink
   {
      ActionFoundation::InputPin input;
      CallProcedureAction call_procedure_action;
   };
   typedef sequence<CallProcedureActionInputPinLink> CallProcedureActionInputPinLinkSet;

   interface CallProcedureActionInputPin : Reflective::RefAssociation
   {
      CallProcedureActionInputPinLinkSet all_call_procedure_action_input_pin_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::InputPin input,
         in CallProcedureAction call_procedure_action)
         raises (Reflective::MofError);
      InputPinSet input (in CallProcedureAction call_procedure_action)
         raises (Reflective::MofError);
   }; // end of interface CallProcedureActionInputPin

   struct ACalledProcedureCallProcedureActionLink
   {
      CommonBehavior::Procedure called_procedure;
      CallProcedureAction call_procedure_action;
   };
   typedef sequence<ACalledProcedureCallProcedureActionLink> ACalledProcedureCallProcedureActionLinkSet;

   interface ACalledProcedureCallProcedureAction : Reflective::RefAssociation
   {
      ACalledProcedureCallProcedureActionLinkSet all_a_called_procedure_call_procedure_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in CommonBehavior::Procedure called_procedure,
         in CallProcedureAction call_procedure_action)
         raises (Reflective::MofError);
      CommonBehavior::Procedure called_procedure (in CallProcedureAction call_procedure_action)
         raises (Reflective::MofError);
      void add (
         in CommonBehavior::Procedure called_procedure,
         in CallProcedureAction call_procedure_action)
         raises (Reflective::MofError);
      void modify_called_procedure (
         in CommonBehavior::Procedure called_procedure,
         in CallProcedureAction call_procedure_action,
         in CommonBehavior::Procedure new_called_procedure)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in CommonBehavior::Procedure called_procedure,
         in CallProcedureAction call_procedure_action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ACalledProcedureCallProcedureAction

   interface ActionsPackageFactory
   {
      ActionsPackage create_actions_package ()
         raises (Reflective::MofError);
   };

   interface ActionsPackage : Reflective::RefPackage
   {
      readonly attribute DataTypes::DataTypesPackage data_types_ref;
      readonly attribute Core::CorePackage core_ref;
      readonly attribute CommonBehavior::CommonBehaviorPackage common_behavior_ref;
      readonly attribute ActionFoundation::ActionFoundationPackage action_foundation_ref;
      readonly attribute CollectionActionClass collection_action_ref;
      readonly attribute FilterActionClass filter_action_ref;
      readonly attribute IterateActionClass iterate_action_ref;
      readonly attribute MapActionClass map_action_ref;
      readonly attribute ReduceActionClass reduce_action_ref;
      readonly attribute ClauseClass clause_ref;
      readonly attribute ConditionalActionClass conditional_action_ref;
      readonly attribute GroupActionClass group_action_ref;
      readonly attribute LoopActionClass loop_action_ref;
      readonly attribute VariableClass variable_ref;
      readonly attribute ApplyFunctionActionClass apply_function_action_ref;
      readonly attribute ArgumentSpecificationClass argument_specification_ref;
      readonly attribute CodeActionClass code_action_ref;
      readonly attribute LiteralValueActionClass literal_value_action_ref;
      readonly attribute MarshalActionClass marshal_action_ref;
      readonly attribute NullActionClass null_action_ref;
      readonly attribute PrimitiveFunctionClass primitive_function_ref;
      readonly attribute TestIdentityActionClass test_identity_action_ref;
      readonly attribute UnmarshalActionClass unmarshal_action_ref;
      readonly attribute JumpHandlerClass jump_handler_ref;
      readonly attribute HandlerActionClass handler_action_ref;
      readonly attribute JumpActionClass jump_action_ref;
      readonly attribute InvocationActionClass invocation_action_ref;
      readonly attribute AsynchronousInvocationActionClass asynchronous_invocation_action_ref;
      readonly attribute ExplicitInvocationActtionClass explicit_invocation_acttion_ref;
      readonly attribute CallOperationActionClass call_operation_action_ref;
      readonly attribute SynchronousInvocationActionClass synchronous_invocation_action_ref;
      readonly attribute ClearAssociationActionClass clear_association_action_ref;
      readonly attribute LinkActionClass link_action_ref;
      readonly attribute WriteLinkActionClass write_link_action_ref;
      readonly attribute CreateLinkActionClass create_link_action_ref;
      readonly attribute CreateLinkObjectActionClass create_link_object_action_ref;
      readonly attribute DestroyLinkActionClass destroy_link_action_ref;
      readonly attribute LinkEndDataClass link_end_data_ref;
      readonly attribute LinkEndCreationDataClass link_end_creation_data_ref;
      readonly attribute QualifierValueClass qualifier_value_ref;
      readonly attribute ReadLinkActionClass read_link_action_ref;
      readonly attribute ReadLinkObjectEndActionClass read_link_object_end_action_ref;
      readonly attribute ReadLinkObjectQualifierActionClass read_link_object_qualifier_action_ref;
      readonly attribute AttributeActionClass attribute_action_ref;
      readonly attribute WriteAttributeActionClass write_attribute_action_ref;
      readonly attribute AddAttributeValueActionClass add_attribute_value_action_ref;
      readonly attribute ClearAttributeActionClass clear_attribute_action_ref;
      readonly attribute ReadAttributeActionClass read_attribute_action_ref;
      readonly attribute RemoveAttributeValueActionClass remove_attribute_value_action_ref;
      readonly attribute CreateObjectActionClass create_object_action_ref;
      readonly attribute DestroyObjectActionClass destroy_object_action_ref;
      readonly attribute ReadIsClassifiedObjectActionClass read_is_classified_object_action_ref;
      readonly attribute ReclassifyObjectActionClass reclassify_object_action_ref;
      readonly attribute ReadExtentActionClass read_extent_action_ref;
      readonly attribute ReadSelfActionClass read_self_action_ref;
      readonly attribute StartObjectStateMachineActionClass start_object_state_machine_action_ref;
      readonly attribute VariableActionClass variable_action_ref;
      readonly attribute WriteVariableActionClass write_variable_action_ref;
      readonly attribute AddVariableValueActionClass add_variable_value_action_ref;
      readonly attribute ClearVariableActionClass clear_variable_action_ref;
      readonly attribute ReadVariableActionClass read_variable_action_ref;
      readonly attribute RemoveVariableValueActionClass remove_variable_value_action_ref;
      readonly attribute SendSignalActionClass send_signal_action_ref;
      readonly attribute BroadcastSignalActionClass broadcast_signal_action_ref;
      readonly attribute CallProcedureActionClass call_procedure_action_ref;
      readonly attribute ATypeVariable a_type_variable_ref;
      readonly attribute ASubinputFilterAction a_subinput_filter_action_ref;
      readonly attribute ASubtestFilterAction a_subtest_filter_action_ref;
      readonly attribute IterateActionResult iterate_action_result_ref;
      readonly attribute InterateActionLoopVariableInput interate_action_loop_variable_input_ref;
      readonly attribute ASubinputIterateAction a_subinput_iterate_action_ref;
      readonly attribute ALeftSubinputReduceAction a_left_subinput_reduce_action_ref;
      readonly attribute ASuboutputReduceAction a_suboutput_reduce_action_ref;
      readonly attribute ARightSubinputReduceAction a_right_subinput_reduce_action_ref;
      readonly attribute ASubactionCollectionAction a_subaction_collection_action_ref;
      readonly attribute MapActionOutputPin map_action_output_pin_ref;
      readonly attribute MapActionArgument map_action_argument_ref;
      readonly attribute FilterActionArgument filter_action_argument_ref;
      readonly attribute FilterActionResult filter_action_result_ref;
      readonly attribute ReduceActionArgument reduce_action_argument_ref;
      readonly attribute ReduceActionOutputPin reduce_action_output_pin_ref;
      readonly attribute ALoopVariableIterateAction a_loop_variable_iterate_action_ref;
      readonly attribute IterateActionCollectionInput iterate_action_collection_input_ref;
      readonly attribute ASuboutputIterateAction a_suboutput_iterate_action_ref;
      readonly attribute ASubinputMapAction a_subinput_map_action_ref;
      readonly attribute ASuboutputMapAction a_suboutput_map_action_ref;
      readonly attribute ASubactionGroup a_subaction_group_ref;
      readonly attribute ABodyClause a_body_clause_ref;
      readonly attribute AClauseConditionalAction a_clause_conditional_action_ref;
      readonly attribute AClauseLoopAction a_clause_loop_action_ref;
      readonly attribute ATestClause a_test_clause_ref;
      readonly attribute ABodyOutputClause a_body_output_clause_ref;
      readonly attribute ALoopVariableLoop a_loop_variable_loop_ref;
      readonly attribute ATestOutputClause a_test_output_clause_ref;
      readonly attribute AScopeVariable a_scope_variable_ref;
      readonly attribute APredecessorClauseSuccessorClause a_predecessor_clause_successor_clause_ref;
      readonly attribute ApplyFunctionActionArgument apply_function_action_argument_ref;
      readonly attribute AFunctionApplyFunctionAction a_function_apply_function_action_ref;
      readonly attribute AInputSpecPrimitiveFunction a_input_spec_primitive_function_ref;
      readonly attribute AOutputSpecPrimitiveFunction a_output_spec_primitive_function_ref;
      readonly attribute AValueLiteralValueAction a_value_literal_value_action_ref;
      readonly attribute ApplyFunctionActionResult apply_function_action_result_ref;
      readonly attribute CodeActionArgument code_action_argument_ref;
      readonly attribute CodeActionResult code_action_result_ref;
      readonly attribute LiteralValueActionResult literal_value_action_result_ref;
      readonly attribute TestIdentityActionFirst test_identity_action_first_ref;
      readonly attribute TestIdentityActionSecond test_identity_action_second_ref;
      readonly attribute MarshalActionArgument marshal_action_argument_ref;
      readonly attribute MarshalActionResult marshal_action_result_ref;
      readonly attribute UnmarshalActionArgument unmarshal_action_argument_ref;
      readonly attribute UnmarshalActionResult unmarshal_action_result_ref;
      readonly attribute ATypeArgumentSpecification a_type_argument_specification_ref;
      readonly attribute AExceptionJumpAction a_exception_jump_action_ref;
      readonly attribute AJumpHandlerProtectedAction a_jump_handler_protected_action_ref;
      readonly attribute JumpActionJumpOccurrence jump_action_jump_occurrence_ref;
      readonly attribute AHandlerOutputHandlerAction a_handler_output_handler_action_ref;
      readonly attribute ABodyHandlerAction a_body_handler_action_ref;
      readonly attribute HandlerActionOccurrence handler_action_occurrence_ref;
      readonly attribute AJumpTypeJumpHandler a_jump_type_jump_handler_ref;
      readonly attribute ABodyJumpHandler a_body_jump_handler_ref;
      readonly attribute InvocationActionTarget invocation_action_target_ref;
      readonly attribute InvocationActionRequest invocation_action_request_ref;
      readonly attribute SynchronousInvocationActionOutputPin synchronous_invocation_action_output_pin_ref;
      readonly attribute ExplicitInvocationActionArgument explicit_invocation_action_argument_ref;
      readonly attribute CallOperationActionResult call_operation_action_result_ref;
      readonly attribute CallOperationActionTarget call_operation_action_target_ref;
      readonly attribute AOperationCallOperationAction a_operation_call_operation_action_ref;
      readonly attribute ReadLinkActionResult read_link_action_result_ref;
      readonly attribute AResultReadLinkObjectEndAction a_result_read_link_object_end_action_ref;
      readonly attribute AResultReadLinkObjectQualifierAction a_result_read_link_object_qualifier_action_ref;
      readonly attribute AInsertAtLinkEndCreationData a_insert_at_link_end_creation_data_ref;
      readonly attribute AEndLinkEndData a_end_link_end_data_ref;
      readonly attribute LinkEndDataValue link_end_data_value_ref;
      readonly attribute AQualifierLinkEndData a_qualifier_link_end_data_ref;
      readonly attribute AQualifierQualifierValue a_qualifier_qualifier_value_ref;
      readonly attribute AQualifierValue a_qualifier_value_ref;
      readonly attribute AObjectReadLinkObjectEndAction a_object_read_link_object_end_action_ref;
      readonly attribute AEndReadLinkObjectEndAction a_end_read_link_object_end_action_ref;
      readonly attribute AObjectReadLinkObjectQualifierAction a_object_read_link_object_qualifier_action_ref;
      readonly attribute AQualifierReadLinkObjectQualifierAction a_qualifier_read_link_object_qualifier_action_ref;
      readonly attribute AResultCreateLinkObjectAction a_result_create_link_object_action_ref;
      readonly attribute AEndDataLinkAction a_end_data_link_action_ref;
      readonly attribute AAssociationClearAssociationAction a_association_clear_association_action_ref;
      readonly attribute AObjectClearAssociationAction a_object_clear_association_action_ref;
      readonly attribute ReadAttributeActionResult read_attribute_action_result_ref;
      readonly attribute AddAttributeValueActionInsertAt add_attribute_value_action_insert_at_ref;
      readonly attribute AttributeActionObject attribute_action_object_ref;
      readonly attribute AAttributeActionAttribute a_attribute_action_attribute_ref;
      readonly attribute WriteAttributeActionValue write_attribute_action_value_ref;
      readonly attribute DestroyObjectActionInput destroy_object_action_input_ref;
      readonly attribute AClassifierCreateObjectAction a_classifier_create_object_action_ref;
      readonly attribute CreateObjectActionResult create_object_action_result_ref;
      readonly attribute AOldClassifierReclassifyObjectAction a_old_classifier_reclassify_object_action_ref;
      readonly attribute ANewClassifierReclassifyObjectAction a_new_classifier_reclassify_object_action_ref;
      readonly attribute ReclassifyObjectActionInput reclassify_object_action_input_ref;
      readonly attribute AClassifierReadIsClassifiedObjectAction a_classifier_read_is_classified_object_action_ref;
      readonly attribute ReadClassifiedObjectActionInput read_classified_object_action_input_ref;
      readonly attribute ReadIsClassifiedObjectActionResult read_is_classified_object_action_result_ref;
      readonly attribute ReadSelfActionResult read_self_action_result_ref;
      readonly attribute ReadExtentActionResult read_extent_action_result_ref;
      readonly attribute AClassifierReadExtentAction a_classifier_read_extent_action_ref;
      readonly attribute StartStateMachineActionInput start_state_machine_action_input_ref;
      readonly attribute AInsertAtAddVariableValueAction a_insert_at_add_variable_value_action_ref;
      readonly attribute AResultReadVariableAction a_result_read_variable_action_ref;
      readonly attribute AVariableVariableAction a_variable_variable_action_ref;
      readonly attribute AValueWriteVariableAction a_value_write_variable_action_ref;
      readonly attribute ASignalSendSignalAction a_signal_send_signal_action_ref;
      readonly attribute ASignalBroadcastSignalAction a_signal_broadcast_signal_action_ref;
      readonly attribute SendSignalActionTarget send_signal_action_target_ref;
      readonly attribute TestIdentityActionResult test_identity_action_result_ref;
      readonly attribute AUnmarshalTypeUnmarshalAction a_unmarshal_type_unmarshal_action_ref;
      readonly attribute AMarshalTypeMarshalAction a_marshal_type_marshal_action_ref;
      readonly attribute CallProcedureActionOutputPin call_procedure_action_output_pin_ref;
      readonly attribute CallProcedureActionInputPin call_procedure_action_input_pin_ref;
      readonly attribute ACalledProcedureCallProcedureAction a_called_procedure_call_procedure_action_ref;
   };
};

#endif