// This file contains the OMG IDL module for the BaseIDL MOF Repository.
//
// Editor: Dr. Philippe Merle - LIFL & INRIA

#pragma prefix "ccm.omg.org"
#include "Reflective.idl"

module BaseIDL
{
   interface TypedClass;
   interface Typed;
   typedef sequence<Typed> TypedSet;
   interface ParameterDefClass;
   interface ParameterDef;
   typedef sequence<ParameterDef> ParameterDefSet;
   interface ContainedClass;
   interface Contained;
   typedef sequence<Contained> ContainedSet;
   interface ConstantDefClass;
   interface ConstantDef;
   typedef sequence<ConstantDef> ConstantDefSet;
   interface ContainerClass;
   interface Container;
   typedef sequence<Container> ContainerSet;
   interface ModuleDefClass;
   interface ModuleDef;
   typedef sequence<ModuleDef> ModuleDefSet;
   interface IDLTypeClass;
   interface IDLType;
   typedef sequence<IDLType> IDLTypeSet;
   interface TypedefDefClass;
   interface TypedefDef;
   typedef sequence<TypedefDef> TypedefDefSet;
   interface InterfaceDefClass;
   interface InterfaceDef;
   typedef sequence<InterfaceDef> InterfaceDefSet;
   interface FieldClass;
   interface Field;
   typedef sequence<Field> FieldSet;
   interface StructDefClass;
   interface StructDef;
   typedef sequence<StructDef> StructDefSet;
   interface UnionDefClass;
   interface UnionDef;
   typedef sequence<UnionDef> UnionDefSet;
   interface EnumDefClass;
   interface EnumDef;
   typedef sequence<EnumDef> EnumDefSet;
   interface AliasDefClass;
   interface AliasDef;
   typedef sequence<AliasDef> AliasDefSet;
   interface StringDefClass;
   interface StringDef;
   typedef sequence<StringDef> StringDefSet;
   interface WstringDefClass;
   interface WstringDef;
   typedef sequence<WstringDef> WstringDefSet;
   interface FixedDefClass;
   interface FixedDef;
   typedef sequence<FixedDef> FixedDefSet;
   interface SequenceDefClass;
   interface SequenceDef;
   typedef sequence<SequenceDef> SequenceDefSet;
   interface ArrayDefClass;
   interface ArrayDef;
   typedef sequence<ArrayDef> ArrayDefSet;
   interface PrimitiveDefClass;
   interface PrimitiveDef;
   typedef sequence<PrimitiveDef> PrimitiveDefSet;
   interface UnionFieldClass;
   interface UnionField;
   typedef sequence<UnionField> UnionFieldSet;
   interface ValueMemberDefClass;
   interface ValueMemberDef;
   typedef sequence<ValueMemberDef> ValueMemberDefSet;
   interface ValueDefClass;
   interface ValueDef;
   typedef sequence<ValueDef> ValueDefSet;
   interface ValueBoxDefClass;
   interface ValueBoxDef;
   typedef sequence<ValueBoxDef> ValueBoxDefSet;
   interface OperationDefClass;
   interface OperationDef;
   typedef sequence<OperationDef> OperationDefSet;
   interface ExceptionDefClass;
   interface ExceptionDef;
   typedef sequence<ExceptionDef> ExceptionDefSet;
   interface AttributeDefClass;
   interface AttributeDef;
   typedef sequence<AttributeDef> AttributeDefSet;
   interface BaseIDLPackage;
   enum PrimitiveKind {PK_NULL,  PK_VOID, PK_SHORT,  PK_LONG,  PK_USHORT, PK_ULONG, PK_FLOAT, PK_DOUBLE, PK_BOOLEAN, PK_CHAR, PK_OCTET, PK_ANY, PK_LONGDOUBLE,  PK_WSTRING, PK_TYPECODE, PK_WCHAR, PK_PRINCIPAL, PK_STRING, PK_ULONGLONG, PK_OBJREF,  PK_LONGLONG};
   enum ParameterMode {PARAM_IN,  PARAM_OUT, PARAM_INOUT};
   enum DefinitionKind {DK_NONE, DK_ALL, DK_ATTRIBUTE, DK_CONSTANT, DK_EXCEPTION, DK_INTERFACE, DK_MODULE, DK_OPERATION, DK_TYPEDEF, DK_ALIAS, DK_STRUCT, DK_UNION,  DK_FIXED, DK_ENUM, DK_PRIMITIVE, DK_STRING, DK_SEQUENCE, DK_WSTRING, DK_ARRAY, DK_REPOSITORY};

