#ifndef MODEL_MANAGEMENT_IDL
#define MODEL_MANAGEMENT_IDL
#pragma prefix "org.omg.uml"
#include "Reflective.idl"
#include "Core.idl"
#include "DataTypes.idl"

module ModelManagement
{
   interface PackageClass;
   interface Package;
   typedef sequence<Package> PackageSet;
   interface ModelClass;
   interface Model;
   typedef sequence<Model> ModelSet;
   interface SubsystemClass;
   interface Subsystem;
   typedef sequence<Subsystem> SubsystemSet;
   interface ElementImportClass;
   interface ElementImport;
   typedef sequence<ElementImport> ElementImportSet;
   interface ModelManagementPackage;

   interface PackageClass : Core::GeneralizableElementClass, Core::NamespaceClass
   {
      readonly attribute PackageSet all_of_type_package;
      readonly attribute PackageSet all_of_class_package;
      Package create_package (
         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 Package : PackageClass, Core::GeneralizableElement, Core::Namespace
   {
      ElementImportSet element_import ()
         raises (Reflective::MofError);
      void set_element_import (in ElementImportSet new_value)
         raises (Reflective::MofError);
      void unset_element_import ()
         raises (Reflective::MofError);
      void add_element_import (in ElementImport new_element)
         raises (Reflective::MofError);
      void modify_element_import (
         in ElementImport old_element,
         in ElementImport new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_element_import (in ElementImport old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Package

   interface ModelClass : PackageClass
   {
      readonly attribute ModelSet all_of_type_model;
      readonly attribute ModelSet all_of_class_model;
      Model create_model (
         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 Model : ModelClass, Package
   {
   }; // end of interface Model

   interface SubsystemClass : PackageClass, Core::ClassifierClass
   {
      readonly attribute SubsystemSet all_of_type_subsystem;
      readonly attribute SubsystemSet all_of_class_subsystem;
      Subsystem create_subsystem (
         in DataTypes::Name name,
         in DataTypes::VisibilityKind visibility,
         in boolean is_specification,
         in boolean is_root,
         in boolean is_leaf,
         in boolean is_abstract,
         in boolean is_instantiable)
         raises (Reflective::MofError);
   };

   interface Subsystem : SubsystemClass, Package, Core::Classifier
   {
      boolean is_instantiable ()
         raises (Reflective::MofError);
      void set_is_instantiable (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface Subsystem

   interface ElementImportClass : Reflective::RefObject
   {
      readonly attribute ElementImportSet all_of_type_element_import;
      readonly attribute ElementImportSet all_of_class_element_import;
      ElementImport create_element_import (
         in DataTypes::VisibilityKind visibility,
         in DataTypes::Name alias,
         in boolean is_specification)
         raises (Reflective::MofError);
   };

   interface ElementImport : ElementImportClass
   {
      DataTypes::VisibilityKind visibility ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_visibility (in DataTypes::VisibilityKind new_value)
         raises (Reflective::MofError);
      void unset_visibility ()
         raises (Reflective::MofError);
      DataTypes::Name alias ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_alias (in DataTypes::Name new_value)
         raises (Reflective::MofError);
      void unset_alias ()
         raises (Reflective::MofError);
      boolean is_specification ()
         raises (Reflective::MofError);
      void set_is_specification (in boolean new_value)
         raises (Reflective::MofError);
      ModelManagement::Package package ()
         raises (Reflective::MofError);
      void set_package (in ModelManagement::Package new_value)
         raises (Reflective::MofError);
      Core::ModelElement imported_element ()
         raises (Reflective::MofError);
      void set_imported_element (in Core::ModelElement new_value)
         raises (Reflective::MofError);
   }; // end of interface ElementImport

   struct AImportedElementElementImportLink
   {
      Core::ModelElement imported_element;
      ElementImport element_import;
   };
   typedef sequence<AImportedElementElementImportLink> AImportedElementElementImportLinkSet;

   interface AImportedElementElementImport : Reflective::RefAssociation
   {
      AImportedElementElementImportLinkSet all_a_imported_element_element_import_links()
         raises (Reflective::MofError);
      boolean exists (
         in Core::ModelElement imported_element,
         in ElementImport element_import)
         raises (Reflective::MofError);
      Core::ModelElement imported_element (in ElementImport element_import)
         raises (Reflective::MofError);
      ElementImportSet element_import (in Core::ModelElement imported_element)
         raises (Reflective::MofError);
      void add (
         in Core::ModelElement imported_element,
         in ElementImport element_import)
         raises (Reflective::MofError);
      void modify_imported_element (
         in Core::ModelElement imported_element,
         in ElementImport element_import,
         in Core::ModelElement new_imported_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_element_import (
         in Core::ModelElement imported_element,
         in ElementImport element_import,
         in ElementImport new_element_import)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Core::ModelElement imported_element,
         in ElementImport element_import)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AImportedElementElementImport

   struct APackageElementImportLink
   {
      ModelManagement::Package package;
      ElementImport element_import;
   };
   typedef sequence<APackageElementImportLink> APackageElementImportLinkSet;

   interface APackageElementImport : Reflective::RefAssociation
   {
      APackageElementImportLinkSet all_a_package_element_import_links()
         raises (Reflective::MofError);
      boolean exists (
         in ModelManagement::Package package,
         in ElementImport element_import)
         raises (Reflective::MofError);
      ModelManagement::Package package (in ElementImport element_import)
         raises (Reflective::MofError);
      ElementImportSet element_import (in ModelManagement::Package package)
         raises (Reflective::MofError);
      void add (
         in ModelManagement::Package package,
         in ElementImport element_import)
         raises (Reflective::MofError);
      void modify_package (
         in ModelManagement::Package package,
         in ElementImport element_import,
         in ModelManagement::Package new_package)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_element_import (
         in ModelManagement::Package package,
         in ElementImport element_import,
         in ElementImport new_element_import)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ModelManagement::Package package,
         in ElementImport element_import)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface APackageElementImport

   interface ModelManagementPackageFactory
   {
      ModelManagementPackage create_model_management_package ()
         raises (Reflective::MofError);
   };

   interface ModelManagementPackage : Reflective::RefPackage
   {
      readonly attribute DataTypes::DataTypesPackage data_types_ref;
      readonly attribute Core::CorePackage core_ref;
      readonly attribute PackageClass package_ref;
      readonly attribute ModelClass model_ref;
      readonly attribute SubsystemClass subsystem_ref;
      readonly attribute ElementImportClass element_import_ref;
      readonly attribute AImportedElementElementImport a_imported_element_element_import_ref;
      readonly attribute APackageElementImport a_package_element_import_ref;
   };
};

#endif