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

module UseCases
{
   interface UseCaseClass;
   interface UseCase;
   typedef sequence<UseCase> UseCaseSet;
   interface ActorClass;
   interface Actor;
   typedef sequence<Actor> ActorSet;
   interface UseCaseInstanceClass;
   interface UseCaseInstance;
   typedef sequence<UseCaseInstance> UseCaseInstanceSet;
   interface ExtendClass;
   interface Extend;
   typedef sequence<Extend> ExtendSet;
   interface IncludeClass;
   interface Include;
   typedef sequence<Include> IncludeSet;
   interface ExtensionPointClass;
   interface ExtensionPoint;
   typedef sequence<ExtensionPoint> ExtensionPointSet;
   typedef sequence<ExtensionPoint> ExtensionPointUList;
   interface UseCasesPackage;

   interface UseCaseClass : Core::ClassifierClass
   {
      readonly attribute UseCaseSet all_of_type_use_case;
      readonly attribute UseCaseSet all_of_class_use_case;
      UseCase create_use_case (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_root,
         in boolean is_leaf,
         in boolean is_abstract)
         raises (Reflective::MofError);
   };

   interface UseCase : UseCaseClass, Core::Classifier
   {
      ExtendSet extend ()
         raises (Reflective::MofError);
      void set_extend (in ExtendSet new_value)
         raises (Reflective::MofError);
      void unset_extend ()
         raises (Reflective::MofError);
      void add_extend (in UseCases::Extend new_element)
         raises (Reflective::MofError);
      void modify_extend (
         in UseCases::Extend old_element,
         in UseCases::Extend new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_extend (in UseCases::Extend old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      IncludeSet include ()
         raises (Reflective::MofError);
      void set_include (in IncludeSet new_value)
         raises (Reflective::MofError);
      void unset_include ()
         raises (Reflective::MofError);
      void add_include (in UseCases::Include new_element)
         raises (Reflective::MofError);
      void modify_include (
         in UseCases::Include old_element,
         in UseCases::Include new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_include (in UseCases::Include old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ExtensionPointSet extension_point ()
         raises (Reflective::MofError);
      void set_extension_point (in ExtensionPointSet new_value)
         raises (Reflective::MofError);
      void unset_extension_point ()
         raises (Reflective::MofError);
      void add_extension_point (in ExtensionPoint new_element)
         raises (Reflective::MofError);
      void modify_extension_point (
         in ExtensionPoint old_element,
         in ExtensionPoint new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_extension_point (in ExtensionPoint old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface UseCase

   interface ActorClass : Core::ClassifierClass
   {
      readonly attribute ActorSet all_of_type_actor;
      readonly attribute ActorSet all_of_class_actor;
      Actor create_actor (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_root,
         in boolean is_leaf,
         in boolean is_abstract)
         raises (Reflective::MofError);
   };

   interface Actor : ActorClass, Core::Classifier
   {
   }; // end of interface Actor

   interface UseCaseInstanceClass : CommonBehavior::InstanceClass
   {
      readonly attribute UseCaseInstanceSet all_of_type_use_case_instance;
      readonly attribute UseCaseInstanceSet all_of_class_use_case_instance;
      UseCaseInstance create_use_case_instance (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface UseCaseInstance : UseCaseInstanceClass, CommonBehavior::Instance
   {
   }; // end of interface UseCaseInstance

   interface ExtendClass : Core::RelationshipClass
   {
      readonly attribute ExtendSet all_of_type_extend;
      readonly attribute ExtendSet all_of_class_extend;
      Extend create_extend (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::BooleanExpression condition)
         raises (Reflective::MofError);
   };

   interface Extend : ExtendClass, Core::Relationship
   {
      DataTypes::BooleanExpression condition ()
         raises (Reflective::MofError);
      void set_condition (in DataTypes::BooleanExpression new_value)
         raises (Reflective::MofError);
      UseCase base ()
         raises (Reflective::MofError);
      void set_base (in UseCase new_value)
         raises (Reflective::MofError);
      UseCase extension ()
         raises (Reflective::MofError);
      void set_extension (in UseCase new_value)
         raises (Reflective::MofError);
      ExtensionPointUList extension_point ()
         raises (Reflective::MofError);
      void set_extension_point (in ExtensionPointUList new_value)
         raises (Reflective::MofError);
      void add_extension_point (in ExtensionPoint new_element)
         raises (Reflective::MofError);
      void add_extension_point_before (
         in ExtensionPoint new_element,
         in ExtensionPoint before_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_extension_point (
         in ExtensionPoint old_element,
         in ExtensionPoint new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_extension_point (in ExtensionPoint old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Extend

   interface IncludeClass : Core::RelationshipClass
   {
      readonly attribute IncludeSet all_of_type_include;
      readonly attribute IncludeSet all_of_class_include;
      Include create_include (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface Include : IncludeClass, Core::Relationship
   {
      UseCase addition ()
         raises (Reflective::MofError);
      void set_addition (in UseCase new_value)
         raises (Reflective::MofError);
      UseCase base ()
         raises (Reflective::MofError);
      void set_base (in UseCase new_value)
         raises (Reflective::MofError);
   }; // end of interface Include

   interface ExtensionPointClass : Core::ModelElementClass
   {
      readonly attribute ExtensionPointSet all_of_type_extension_point;
      readonly attribute ExtensionPointSet all_of_class_extension_point;
      ExtensionPoint create_extension_point (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in DataTypes::LocationReference location)
         raises (Reflective::MofError);
   };

   interface ExtensionPoint : ExtensionPointClass, Core::ModelElement
   {
      DataTypes::LocationReference location ()
         raises (Reflective::MofError);
      void set_location (in DataTypes::LocationReference new_value)
         raises (Reflective::MofError);
      UseCase use_case ()
         raises (Reflective::MofError);
      void set_use_case (in UseCase new_value)
         raises (Reflective::MofError);
   }; // end of interface ExtensionPoint

   struct ABaseExtenderLink
   {
      UseCase base;
      Extend extender;
   };
   typedef sequence<ABaseExtenderLink> ABaseExtenderLinkSet;

   interface ABaseExtender : Reflective::RefAssociation
   {
      ABaseExtenderLinkSet all_a_base_extender_links()
         raises (Reflective::MofError);
      boolean exists (
         in UseCase base,
         in Extend extender)
         raises (Reflective::MofError);
      UseCase base (in Extend extender)
         raises (Reflective::MofError);
      ExtendSet extender (in UseCase base)
         raises (Reflective::MofError);
      void add (
         in UseCase base,
         in Extend extender)
         raises (Reflective::MofError);
      void modify_base (
         in UseCase base,
         in Extend extender,
         in UseCase new_base)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_extender (
         in UseCase base,
         in Extend extender,
         in Extend new_extender)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in UseCase base,
         in Extend extender)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ABaseExtender

   struct AExtensionExtendLink
   {
      UseCase extension;
      UseCases::Extend extend;
   };
   typedef sequence<AExtensionExtendLink> AExtensionExtendLinkSet;

   interface AExtensionExtend : Reflective::RefAssociation
   {
      AExtensionExtendLinkSet all_a_extension_extend_links()
         raises (Reflective::MofError);
      boolean exists (
         in UseCase extension,
         in UseCases::Extend extend)
         raises (Reflective::MofError);
      UseCase extension (in UseCases::Extend extend)
         raises (Reflective::MofError);
      ExtendSet extend (in UseCase extension)
         raises (Reflective::MofError);
      void add (
         in UseCase extension,
         in UseCases::Extend extend)
         raises (Reflective::MofError);
      void modify_extension (
         in UseCase extension,
         in UseCases::Extend extend,
         in UseCase new_extension)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_extend (
         in UseCase extension,
         in UseCases::Extend extend,
         in UseCases::Extend new_extend)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in UseCase extension,
         in UseCases::Extend extend)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AExtensionExtend

   struct AIncluderAdditionLink
   {
      Include includer;
      UseCase addition;
   };
   typedef sequence<AIncluderAdditionLink> AIncluderAdditionLinkSet;

   interface AIncluderAddition : Reflective::RefAssociation
   {
      AIncluderAdditionLinkSet all_a_includer_addition_links()
         raises (Reflective::MofError);
      boolean exists (
         in Include includer,
         in UseCase addition)
         raises (Reflective::MofError);
      IncludeSet includer (in UseCase addition)
         raises (Reflective::MofError);
      UseCase addition (in Include includer)
         raises (Reflective::MofError);
      void add (
         in Include includer,
         in UseCase addition)
         raises (Reflective::MofError);
      void modify_includer (
         in Include includer,
         in UseCase addition,
         in Include new_includer)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_addition (
         in Include includer,
         in UseCase addition,
         in UseCase new_addition)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Include includer,
         in UseCase addition)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AIncluderAddition

   struct AIncludeBaseLink
   {
      UseCases::Include include;
      UseCase base;
   };
   typedef sequence<AIncludeBaseLink> AIncludeBaseLinkSet;

   interface AIncludeBase : Reflective::RefAssociation
   {
      AIncludeBaseLinkSet all_a_include_base_links()
         raises (Reflective::MofError);
      boolean exists (
         in UseCases::Include include,
         in UseCase base)
         raises (Reflective::MofError);
      IncludeSet include (in UseCase base)
         raises (Reflective::MofError);
      UseCase base (in UseCases::Include include)
         raises (Reflective::MofError);
      void add (
         in UseCases::Include include,
         in UseCase base)
         raises (Reflective::MofError);
      void modify_include (
         in UseCases::Include include,
         in UseCase base,
         in UseCases::Include new_include)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_base (
         in UseCases::Include include,
         in UseCase base,
         in UseCase new_base)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in UseCases::Include include,
         in UseCase base)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AIncludeBase

   struct AExtensionPointUseCaseLink
   {
      ExtensionPoint extension_point;
      UseCase use_case;
   };
   typedef sequence<AExtensionPointUseCaseLink> AExtensionPointUseCaseLinkSet;

   interface AExtensionPointUseCase : Reflective::RefAssociation
   {
      AExtensionPointUseCaseLinkSet all_a_extension_point_use_case_links()
         raises (Reflective::MofError);
      boolean exists (
         in ExtensionPoint extension_point,
         in UseCase use_case)
         raises (Reflective::MofError);
      ExtensionPointSet extension_point (in UseCase use_case)
         raises (Reflective::MofError);
      UseCase use_case (in ExtensionPoint extension_point)
         raises (Reflective::MofError);
      void add (
         in ExtensionPoint extension_point,
         in UseCase use_case)
         raises (Reflective::MofError);
      void modify_extension_point (
         in ExtensionPoint extension_point,
         in UseCase use_case,
         in ExtensionPoint new_extension_point)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_use_case (
         in ExtensionPoint extension_point,
         in UseCase use_case,
         in UseCase new_use_case)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ExtensionPoint extension_point,
         in UseCase use_case)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AExtensionPointUseCase

   struct AExtensionPointExtendLink
   {
      ExtensionPoint extension_point;
      UseCases::Extend extend;
   };
   typedef sequence<AExtensionPointExtendLink> AExtensionPointExtendLinkSet;

   interface AExtensionPointExtend : Reflective::RefAssociation
   {
      AExtensionPointExtendLinkSet all_a_extension_point_extend_links()
         raises (Reflective::MofError);
      boolean exists (
         in ExtensionPoint extension_point,
         in UseCases::Extend extend)
         raises (Reflective::MofError);
      ExtensionPointUList extension_point (in UseCases::Extend extend)
         raises (Reflective::MofError);
      ExtendSet extend (in ExtensionPoint extension_point)
         raises (Reflective::MofError);
      void add (
         in ExtensionPoint extension_point,
         in UseCases::Extend extend)
         raises (Reflective::MofError);
      void add_before_extension_point (
         in ExtensionPoint extension_point,
         in UseCases::Extend extend,
         in ExtensionPoint before)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_extension_point (
         in ExtensionPoint extension_point,
         in UseCases::Extend extend,
         in ExtensionPoint new_extension_point)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_extend (
         in ExtensionPoint extension_point,
         in UseCases::Extend extend,
         in UseCases::Extend new_extend)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ExtensionPoint extension_point,
         in UseCases::Extend extend)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AExtensionPointExtend

   interface UseCasesPackageFactory
   {
      UseCasesPackage create_use_cases_package ()
         raises (Reflective::MofError);
   };

   interface UseCasesPackage : Reflective::RefPackage
   {
      readonly attribute DataTypes::DataTypesPackage data_types_ref;
      readonly attribute Core::CorePackage core_ref;
      readonly attribute CommonBehavior::CommonBehaviorPackage common_behavior_ref;
      readonly attribute UseCaseClass use_case_ref;
      readonly attribute ActorClass actor_ref;
      readonly attribute UseCaseInstanceClass use_case_instance_ref;
      readonly attribute ExtendClass extend_ref;
      readonly attribute IncludeClass include_ref;
      readonly attribute ExtensionPointClass extension_point_ref;
      readonly attribute ABaseExtender a_base_extender_ref;
      readonly attribute AExtensionExtend a_extension_extend_ref;
      readonly attribute AIncluderAddition a_includer_addition_ref;
      readonly attribute AIncludeBase a_include_base_ref;
      readonly attribute AExtensionPointUseCase a_extension_point_use_case_ref;
      readonly attribute AExtensionPointExtend a_extension_point_extend_ref;
   };
};

#endif