   interface TypedClass : Reflective::RefObject
   {
      readonly attribute TypedSet all_of_type_typed;
   };

   interface Typed : TypedClass
   {
      IDLType idl_type ()
         raises (Reflective::MofError);
      void set_idl_type (in IDLType new_value)
         raises (Reflective::MofError);
   }; // end of interface Typed

   interface ParameterDefClass : TypedClass
   {
      readonly attribute ParameterDefSet all_of_type_parameter_def;
      readonly attribute ParameterDefSet all_of_class_parameter_def;
      ParameterDef create_parameter_def (
         in string identifier,
         in ParameterMode direction)
         raises (Reflective::MofError);
   };

   interface ParameterDef : ParameterDefClass, Typed
   {
      string identifier ()
         raises (Reflective::MofError);
      void set_identifier (in string new_value)
         raises (Reflective::MofError);
      ParameterMode direction ()
         raises (Reflective::MofError);
      void set_direction (in ParameterMode new_value)
         raises (Reflective::MofError);
   }; // end of interface ParameterDef

   interface ContainedClass : Reflective::RefObject
   {
      readonly attribute ContainedSet all_of_type_contained;
   };

   interface Contained : ContainedClass
   {
      Container defined_in ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_defined_in (in Container new_value)
         raises (Reflective::MofError);
      void unset_defined_in ()
         raises (Reflective::MofError);
      string identifier ()
         raises (Reflective::MofError);
      void set_identifier (in string new_value)
         raises (Reflective::MofError);
      string repository_id ()
         raises (Reflective::MofError);
      void set_repository_id (in string new_value)
         raises (Reflective::MofError);
      string version ()
         raises (Reflective::MofError);
      void set_version (in string new_value)
         raises (Reflective::MofError);
      string absolute_name ()
         raises (Reflective::MofError);
   }; // end of interface Contained

   interface ConstantDefClass : TypedClass, ContainedClass
   {
      readonly attribute ConstantDefSet all_of_type_constant_def;
      readonly attribute ConstantDefSet all_of_class_constant_def;
      ConstantDef create_constant_def (
         in string identifier,
         in string repository_id,
         in string version,
         in any const_value)
         raises (Reflective::MofError);
   };

   interface ConstantDef : ConstantDefClass, Typed, Contained
   {
      any const_value ()
         raises (Reflective::MofError);
      void set_const_value (in any new_value)
         raises (Reflective::MofError);
   }; // end of interface ConstantDef

   interface ContainerClass : ContainedClass
   {
      readonly attribute ContainerSet all_of_type_container;
   };

