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

module ActionFoundation
{
   interface ControlFlowClass;
   interface ControlFlow;
   typedef sequence<ControlFlow> ControlFlowSet;
   interface ActionClass;
   interface Action;
   typedef sequence<Action> ActionSet;
   interface PrimitiveActionClass;
   interface PrimitiveAction;
   typedef sequence<PrimitiveAction> PrimitiveActionSet;
   interface PinClass;
   interface Pin;
   typedef sequence<Pin> PinSet;
   interface InputPinClass;
   interface InputPin;
   typedef sequence<InputPin> InputPinSet;
   typedef sequence<InputPin> InputPinUList;
   interface DataFlowClass;
   interface DataFlow;
   typedef sequence<DataFlow> DataFlowSet;
   interface OutputPinClass;
   interface OutputPin;
   typedef sequence<OutputPin> OutputPinSet;
   typedef sequence<OutputPin> OutputPinUList;
   interface ActionFoundationPackage;

   interface ControlFlowClass : Core::ModelElementClass
   {
      readonly attribute ControlFlowSet all_of_type_control_flow;
      readonly attribute ControlFlowSet all_of_class_control_flow;
      ControlFlow create_control_flow (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface ControlFlow : ControlFlowClass, Core::ModelElement
   {
      Action predecessor ()
         raises (Reflective::MofError);
      void set_predecessor (in Action new_value)
         raises (Reflective::MofError);
      Action successor ()
         raises (Reflective::MofError);
      void set_successor (in Action new_value)
         raises (Reflective::MofError);
   }; // end of interface ControlFlow

   interface ActionClass : Core::ModelElementClass
   {
      readonly attribute ActionSet all_of_type_action;
   };

   interface Action : ActionClass, Core::ModelElement
   {
      boolean is_read_only ()
         raises (Reflective::MofError);
      void set_is_read_only (in boolean new_value)
         raises (Reflective::MofError);
      ControlFlowSet consequent ()
         raises (Reflective::MofError);
      void set_consequent (in ControlFlowSet new_value)
         raises (Reflective::MofError);
      void unset_consequent ()
         raises (Reflective::MofError);
      void add_consequent (in ControlFlow new_element)
         raises (Reflective::MofError);
      void modify_consequent (
         in ControlFlow old_element,
         in ControlFlow new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_consequent (in ControlFlow old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ControlFlowSet antecedent ()
         raises (Reflective::MofError);
      void set_antecedent (in ControlFlowSet new_value)
         raises (Reflective::MofError);
      void unset_antecedent ()
         raises (Reflective::MofError);
      void add_antecedent (in ControlFlow new_element)
         raises (Reflective::MofError);
      void modify_antecedent (
         in ControlFlow old_element,
         in ControlFlow new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_antecedent (in ControlFlow old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      OutputPinUList output_pin ()
         raises (Reflective::MofError);
      void set_output_pin (in OutputPinUList new_value)
         raises (Reflective::MofError);
      void unset_output_pin ()
         raises (Reflective::MofError);
      void add_output_pin (in OutputPin new_element)
         raises (Reflective::MofError);
      void add_output_pin_before (
         in OutputPin new_element,
         in OutputPin before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_output_pin (
         in OutputPin old_element,
         in OutputPin new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_output_pin (in OutputPin old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      OutputPinSet available_output ()
         raises (Reflective::MofError);
      InputPinUList input_pin ()
         raises (Reflective::MofError);
      void set_input_pin (in InputPinUList new_value)
         raises (Reflective::MofError);
      void unset_input_pin ()
         raises (Reflective::MofError);
      void add_input_pin (in InputPin new_element)
         raises (Reflective::MofError);
      void add_input_pin_before (
         in InputPin new_element,
         in InputPin before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_input_pin (
         in InputPin old_element,
         in InputPin new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_input_pin (in InputPin old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      InputPinSet available_input ()
         raises (Reflective::MofError);
      void set_available_input (in InputPinSet new_value)
         raises (Reflective::MofError);
      void unset_available_input ()
         raises (Reflective::MofError);
      void add_available_input (in InputPin new_element)
         raises (Reflective::MofError);
      void modify_available_input (
         in InputPin old_element,
         in InputPin new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_available_input (in InputPin old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      CommonBehavior::Procedure procedure ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_procedure (in CommonBehavior::Procedure new_value)
         raises (Reflective::MofError);
      void unset_procedure ()
         raises (Reflective::MofError);
   }; // end of interface Action

   interface PrimitiveActionClass : ActionClass
   {
      readonly attribute PrimitiveActionSet all_of_type_primitive_action;
   };

   interface PrimitiveAction : PrimitiveActionClass, Action
   {
   }; // end of interface PrimitiveAction

   interface PinClass : Core::ModelElementClass
   {
      readonly attribute PinSet all_of_type_pin;
   };

   interface Pin : PinClass, Core::ModelElement
   {
      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);
      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);
   }; // end of interface Pin

   interface InputPinClass : PinClass
   {
      readonly attribute InputPinSet all_of_type_input_pin;
      readonly attribute InputPinSet all_of_class_input_pin;
      InputPin create_input_pin (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::Multiplicity multiplicity,
         in DataTypes::OrderingKind ordering)
         raises (Reflective::MofError);
   };

   interface InputPin : InputPinClass, Pin
   {
      DataFlow flow ()
         raises (Reflective::MofError);
      void set_flow (in DataFlow new_value)
         raises (Reflective::MofError);
      CommonBehavior::Procedure procedure ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_procedure (in CommonBehavior::Procedure new_value)
         raises (Reflective::MofError);
      void unset_procedure ()
         raises (Reflective::MofError);
      ActionFoundation::Action action ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_action (in ActionFoundation::Action new_value)
         raises (Reflective::MofError);
      void unset_action ()
         raises (Reflective::MofError);
   }; // end of interface InputPin

   interface DataFlowClass : Core::ModelElementClass
   {
      readonly attribute DataFlowSet all_of_type_data_flow;
      readonly attribute DataFlowSet all_of_class_data_flow;
      DataFlow create_data_flow (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface DataFlow : DataFlowClass, Core::ModelElement
   {
      OutputPin source ()
         raises (Reflective::MofError);
      void set_source (in OutputPin new_value)
         raises (Reflective::MofError);
      InputPin destination ()
         raises (Reflective::MofError);
      void set_destination (in InputPin new_value)
         raises (Reflective::MofError);
   }; // end of interface DataFlow

   interface OutputPinClass : PinClass
   {
      readonly attribute OutputPinSet all_of_type_output_pin;
      readonly attribute OutputPinSet all_of_class_output_pin;
      OutputPin create_output_pin (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::Multiplicity multiplicity,
         in DataTypes::OrderingKind ordering)
         raises (Reflective::MofError);
   };

   interface OutputPin : OutputPinClass, Pin
   {
      DataFlowSet flow ()
         raises (Reflective::MofError);
      void set_flow (in DataFlowSet new_value)
         raises (Reflective::MofError);
      void unset_flow ()
         raises (Reflective::MofError);
      void add_flow (in DataFlow new_element)
         raises (Reflective::MofError);
      void modify_flow (
         in DataFlow old_element,
         in DataFlow new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_flow (in DataFlow old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      CommonBehavior::Procedure procedure ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_procedure (in CommonBehavior::Procedure new_value)
         raises (Reflective::MofError);
      void unset_procedure ()
         raises (Reflective::MofError);
      ActionFoundation::Action action ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_action (in ActionFoundation::Action new_value)
         raises (Reflective::MofError);
      void unset_action ()
         raises (Reflective::MofError);
   }; // end of interface OutputPin

   struct AConsequentPredecessorLink
   {
      ControlFlow consequent;
      Action predecessor;
   };
   typedef sequence<AConsequentPredecessorLink> AConsequentPredecessorLinkSet;

   interface AConsequentPredecessor : Reflective::RefAssociation
   {
      AConsequentPredecessorLinkSet all_a_consequent_predecessor_links()
         raises (Reflective::MofError);
      boolean exists (
         in ControlFlow consequent,
         in Action predecessor)
         raises (Reflective::MofError);
      ControlFlowSet consequent (in Action predecessor)
         raises (Reflective::MofError);
      Action predecessor (in ControlFlow consequent)
         raises (Reflective::MofError);
      void add (
         in ControlFlow consequent,
         in Action predecessor)
         raises (Reflective::MofError);
      void modify_consequent (
         in ControlFlow consequent,
         in Action predecessor,
         in ControlFlow new_consequent)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_predecessor (
         in ControlFlow consequent,
         in Action predecessor,
         in Action new_predecessor)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ControlFlow consequent,
         in Action predecessor)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AConsequentPredecessor

   struct ASuccessorAntecedentLink
   {
      Action successor;
      ControlFlow antecedent;
   };
   typedef sequence<ASuccessorAntecedentLink> ASuccessorAntecedentLinkSet;

   interface ASuccessorAntecedent : Reflective::RefAssociation
   {
      ASuccessorAntecedentLinkSet all_a_successor_antecedent_links()
         raises (Reflective::MofError);
      boolean exists (
         in Action successor,
         in ControlFlow antecedent)
         raises (Reflective::MofError);
      Action successor (in ControlFlow antecedent)
         raises (Reflective::MofError);
      ControlFlowSet antecedent (in Action successor)
         raises (Reflective::MofError);
      void add (
         in Action successor,
         in ControlFlow antecedent)
         raises (Reflective::MofError);
      void modify_successor (
         in Action successor,
         in ControlFlow antecedent,
         in Action new_successor)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_antecedent (
         in Action successor,
         in ControlFlow antecedent,
         in ControlFlow new_antecedent)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Action successor,
         in ControlFlow antecedent)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASuccessorAntecedent

   struct AActionProcedureLink
   {
      ActionFoundation::Action action;
      CommonBehavior::Procedure procedure;
   };
   typedef sequence<AActionProcedureLink> AActionProcedureLinkSet;

   interface AActionProcedure : Reflective::RefAssociation
   {
      AActionProcedureLinkSet all_a_action_procedure_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::Action action,
         in CommonBehavior::Procedure procedure)
         raises (Reflective::MofError);
      ActionFoundation::Action action (in CommonBehavior::Procedure procedure)
         raises (Reflective::MofError);
      CommonBehavior::Procedure procedure (in ActionFoundation::Action action)
         raises (Reflective::MofError);
      void modify_procedure (
         in ActionFoundation::Action action,
         in CommonBehavior::Procedure procedure,
         in CommonBehavior::Procedure new_procedure)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AActionProcedure

   struct AArgumentProcedureLink
   {
      OutputPin argument;
      CommonBehavior::Procedure procedure;
   };
   typedef sequence<AArgumentProcedureLink> AArgumentProcedureLinkSet;

   interface AArgumentProcedure : Reflective::RefAssociation
   {
      AArgumentProcedureLinkSet all_a_argument_procedure_links()
         raises (Reflective::MofError);
      boolean exists (
         in OutputPin argument,
         in CommonBehavior::Procedure procedure)
         raises (Reflective::MofError);
      OutputPinUList argument (in CommonBehavior::Procedure procedure)
         raises (Reflective::MofError);
      CommonBehavior::Procedure procedure (in OutputPin argument)
         raises (Reflective::MofError);
      void add (
         in OutputPin argument,
         in CommonBehavior::Procedure procedure)
         raises (Reflective::MofError);
      void add_before_argument (
         in OutputPin argument,
         in CommonBehavior::Procedure procedure,
         in OutputPin before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_argument (
         in OutputPin argument,
         in CommonBehavior::Procedure procedure,
         in OutputPin new_argument)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_procedure (
         in OutputPin argument,
         in CommonBehavior::Procedure procedure,
         in CommonBehavior::Procedure new_procedure)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in OutputPin argument,
         in CommonBehavior::Procedure procedure)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AArgumentProcedure

   struct AResultProcedureLink
   {
      InputPin result;
      CommonBehavior::Procedure procedure;
   };
   typedef sequence<AResultProcedureLink> AResultProcedureLinkSet;

   interface AResultProcedure : Reflective::RefAssociation
   {
      AResultProcedureLinkSet all_a_result_procedure_links()
         raises (Reflective::MofError);
      boolean exists (
         in InputPin result,
         in CommonBehavior::Procedure procedure)
         raises (Reflective::MofError);
      InputPinUList result (in CommonBehavior::Procedure procedure)
         raises (Reflective::MofError);
      CommonBehavior::Procedure procedure (in InputPin result)
         raises (Reflective::MofError);
      void add (
         in InputPin result,
         in CommonBehavior::Procedure procedure)
         raises (Reflective::MofError);
      void add_before_result (
         in InputPin result,
         in CommonBehavior::Procedure procedure,
         in InputPin before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_result (
         in InputPin result,
         in CommonBehavior::Procedure procedure,
         in InputPin new_result)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_procedure (
         in InputPin result,
         in CommonBehavior::Procedure procedure,
         in CommonBehavior::Procedure new_procedure)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in InputPin result,
         in CommonBehavior::Procedure procedure)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AResultProcedure

   struct ActionAvailableInputLink
   {
      InputPin available_input;
      ActionFoundation::Action action;
   };
   typedef sequence<ActionAvailableInputLink> ActionAvailableInputLinkSet;

   interface ActionAvailableInput : Reflective::RefAssociation
   {
      ActionAvailableInputLinkSet all_action_available_input_links()
         raises (Reflective::MofError);
      boolean exists (
         in InputPin available_input,
         in ActionFoundation::Action action)
         raises (Reflective::MofError);
      InputPinSet available_input (in ActionFoundation::Action action)
         raises (Reflective::MofError);
      void add (
         in InputPin available_input,
         in ActionFoundation::Action action)
         raises (Reflective::MofError);
      void modify_available_input (
         in InputPin available_input,
         in ActionFoundation::Action action,
         in InputPin new_available_input)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in InputPin available_input,
         in ActionFoundation::Action action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ActionAvailableInput

   struct AInputPinActionLink
   {
      InputPin input_pin;
      ActionFoundation::Action action;
   };
   typedef sequence<AInputPinActionLink> AInputPinActionLinkSet;

   interface AInputPinAction : Reflective::RefAssociation
   {
      AInputPinActionLinkSet all_a_input_pin_action_links()
         raises (Reflective::MofError);
      boolean exists (
         in InputPin input_pin,
         in ActionFoundation::Action action)
         raises (Reflective::MofError);
      InputPinUList input_pin (in ActionFoundation::Action action)
         raises (Reflective::MofError);
      ActionFoundation::Action action (in InputPin input_pin)
         raises (Reflective::MofError);
      void add (
         in InputPin input_pin,
         in ActionFoundation::Action action)
         raises (Reflective::MofError);
      void add_before_input_pin (
         in InputPin input_pin,
         in ActionFoundation::Action action,
         in InputPin before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_input_pin (
         in InputPin input_pin,
         in ActionFoundation::Action action,
         in InputPin new_input_pin)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_action (
         in InputPin input_pin,
         in ActionFoundation::Action action,
         in ActionFoundation::Action new_action)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in InputPin input_pin,
         in ActionFoundation::Action action)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AInputPinAction

   struct ASourceFlowLink
   {
      OutputPin source;
      DataFlow flow;
   };
   typedef sequence<ASourceFlowLink> ASourceFlowLinkSet;

   interface ASourceFlow : Reflective::RefAssociation
   {
      ASourceFlowLinkSet all_a_source_flow_links()
         raises (Reflective::MofError);
      boolean exists (
         in OutputPin source,
         in DataFlow flow)
         raises (Reflective::MofError);
      OutputPin source (in DataFlow flow)
         raises (Reflective::MofError);
      DataFlowSet flow (in OutputPin source)
         raises (Reflective::MofError);
      void add (
         in OutputPin source,
         in DataFlow flow)
         raises (Reflective::MofError);
      void modify_source (
         in OutputPin source,
         in DataFlow flow,
         in OutputPin new_source)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_flow (
         in OutputPin source,
         in DataFlow flow,
         in DataFlow new_flow)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in OutputPin source,
         in DataFlow flow)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASourceFlow

   struct AActionOutputPinLink
   {
      ActionFoundation::Action action;
      OutputPin output_pin;
   };
   typedef sequence<AActionOutputPinLink> AActionOutputPinLinkSet;

   interface AActionOutputPin : Reflective::RefAssociation
   {
      AActionOutputPinLinkSet all_a_action_output_pin_links()
         raises (Reflective::MofError);
      boolean exists (
         in ActionFoundation::Action action,
         in OutputPin output_pin)
         raises (Reflective::MofError);
      ActionFoundation::Action action (in OutputPin output_pin)
         raises (Reflective::MofError);
      OutputPinUList output_pin (in ActionFoundation::Action action)
         raises (Reflective::MofError);
      void add (
         in ActionFoundation::Action action,
         in OutputPin output_pin)
         raises (Reflective::MofError);
      void add_before_output_pin (
         in ActionFoundation::Action action,
         in OutputPin output_pin,
         in OutputPin before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_action (
         in ActionFoundation::Action action,
         in OutputPin output_pin,
         in ActionFoundation::Action new_action)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_output_pin (
         in ActionFoundation::Action action,
         in OutputPin output_pin,
         in OutputPin new_output_pin)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ActionFoundation::Action action,
         in OutputPin output_pin)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AActionOutputPin

   struct ActionAvailableOutputLink
   {
      OutputPin available_output;
      ActionFoundation::Action action;
   };
   typedef sequence<ActionAvailableOutputLink> ActionAvailableOutputLinkSet;

   interface ActionAvailableOutput : Reflective::RefAssociation
   {
      ActionAvailableOutputLinkSet all_action_available_output_links()
         raises (Reflective::MofError);
      boolean exists (
         in OutputPin available_output,
         in ActionFoundation::Action action)
         raises (Reflective::MofError);
      OutputPinSet available_output (in ActionFoundation::Action action)
         raises (Reflective::MofError);
   }; // end of interface ActionAvailableOutput

   struct ATypePinLink
   {
      Core::Classifier type;
      ActionFoundation::Pin pin;
   };
   typedef sequence<ATypePinLink> ATypePinLinkSet;

   interface ATypePin : Reflective::RefAssociation
   {
      ATypePinLinkSet all_a_type_pin_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::Classifier type,
         in ActionFoundation::Pin pin)
         raises (Reflective::MofError);
      Core::Classifier type (in ActionFoundation::Pin pin)
         raises (Reflective::MofError);
      void add (
         in Core::Classifier type,
         in ActionFoundation::Pin pin)
         raises (Reflective::MofError);
      void modify_type (
         in Core::Classifier type,
         in ActionFoundation::Pin pin,
         in Core::Classifier new_type)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::Classifier type,
         in ActionFoundation::Pin pin)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ATypePin

   struct ADestinationFlowLink
   {
      InputPin destination;
      DataFlow flow;
   };
   typedef sequence<ADestinationFlowLink> ADestinationFlowLinkSet;

   interface ADestinationFlow : Reflective::RefAssociation
   {
      ADestinationFlowLinkSet all_a_destination_flow_links()
         raises (Reflective::MofError);
      boolean exists (
         in InputPin destination,
         in DataFlow flow)
         raises (Reflective::MofError);
      InputPin destination (in DataFlow flow)
         raises (Reflective::MofError);
      DataFlow flow (in InputPin destination)
         raises (Reflective::MofError);
      void add (
         in InputPin destination,
         in DataFlow flow)
         raises (Reflective::MofError);
      void modify_destination (
         in InputPin destination,
         in DataFlow flow,
         in InputPin new_destination)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_flow (
         in InputPin destination,
         in DataFlow flow,
         in DataFlow new_flow)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in InputPin destination,
         in DataFlow flow)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ADestinationFlow

   interface ActionFoundationPackageFactory
   {
      ActionFoundationPackage create_action_foundation_package ()
         raises (Reflective::MofError);
   };

   interface ActionFoundationPackage : Reflective::RefPackage
   {
      readonly attribute DataTypes::DataTypesPackage data_types_ref;
      readonly attribute Core::CorePackage core_ref;
      readonly attribute CommonBehavior::CommonBehaviorPackage common_behavior_ref;
      readonly attribute ControlFlowClass control_flow_ref;
      readonly attribute ActionClass action_ref;
      readonly attribute PrimitiveActionClass primitive_action_ref;
      readonly attribute PinClass pin_ref;
      readonly attribute InputPinClass input_pin_ref;
      readonly attribute DataFlowClass data_flow_ref;
      readonly attribute OutputPinClass output_pin_ref;
      readonly attribute AConsequentPredecessor a_consequent_predecessor_ref;
      readonly attribute ASuccessorAntecedent a_successor_antecedent_ref;
      readonly attribute AActionProcedure a_action_procedure_ref;
      readonly attribute AArgumentProcedure a_argument_procedure_ref;
      readonly attribute AResultProcedure a_result_procedure_ref;
      readonly attribute ActionAvailableInput action_available_input_ref;
      readonly attribute AInputPinAction a_input_pin_action_ref;
      readonly attribute ASourceFlow a_source_flow_ref;
      readonly attribute AActionOutputPin a_action_output_pin_ref;
      readonly attribute ActionAvailableOutput action_available_output_ref;
      readonly attribute ATypePin a_type_pin_ref;
      readonly attribute ADestinationFlow a_destination_flow_ref;
   };
};

#endif