   interface Container : ContainerClass, Contained
   {
      ContainedSet contents ()
         raises (Reflective::MofError);
      void set_contents (in ContainedSet new_value)
         raises (Reflective::MofError);
      void unset_contents ()
         raises (Reflective::MofError);
      void add_contents (in Contained new_element)
         raises (Reflective::MofError);
      void modify_contents (
         in Contained old_element,
         in Contained new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_contents (in Contained old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      Contained lookup_name(
         in string search_name,
         in long levels_to_search,
         in DefinitionKind limit_to_type,
         in boolean exclude_inherited)
         raises (Reflective::MofError);
      Contained lookup(
         in string search_name)
         raises (Reflective::MofError);
      Contained get_filtered_contents(
         in DefinitionKind limit_to_type,
         in boolean include_inherited)
         raises (Reflective::MofError);
   }; // end of interface Container

   interface ModuleDefClass : ContainerClass
   {
      readonly attribute ModuleDefSet all_of_type_module_def;
      readonly attribute ModuleDefSet all_of_class_module_def;
      ModuleDef create_module_def (
         in string identifier,
         in string repository_id,
         in string version,
         in string prefix)
         raises (Reflective::MofError);
   };

   interface ModuleDef : ModuleDefClass, Container
   {
      string prefix ()
         raises (Reflective::MofError);
      void set_prefix (in string new_value)
         raises (Reflective::MofError);
   }; // end of interface ModuleDef

   interface IDLTypeClass : Reflective::RefObject
   {
      readonly attribute IDLTypeSet all_of_type_idltype;
   };

   interface IDLType : IDLTypeClass
   {
      CORBA::TypeCode type_code ()
         raises (Reflective::MofError);
   }; // end of interface IDLType

   interface TypedefDefClass : IDLTypeClass, ContainedClass
   {
      readonly attribute TypedefDefSet all_of_type_typedef_def;
   };

   interface TypedefDef : TypedefDefClass, IDLType, Contained
   {
   }; // end of interface TypedefDef

   interface InterfaceDefClass : IDLTypeClass, ContainerClass
   {
      readonly attribute InterfaceDefSet all_of_type_interface_def;
      readonly attribute InterfaceDefSet all_of_class_interface_def;
      InterfaceDef create_interface_def (
         in string identifier,
         in string repository_id,
         in string version,
         in boolean is_abstract,
         in boolean is_local)
         raises (Reflective::MofError);
   };

   interface InterfaceDef : InterfaceDefClass, IDLType, Container
   {
      InterfaceDefSet base ()
         raises (Reflective::MofError);
      void set_base (in InterfaceDefSet new_value)
         raises (Reflective::MofError);
      void unset_base ()
         raises (Reflective::MofError);
      void add_base (in InterfaceDef new_element)
         raises (Reflective::MofError);
      void modify_base (
        in InterfaceDef old_element,
        in InterfaceDef new_element)
        raises (Reflective::NotFound, Reflective::MofError);
      void remove_base (in InterfaceDef old_element)
        raises (Reflective::NotFound, Reflective::MofError);
      boolean is_abstract ()
        raises (Reflective::MofError);
      void set_is_abstract (in boolean new_value)
         raises (Reflective::MofError);
      boolean is_local ()
         raises (Reflective::MofError);
      void set_is_local (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface InterfaceDef

   interface FieldClass : TypedClass
   {
      readonly attribute FieldSet all_of_type_field;
      readonly attribute FieldSet all_of_class_field;
      Field create_field (
         in string identifier)
         raises (Reflective::MofError);
   };

   interface Field : FieldClass, Typed
   {
      string identifier ()
         raises (Reflective::MofError);
      void set_identifier (in string new_value)
         raises (Reflective::MofError);
   }; // end of interface Field

   interface StructDefClass : TypedefDefClass
   {
      readonly attribute StructDefSet all_of_type_struct_def;
      readonly attribute StructDefSet all_of_class_struct_def;
      StructDef create_struct_def (
         in string identifier,
         in string repository_id,
         in string version,
         in Field members)
         raises (Reflective::MofError);
   };

   interface StructDef : StructDefClass, TypedefDef
   {
      Field members ()
         raises (Reflective::MofError);
      void set_members (in Field new_value)
         raises (Reflective::MofError);
   }; // end of interface StructDef

   interface UnionDefClass : TypedefDefClass
   {
      readonly attribute UnionDefSet all_of_type_union_def;
      readonly attribute UnionDefSet all_of_class_union_def;
      UnionDef create_union_def (
         in string identifier,
         in string repository_id,
         in string version,
         in UnionField union_members)
         raises (Reflective::MofError);
   };

   interface UnionDef : UnionDefClass, TypedefDef
   {
      IDLType discriminator_type ()
         raises (Reflective::MofError);
      void set_discriminator_type (in IDLType new_value)
         raises (Reflective::MofError);
      UnionField union_members ()
         raises (Reflective::MofError);
      void set_union_members (in UnionField new_value)
         raises (Reflective::MofError);
   }; // end of interface UnionDef

   interface EnumDefClass : TypedefDefClass
   {
      readonly attribute EnumDefSet all_of_type_enum_def;
      readonly attribute EnumDefSet all_of_class_enum_def;
      EnumDef create_enum_def (
         in string identifier,
         in string repository_id,
         in string version,
         in string members)
         raises (Reflective::MofError);
   };

   interface EnumDef : EnumDefClass, TypedefDef
   {
      string members ()
         raises (Reflective::MofError);
      void set_members (in string new_value)
         raises (Reflective::MofError);
   }; // end of interface EnumDef

   interface AliasDefClass : TypedefDefClass, TypedClass
   {
      readonly attribute AliasDefSet all_of_type_alias_def;
      readonly attribute AliasDefSet all_of_class_alias_def;
      AliasDef create_alias_def (
         in string identifier,
         in string repository_id,
         in string version)
         raises (Reflective::MofError);
   };

   interface AliasDef : AliasDefClass, TypedefDef, Typed
   {
   }; // end of interface AliasDef

   interface StringDefClass : IDLTypeClass
   {
      readonly attribute StringDefSet all_of_type_string_def;
      readonly attribute StringDefSet all_of_class_string_def;
      StringDef create_string_def (
         in unsigned long bound)
         raises (Reflective::MofError);
   };

   interface StringDef : StringDefClass, IDLType
   {
      unsigned long bound ()
         raises (Reflective::MofError);
      void set_bound (in unsigned long new_value)
         raises (Reflective::MofError);
   }; // end of interface StringDef

   interface WstringDefClass : IDLTypeClass
   {
      readonly attribute WstringDefSet all_of_type_wstring_def;
      readonly attribute WstringDefSet all_of_class_wstring_def;
      WstringDef create_wstring_def (
         in unsigned long bound)
         raises (Reflective::MofError);
   };

   interface WstringDef : WstringDefClass, IDLType
   {
      unsigned long bound ()
         raises (Reflective::MofError);
      void set_bound (in unsigned long new_value)
         raises (Reflective::MofError);
   }; // end of interface WstringDef

   interface FixedDefClass : IDLTypeClass
   {
      readonly attribute FixedDefSet all_of_type_fixed_def;
      readonly attribute FixedDefSet all_of_class_fixed_def;
      FixedDef create_fixed_def (
         in unsigned short digits,
         in short scale)
         raises (Reflective::MofError);
   };

   interface FixedDef : FixedDefClass, IDLType
   {
      unsigned short digits ()
         raises (Reflective::MofError);
      void set_digits (in unsigned short new_value)
         raises (Reflective::MofError);
      short scale ()
         raises (Reflective::MofError);
      void set_scale (in short new_value)
         raises (Reflective::MofError);
   }; // end of interface FixedDef

   interface SequenceDefClass : TypedClass, IDLTypeClass
   {
      readonly attribute SequenceDefSet all_of_type_sequence_def;
      readonly attribute SequenceDefSet all_of_class_sequence_def;
      SequenceDef create_sequence_def (
         in unsigned long bound)
         raises (Reflective::MofError);
   };

   interface SequenceDef : SequenceDefClass, Typed, IDLType
   {
      unsigned long bound ()
         raises (Reflective::MofError);
      void set_bound (in unsigned long new_value)
         raises (Reflective::MofError);
   }; // end of interface SequenceDef

   interface ArrayDefClass : TypedClass, IDLTypeClass
   {
      readonly attribute ArrayDefSet all_of_type_array_def;
      readonly attribute ArrayDefSet all_of_class_array_def;
      ArrayDef create_array_def (
         in unsigned long bound)
         raises (Reflective::MofError);
   };

   interface ArrayDef : ArrayDefClass, Typed, IDLType
   {
      unsigned long bound ()
         raises (Reflective::MofError);
      void set_bound (in unsigned long new_value)
         raises (Reflective::MofError);
   }; // end of interface ArrayDef

   interface PrimitiveDefClass : IDLTypeClass
   {
      readonly attribute PrimitiveDefSet all_of_type_primitive_def;
      readonly attribute PrimitiveDefSet all_of_class_primitive_def;
      PrimitiveDef create_primitive_def (
         in PrimitiveKind kind)
         raises (Reflective::MofError);
   };

   interface PrimitiveDef : PrimitiveDefClass, IDLType
   {
      PrimitiveKind kind ()
         raises (Reflective::MofError);
      void set_kind (in PrimitiveKind new_value)
         raises (Reflective::MofError);
   }; // end of interface PrimitiveDef

   interface UnionFieldClass : TypedClass
   {
      readonly attribute UnionFieldSet all_of_type_union_field;
      readonly attribute UnionFieldSet all_of_class_union_field;
      UnionField create_union_field (
         in string identifier,
         in any label)
         raises (Reflective::MofError);
   };

   interface UnionField : UnionFieldClass, Typed
   {
      string identifier ()
         raises (Reflective::MofError);
      void set_identifier (in string new_value)
         raises (Reflective::MofError);
      any label ()
         raises (Reflective::MofError);
      void set_label (in any new_value)
         raises (Reflective::MofError);
   }; // end of interface UnionField

   interface ValueMemberDefClass : TypedClass, ContainedClass
   {
      readonly attribute ValueMemberDefSet all_of_type_value_member_def;
      readonly attribute ValueMemberDefSet all_of_class_value_member_def;
      ValueMemberDef create_value_member_def (
         in string identifier,
         in string repository_id,
         in string version,
         in boolean is_public_member)
         raises (Reflective::MofError);
   };

   interface ValueMemberDef : ValueMemberDefClass, Typed, Contained
   {
      boolean is_public_member ()
         raises (Reflective::MofError);
      void set_is_public_member (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface ValueMemberDef

   interface ValueDefClass : ContainerClass, IDLTypeClass
   {
      readonly attribute ValueDefSet all_of_type_value_def;
      readonly attribute ValueDefSet all_of_class_value_def;
      ValueDef create_value_def (
         in string identifier,
         in string repository_id,
         in string version,
         in boolean is_abstract,
         in boolean is_custom,
         in boolean is_truncatable)
         raises (Reflective::MofError);
   };

   interface ValueDef : ValueDefClass, Container, IDLType
   {
      InterfaceDef interface_def ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_interface_def (in InterfaceDef new_value)
         raises (Reflective::MofError);
      void unset_interface_def ()
         raises (Reflective::MofError);
      ValueDef base ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_base (in ValueDef new_value)
         raises (Reflective::MofError);
      void unset_base ()
         raises (Reflective::MofError);
      ValueDefSet abstract_base ()
         raises (Reflective::MofError);
      void set_abstract_base (in ValueDefSet new_value)
         raises (Reflective::MofError);
      void unset_abstract_base ()
         raises (Reflective::MofError);
      void add_abstract_base (in ValueDef new_element)
         raises (Reflective::MofError);
      void modify_abstract_base (
         in ValueDef old_element,
         in ValueDef new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_abstract_base (in ValueDef old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      boolean is_abstract ()
         raises (Reflective::MofError);
      void set_is_abstract (in boolean new_value)
         raises (Reflective::MofError);
      boolean is_custom ()
         raises (Reflective::MofError);
      void set_is_custom (in boolean new_value)
         raises (Reflective::MofError);
      boolean is_truncatable ()
         raises (Reflective::MofError);
      void set_is_truncatable (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface ValueDef

   interface ValueBoxDefClass : TypedefDefClass
   {
      readonly attribute ValueBoxDefSet all_of_type_value_box_def;
      readonly attribute ValueBoxDefSet all_of_class_value_box_def;
      ValueBoxDef create_value_box_def (
         in string identifier,
         in string repository_id,
         in string version)
         raises (Reflective::MofError);
   };

   interface ValueBoxDef : ValueBoxDefClass, TypedefDef
   {
   }; // end of interface ValueBoxDef

   interface OperationDefClass : TypedClass, ContainedClass
   {
      readonly attribute OperationDefSet all_of_type_operation_def;
      readonly attribute OperationDefSet all_of_class_operation_def;
      OperationDef create_operation_def (
         in string identifier,
         in string repository_id,
         in string version,
         in boolean is_oneway,
         in ParameterDef parameters,
         in string contexts)
         raises (Reflective::MofError);
   };

   interface OperationDef : OperationDefClass, Typed, Contained
   {
      ExceptionDefSet exception_def ()
         raises (Reflective::MofError);
      void set_exception_def (in ExceptionDefSet new_value)
         raises (Reflective::MofError);
      void unset_exception_def ()
         raises (Reflective::MofError);
      void add_exception_def (in ExceptionDef new_element)
         raises (Reflective::MofError);
      void modify_exception_def (
         in ExceptionDef old_element,
         in ExceptionDef new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_exception_def (in ExceptionDef old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      boolean is_oneway ()
         raises (Reflective::MofError);
      void set_is_oneway (in boolean new_value)
         raises (Reflective::MofError);
      ParameterDef parameters ()
         raises (Reflective::MofError);
      void set_parameters (in ParameterDef new_value)
         raises (Reflective::MofError);
      string contexts ()
         raises (Reflective::MofError);
      void set_contexts (in string new_value)
         raises (Reflective::MofError);
   }; // end of interface OperationDef

   interface ExceptionDefClass : ContainedClass
   {
      readonly attribute ExceptionDefSet all_of_type_exception_def;
      readonly attribute ExceptionDefSet all_of_class_exception_def;
      ExceptionDef create_exception_def (
         in string identifier,
         in string repository_id,
         in string version,
         in CORBA::TypeCode type_code,
         in Field members)
         raises (Reflective::MofError);
   };

   interface ExceptionDef : ExceptionDefClass, Contained
   {
      CORBA::TypeCode type_code ()
         raises (Reflective::MofError);
      Field members ()
         raises (Reflective::MofError);
      void set_members (in Field new_value)
         raises (Reflective::MofError);
   }; // end of interface ExceptionDef

   interface AttributeDefClass : TypedClass, ContainedClass
   {
      readonly attribute AttributeDefSet all_of_type_attribute_def;
      readonly attribute AttributeDefSet all_of_class_attribute_def;
      AttributeDef create_attribute_def (
         in string identifier,
         in string repository_id,
         in string version,
         in boolean is_readonly)
         raises (Reflective::MofError);
   };

   interface AttributeDef : AttributeDefClass, Typed, Contained
   {
      ExceptionDefSet set_exception ()
         raises (Reflective::MofError);
      void set_set_exception (in ExceptionDefSet new_value)
         raises (Reflective::MofError);
      void unset_set_exception ()
         raises (Reflective::MofError);
      void add_set_exception (in ExceptionDef new_element)
         raises (Reflective::MofError);
      void modify_set_exception (
         in ExceptionDef old_element,
         in ExceptionDef new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_set_exception (in ExceptionDef old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ExceptionDefSet get_exception ()
         raises (Reflective::MofError);
      void set_get_exception (in ExceptionDefSet new_value)
         raises (Reflective::MofError);
      void unset_get_exception ()
         raises (Reflective::MofError);
      void add_get_exception (in ExceptionDef new_element)
         raises (Reflective::MofError);
      void modify_get_exception (
         in ExceptionDef old_element,
         in ExceptionDef new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_get_exception (in ExceptionDef old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      boolean is_readonly ()
         raises (Reflective::MofError);
      void set_is_readonly (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface AttributeDef

   struct InterfaceDerivedFromLink
   {
      InterfaceDef base;
      InterfaceDef derived;
   };
   typedef sequence<InterfaceDerivedFromLink> InterfaceDerivedFromLinkSet;

   interface InterfaceDerivedFrom : Reflective::RefAssociation
   {
      InterfaceDerivedFromLinkSet all_interface_derived_from_links()
         raises (Reflective::MofError);
      boolean exists (
         in InterfaceDef base,
         in InterfaceDef derived)
         raises (Reflective::MofError);
      InterfaceDefSet base (in InterfaceDef derived)
         raises (Reflective::MofError);
      void add (
         in InterfaceDef base,
         in InterfaceDef derived)
         raises (Reflective::MofError);
      void modify_base (
         in InterfaceDef base,
         in InterfaceDef derived,
         in InterfaceDef new_base)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in InterfaceDef base,
         in InterfaceDef derived)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface InterfaceDerivedFrom

   struct DiscriminatedByLink
   {
      IDLType discriminator_type;
      UnionDef union_def;
   };
   typedef sequence<DiscriminatedByLink> DiscriminatedByLinkSet;

   interface DiscriminatedBy : Reflective::RefAssociation
   {
      DiscriminatedByLinkSet all_discriminated_by_links()
         raises (Reflective::MofError);
      boolean exists (
         in IDLType discriminator_type,
         in UnionDef union_def)
         raises (Reflective::MofError);
      IDLType discriminator_type (in UnionDef union_def)
         raises (Reflective::MofError);
      void add (
         in IDLType discriminator_type,
         in UnionDef union_def)
         raises (Reflective::MofError);
      void modify_discriminator_type (
         in IDLType discriminator_type,
         in UnionDef union_def,
         in IDLType new_discriminator_type)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in IDLType discriminator_type,
         in UnionDef union_def)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface DiscriminatedBy

   struct TypedByLink
   {
      IDLType idl_type;
      BaseIDL::Typed typed;
   };
   typedef sequence<TypedByLink> TypedByLinkSet;

   interface TypedBy : Reflective::RefAssociation
   {
      TypedByLinkSet all_typed_by_links()
         raises (Reflective::MofError);
      boolean exists (
         in IDLType idl_type,
         in BaseIDL::Typed typed)
         raises (Reflective::MofError);
      IDLType idl_type (in BaseIDL::Typed typed)
         raises (Reflective::MofError);
      void add (
         in IDLType idl_type,
         in BaseIDL::Typed typed)
         raises (Reflective::MofError);
      void modify_idl_type (
         in IDLType idl_type,
         in BaseIDL::Typed typed,
         in IDLType new_idl_type)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in IDLType idl_type,
         in BaseIDL::Typed typed)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface TypedBy

   struct SupportsLink
   {
      InterfaceDef interface_def;
      ValueDef value_def;
   };
   typedef sequence<SupportsLink> SupportsLinkSet;

   interface Supports : Reflective::RefAssociation
   {
      SupportsLinkSet all_supports_links()
         raises (Reflective::MofError);
      boolean exists (
         in InterfaceDef interface_def,
         in ValueDef value_def)
         raises (Reflective::MofError);
      InterfaceDef interface_def (in ValueDef value_def)
         raises (Reflective::MofError);
      void add (
         in InterfaceDef interface_def,
         in ValueDef value_def)
         raises (Reflective::MofError);
      void modify_interface_def (
         in InterfaceDef interface_def,
         in ValueDef value_def,
         in InterfaceDef new_interface_def)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in InterfaceDef interface_def,
         in ValueDef value_def)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Supports

   struct ValueDerivedFromLink
   {
      ValueDef base;
      ValueDef derived;
   };
   typedef sequence<ValueDerivedFromLink> ValueDerivedFromLinkSet;

   interface ValueDerivedFrom : Reflective::RefAssociation
   {
      ValueDerivedFromLinkSet all_value_derived_from_links()
         raises (Reflective::MofError);
      boolean exists (
         in ValueDef base,
         in ValueDef derived)
         raises (Reflective::MofError);
      ValueDef base (in ValueDef derived)
         raises (Reflective::MofError);
      void add (
         in ValueDef base,
         in ValueDef derived)
         raises (Reflective::MofError);
      void modify_base (
         in ValueDef base,
         in ValueDef derived,
         in ValueDef new_base)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ValueDef base,
         in ValueDef derived)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ValueDerivedFrom

   struct AbstractDerivedFromLink
   {
      ValueDef abstract_derived;
      ValueDef abstract_base;
   };
   typedef sequence<AbstractDerivedFromLink> AbstractDerivedFromLinkSet;

   interface AbstractDerivedFrom : Reflective::RefAssociation
   {
      AbstractDerivedFromLinkSet all_abstract_derived_from_links()
         raises (Reflective::MofError);
      boolean exists (
         in ValueDef abstract_derived,
         in ValueDef abstract_base)
         raises (Reflective::MofError);
      ValueDefSet abstract_base (in ValueDef abstract_derived)
         raises (Reflective::MofError);
      void add (
         in ValueDef abstract_derived,
         in ValueDef abstract_base)
         raises (Reflective::MofError);
      void modify_abstract_base (
         in ValueDef abstract_derived,
         in ValueDef abstract_base,
         in ValueDef new_abstract_base)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ValueDef abstract_derived,
         in ValueDef abstract_base)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface AbstractDerivedFrom

   struct SetRaisesLink
   {
      ExceptionDef set_exception;
      AttributeDef set_attribute;
   };
   typedef sequence<SetRaisesLink> SetRaisesLinkSet;

   interface SetRaises : Reflective::RefAssociation
   {
      SetRaisesLinkSet all_set_raises_links()
         raises (Reflective::MofError);
      boolean exists (
         in ExceptionDef set_exception,
         in AttributeDef set_attribute)
         raises (Reflective::MofError);
      ExceptionDefSet set_exception (in AttributeDef set_attribute)
         raises (Reflective::MofError);
      void add (
         in ExceptionDef set_exception,
         in AttributeDef set_attribute)
         raises (Reflective::MofError);
      void modify_set_exception (
         in ExceptionDef set_exception,
         in AttributeDef set_attribute,
         in ExceptionDef new_set_exception)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ExceptionDef set_exception,
         in AttributeDef set_attribute)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface SetRaises

   struct CanRaiseLink
   {
      ExceptionDef exception_def;
      OperationDef operation_def;
   };
   typedef sequence<CanRaiseLink> CanRaiseLinkSet;

   interface CanRaise : Reflective::RefAssociation
   {
      CanRaiseLinkSet all_can_raise_links()
         raises (Reflective::MofError);
      boolean exists (
         in ExceptionDef exception_def,
         in OperationDef operation_def)
         raises (Reflective::MofError);
      ExceptionDefSet exception_def (in OperationDef operation_def)
         raises (Reflective::MofError);
      void add (
         in ExceptionDef exception_def,
         in OperationDef operation_def)
         raises (Reflective::MofError);
      void modify_exception_def (
         in ExceptionDef exception_def,
         in OperationDef operation_def,
         in ExceptionDef new_exception_def)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ExceptionDef exception_def,
         in OperationDef operation_def)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface CanRaise

   struct GetRaisesLink
   {
      ExceptionDef get_exception;
      AttributeDef get_attribute;
   };
   typedef sequence<GetRaisesLink> GetRaisesLinkSet;

   interface GetRaises : Reflective::RefAssociation
   {
      GetRaisesLinkSet all_get_raises_links()
         raises (Reflective::MofError);
      boolean exists (
         in ExceptionDef get_exception,
         in AttributeDef get_attribute)
         raises (Reflective::MofError);
      ExceptionDefSet get_exception (in AttributeDef get_attribute)
         raises (Reflective::MofError);
      void add (
         in ExceptionDef get_exception,
         in AttributeDef get_attribute)
         raises (Reflective::MofError);
      void modify_get_exception (
         in ExceptionDef get_exception,
         in AttributeDef get_attribute,
         in ExceptionDef new_get_exception)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ExceptionDef get_exception,
         in AttributeDef get_attribute)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface GetRaises

   struct ContainsLink
   {
      Container defined_in;
      Contained contents;
   };
   typedef sequence<ContainsLink> ContainsLinkSet;

   interface Contains : Reflective::RefAssociation
   {
      ContainsLinkSet all_contains_links()
         raises (Reflective::MofError);
      boolean exists (
         in Container defined_in,
         in Contained contents)
         raises (Reflective::MofError);
      Container defined_in (in Contained contents)
         raises (Reflective::MofError);
      ContainedSet contents (in Container defined_in)
         raises (Reflective::MofError);
      void add (
         in Container defined_in,
         in Contained contents)
         raises (Reflective::MofError);
      void modify_defined_in (
         in Container defined_in,
         in Contained contents,
         in Container new_defined_in)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_contents (
         in Container defined_in,
         in Contained contents,
         in Contained new_contents)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in Container defined_in,
         in Contained contents)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface Contains

   interface BaseIDLPackageFactory
   {
      BaseIDLPackage create_base_idl_package ()
         raises (Reflective::MofError);
   };

   interface BaseIDLPackage : Reflective::RefPackage
   {
      readonly attribute TypedClass typed_ref;
      readonly attribute ParameterDefClass parameter_def_ref;
      readonly attribute ContainedClass contained_ref;
      readonly attribute ConstantDefClass constant_def_ref;
      readonly attribute ContainerClass container_ref;
      readonly attribute ModuleDefClass module_def_ref;
      readonly attribute IDLTypeClass idltype_ref;
      readonly attribute TypedefDefClass typedef_def_ref;
      readonly attribute InterfaceDefClass interface_def_ref;
      readonly attribute FieldClass field_ref;
      readonly attribute StructDefClass struct_def_ref;
      readonly attribute UnionDefClass union_def_ref;
      readonly attribute EnumDefClass enum_def_ref;
      readonly attribute AliasDefClass alias_def_ref;
      readonly attribute StringDefClass string_def_ref;
      readonly attribute WstringDefClass wstring_def_ref;
      readonly attribute FixedDefClass fixed_def_ref;
      readonly attribute SequenceDefClass sequence_def_ref;
      readonly attribute ArrayDefClass array_def_ref;
      readonly attribute PrimitiveDefClass primitive_def_ref;
      readonly attribute UnionFieldClass union_field_ref;
      readonly attribute ValueMemberDefClass value_member_def_ref;
      readonly attribute ValueDefClass value_def_ref;
      readonly attribute ValueBoxDefClass value_box_def_ref;
      readonly attribute OperationDefClass operation_def_ref;
      readonly attribute ExceptionDefClass exception_def_ref;
      readonly attribute AttributeDefClass attribute_def_ref;
      readonly attribute InterfaceDerivedFrom interface_derived_from_ref;
      readonly attribute DiscriminatedBy discriminated_by_ref;
      readonly attribute TypedBy typed_by_ref;
      readonly attribute Supports supports_ref;
      readonly attribute ValueDerivedFrom value_derived_from_ref;
      readonly attribute AbstractDerivedFrom abstract_derived_from_ref;
      readonly attribute SetRaises set_raises_ref;
      readonly attribute CanRaise can_raise_ref;
      readonly attribute GetRaises get_raises_ref;
      readonly attribute Contains contains_ref;
   };
}; // end of module BaseIDL