//
// $Id$
//
// ================================================================
//
// = LIBRARY
//   IFR_Client
//
// = FILENAME
//   Interface.pidl
//
// = DESCRIPTION
//   This file was used to generate the code in InterfaceC.{h,i,cpp}.
//
//   The command used to generate code from this file is:
//
//     tao_idl -o orig -Ge 1 \
//          -Wb,export_macro=TAO_IFR_Client_Export \
//          -Wb,export_include=ifr_client_export.h \
//          -Wb,pre_include="ace/pre.h" \
//          -Wb,post_include="ace/post.h" \
//          Interface.pidl
//
//   after the file is generated a patch must be applied.  The patch
//   replaces qualified namespace scoping with flat names, since there
//   are at present two versions of Interface.idl, one where most of
//   the definitions are in the IR namespace and one where they are in
//   the CORBA namespace. Hopefully, the OMG will ultimately reconcile
//   the two versions, but until then we will be compliant with the
//   CORBA 2.x version, while leaving unchanged as much as possible
//   from the CCM (forthcoming CORBA 3.0) version. To that end, the
//   flat names are typedef'd in one or both namespaces.
//
//   Apply patches using the following commands:
//
//   patch < diffs/InterfaceC.h.diff
//   patch < diffs/InterfaceC.i.diff
//   patch < diffs/InterfaceC.cpp.diff
//
//   These patches are used to automate the above changes when the
//   code, which is part of the TAO library, must be regenerated because
//   of modifications to the output of the TAO IDL compiler.
//
//   Note: The diffs were generated with these commands:
//
//   diff -wbu orig/InterfaceC.h InterfaceC.h > diffs/InterfaceC.h.diff
//   diff -wbu orig/InterfaceC.i InterfaceC.i > diffs/InterfaceC.i.diff
//   diff -wbu orig/InterfaceC.cpp InterfaceC.cpp > diffs/InterfaceC.cpp.diff
//
//   To regenerate the skeleton files InterfaceS.{h,i,cpp} and 
//   InterfaceS_T.{h,i.cpp} in ACE_ROOT/TAO/orbsvcs/IFR_Service, use the 
//   command
//
//     tao_idl -o ../../orbsvcs/IFR_Service/orig -Ge 1 \
//          -Wb,pre_include="ace/pre.h" \
//          -Wb,post_include="ace/post.h" \
//          Interface.pidl
//
//   and the diff and patch commands change accordingly.
//
// ================================================================

#ifndef _INTERFACE_IDL_
#define _INTERFACE_IDL_
#pragma prefix "omg.org"

module IR 
{
  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_Enum,
    dk_Primitive, 
    dk_String, 
    dk_Sequence, 
    dk_Array,
    dk_Repository,
    dk_Wstring, 
    dk_Fixed,
    dk_Value, 
    dk_ValueBox, 
    dk_ValueMember,
    dk_Native

    // CORBA 2.x specific.

    ,dk_AbstractInterface
    ,dk_LocalInterface

    // CCM specific.

    ,dk_Component
    ,dk_Home
    ,dk_Factory
    ,dk_Finder
    ,dk_PrimaryKey
    ,dk_Emits 
    ,dk_Publishes
    ,dk_Consumes
    ,dk_Provides
    ,dk_Uses
  };
};

module CORBA
{
  typedef string Identifier;
  typedef string ScopedName;
  typedef string RepositoryId;  

  interface IRObject 
  {
    // read interface
    readonly attribute IR::DefinitionKind def_kind;
    // write interface
    void destroy ();
  };

  typedef short ValueModifier; // PIDL
  const ValueModifier VM_NONE = 0;
  const ValueModifier VM_CUSTOM = 1;
  const ValueModifier VM_ABSTRACT = 2;
  const ValueModifier VM_TRUNCATABLE = 3;

  typedef short Visibility;
  const Visibility PRIVATE_MEMBER = 0;
  const Visibility PUBLIC_MEMBER = 1;
};

module IR
{
  typedef string Identifier;
  typedef string ScopedName;
  typedef string RepositoryId;

  typedef string VersionSpec;

  interface Contained;
  interface Repository;
  interface Container;

  interface Contained : CORBA::IRObject 
  {
    // read/write interface
    attribute RepositoryId id;
    attribute Identifier name;
    attribute VersionSpec version;

    // read interface
    readonly attribute Container defined_in;
    readonly attribute ScopedName absolute_name;
    readonly attribute Repository containing_repository;

    struct Description 
    {
      DefinitionKind kind;
      any value;
    };

    Description describe ();

    // write interface
    void move (
        in Container new_container,
        in Identifier new_name,
        in VersionSpec new_version
      );
  };

  interface ModuleDef;
  interface ConstantDef;
  interface IDLType;
  interface StructDef;
  interface UnionDef;
  interface EnumDef;
  interface AliasDef;
  interface InterfaceDef;
  interface ExceptionDef;
  interface NativeDef;
  typedef sequence <InterfaceDef> InterfaceDefSeq;
  interface ValueDef;
  typedef sequence <ValueDef> ValueDefSeq;
  interface ValueBoxDef;
  typedef sequence <Contained> ContainedSeq;

  // CORBA 2.x specific.
  interface AbstractInterfaceDef;
  typedef sequence <AbstractInterfaceDef> AbstractInterfaceDefSeq;
  interface LocalInterfaceDef;
  typedef sequence <LocalInterfaceDef> LocalInterfaceDefSeq;
  
  // CCM specific.
  interface ComponentDef;
  typedef sequence <ComponentDef> ComponentDefSeq;
  interface ProvidesDef;
  typedef sequence <ProvidesDef> ProvidesDefSeq;
  interface UsesDef;
  typedef sequence <UsesDef> UsesDefSeq;
  interface HomeDef;
  typedef sequence <HomeDef> HomeDefSeq;
  interface EventDef;
  interface EmitsDef;
  typedef sequence <EmitsDef> EmitsDefSeq;
  interface PublishesDef;
  typedef sequence <PublishesDef> PublishesDefSeq;
  interface ConsumesDef;
  typedef sequence <ConsumesDef> ConsumesDefSeq;
  interface FactoryDef;
  typedef sequence <FactoryDef> FactoryDefSeq;
  interface FinderDef;
  typedef sequence <FinderDef> FinderDefSeq;
  interface PrimaryKeyDef;

  struct StructMember 
  {
    Identifier name;
    CORBA::TypeCode type;
    IDLType type_def;
  };

  typedef sequence <StructMember> StructMemberSeq;

  struct Initializer 
  {
    StructMemberSeq members;
    Identifier name;
  };

  typedef sequence <Initializer> InitializerSeq;

  struct UnionMember 
  {
    Identifier name;
    any label;
    CORBA:: TypeCode type;
    IDLType type_def;
  };

  typedef sequence <UnionMember> UnionMemberSeq;
  typedef sequence <Identifier> EnumMemberSeq;

  interface Container : CORBA::IRObject 
  {
    // read interface
    Contained lookup (
        in ScopedName search_name
      );
    ContainedSeq contents (
        in DefinitionKind limit_type,
        in boolean exclude_inherited
      );
    ContainedSeq lookup_name (
        in Identifier search_name,
        in long levels_to_search,
        in DefinitionKind limit_type,
        in boolean exclude_inherited
      );
    struct Description 
    {
      Contained contained_object;
      DefinitionKind kind;
      any value;
    };

    typedef sequence<Description> DescriptionSeq;

    DescriptionSeq describe_contents (
        in DefinitionKind limit_type,
        in boolean exclude_inherited,
        in long max_returned_objs
      );
    // write interface
    ModuleDef create_module (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version
      );
    ConstantDef create_constant (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in IDLType type,
        in any value
      );
    StructDef create_struct (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in StructMemberSeq members
      );
    UnionDef create_union (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in IDLType discriminator_type,
        in UnionMemberSeq members
      );
    EnumDef create_enum (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in EnumMemberSeq members
      );
    AliasDef create_alias (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in IDLType original_type
      );
    InterfaceDef create_interface (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in InterfaceDefSeq base_interfaces

        /* CCM specific.
        ,in boolean is_abstract
        ,in boolean is_local 
        */
      );
    ValueDef create_value (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in boolean is_custom,
        in boolean is_abstract,
        in ValueDef base_value,
        in boolean is_truncatable,
        in ValueDefSeq abstract_base_values,
        in InterfaceDefSeq supported_interfaces,
        in InitializerSeq initializers
      );
    ValueBoxDef create_value_box (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in IDLType original_type_def
      );
    ExceptionDef create_exception (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in StructMemberSeq members
      );
    NativeDef create_native (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version
      );

    // CORBA 2.x specific.

    AbstractInterfaceDef create_abstract_interface (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in AbstractInterfaceDefSeq base_interfaces
      );
    LocalInterfaceDef create_local_interface (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in InterfaceDefSeq base_interfaces
      );
  };

  interface IDLType : CORBA::IRObject 
  {
    readonly attribute CORBA::TypeCode type;
  };

  interface PrimitiveDef;
  interface StringDef;
  interface SequenceDef;
  interface ArrayDef;
  interface WstringDef;
  interface FixedDef;

  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_TypeCode, 
    pk_Principal, 
    pk_string, 
    pk_objref,
    pk_longlong, 
    pk_ulonglong, 
    pk_longdouble,
    pk_wchar, 
    pk_wstring, 
    pk_value_base
  };

  interface Repository : Container 
  {
    // read interface
    Contained lookup_id (
        in RepositoryId search_id
      );
    CORBA::TypeCode get_canonical_typecode (
        in CORBA::TypeCode tc
      );
    PrimitiveDef get_primitive (
        in PrimitiveKind kind
      );
    // write interface
    StringDef create_string (
        in unsigned long bound
      );
    WstringDef create_wstring (
        in unsigned long bound
      );
    SequenceDef create_sequence (
        in unsigned long bound,
        in IDLType element_type
      );
    ArrayDef create_array (
        in unsigned long length,
        in IDLType element_type
      );
    FixedDef create_fixed (
        in unsigned short digits,
        in short scale
      );
  };

  // CCM specific.

  interface ComponentRepository : Repository
  {
    ComponentDef create_component (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in ComponentDef base_component,
        in InterfaceDefSeq supports_interfaces
      );
    HomeDef create_home (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in HomeDef base_home,
        in ComponentDef managed_component,
        in ValueDef primary_key
      );
  };

  interface ModuleDef : Container, Contained 
  {
  };

  struct ModuleDescription 
  {
    Identifier name;
    RepositoryId id;
    RepositoryId defined_in;
    VersionSpec version;
  };

  interface ConstantDef : Contained 
  {
    readonly attribute CORBA::TypeCode type;
    attribute IDLType type_def;
    attribute any value;
  };

  struct ConstantDescription 
  {
    Identifier name;
    RepositoryId id;
    RepositoryId defined_in;
    VersionSpec version;
    CORBA::TypeCode type;
    any value;
  };

  interface TypedefDef : Contained, IDLType 
  {
  };

  struct TypeDescription 
  {
    Identifier name;
    RepositoryId id;
    RepositoryId defined_in;
    VersionSpec version;
    CORBA::TypeCode type;
  };

  interface StructDef : TypedefDef, Container 
  {
    attribute StructMemberSeq members;
  };

  interface UnionDef : TypedefDef, Container 
  {
    readonly attribute CORBA::TypeCode discriminator_type;
    attribute IDLType discriminator_type_def;
    attribute UnionMemberSeq members;
  };

  interface EnumDef : TypedefDef 
  {
    attribute EnumMemberSeq members;
  };

  interface AliasDef : TypedefDef 
  {
    attribute IDLType original_type_def;
  };

  interface NativeDef : TypedefDef 
  {
  };

  interface PrimitiveDef: IDLType 
  {
    readonly attribute PrimitiveKind kind;
  };

  interface StringDef : IDLType 
  {
    attribute unsigned long bound;
  };

  interface WstringDef : IDLType 
  {
    attribute unsigned long bound;
  };

  interface FixedDef : IDLType 
  {
    attribute unsigned short digits;
    attribute short scale;
  };

  interface SequenceDef : IDLType 
  {
    attribute unsigned long bound;
    readonly attribute CORBA::TypeCode element_type;
    attribute IDLType element_type_def;
  };

  interface ArrayDef : IDLType 
  {
    attribute unsigned long length;
    readonly attribute CORBA::TypeCode element_type;
    attribute IDLType element_type_def;
  };

  interface ExceptionDef : Contained, Container 
  {
    readonly attribute CORBA::TypeCode type;
    attribute StructMemberSeq members;
  };

  struct ExceptionDescription 
  {
    Identifier name;
    RepositoryId id;
    RepositoryId defined_in;
    VersionSpec version;
    CORBA::TypeCode type;
  };

  typedef sequence <ExceptionDef> ExceptionDefSeq;
  typedef sequence <ExceptionDescription> ExcDescriptionSeq;

  enum AttributeMode 
  {
    ATTR_NORMAL, 
    ATTR_READONLY
  };

  interface AttributeDef : Contained 
  {
    readonly attribute CORBA::TypeCode type;
    attribute IDLType type_def;
    attribute AttributeMode mode;
  };

  struct AttributeDescription 
  {
    Identifier name;
    RepositoryId id;
    RepositoryId defined_in;
    VersionSpec version;
    CORBA::TypeCode type;
    AttributeMode mode;

    /* CCM specific.
    ExcDescriptionSeq get_exceptions;
    ExcDescriptionSeq put_exceptions;
    */
  };

  enum OperationMode 
  {
    OP_NORMAL, 
    OP_ONEWAY
  };

  enum ParameterMode 
  {
    PARAM_IN, 
    PARAM_OUT, 
    PARAM_INOUT
  };

  struct ParameterDescription 
  {
    Identifier name;
    CORBA::TypeCode type;
    IDLType type_def;
    ParameterMode mode;
  };

  typedef sequence <ParameterDescription> ParDescriptionSeq;
  typedef Identifier ContextIdentifier;
  typedef sequence <ContextIdentifier> ContextIdSeq;

  interface OperationDef : Contained 
  {
    readonly attribute CORBA::TypeCode result;
    attribute IDLType result_def;
    attribute ParDescriptionSeq params;
    attribute OperationMode mode;
    attribute ContextIdSeq contexts;
    attribute ExceptionDefSeq exceptions;
  };

  struct OperationDescription 
  {
    Identifier name;
    RepositoryId id;
    RepositoryId defined_in;
    VersionSpec version;
    CORBA::TypeCode result;
    OperationMode mode;
    ContextIdSeq contexts;
    ParDescriptionSeq parameters;
    ExcDescriptionSeq exceptions;
  };

  typedef sequence <RepositoryId> RepositoryIdSeq;
  typedef sequence <OperationDescription> OpDescriptionSeq;
  typedef sequence <AttributeDescription> AttrDescriptionSeq;

  interface InterfaceDef : Container, Contained, IDLType 
  {
    // read/write interface
    attribute InterfaceDefSeq base_interfaces;
    // read interface

    /* CCM specific.
    attribute boolean is_abstract;
    attribute boolean is_local;
    */

    boolean is_a (
        in RepositoryId interface_id
      );

    // CORBA 2.x specific.

    struct FullInterfaceDescription 
    {
      Identifier name;
      RepositoryId id;
      RepositoryId defined_in;
      VersionSpec version;
      OpDescriptionSeq operations;
      AttrDescriptionSeq attributes;
      RepositoryIdSeq base_interfaces;
      CORBA::TypeCode type;
    };

    FullInterfaceDescription describe_interface ();

    // write interface
    AttributeDef create_attribute (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in IDLType type,
        in AttributeMode mode

        /* CCM specific.
        ,in ExceptionDefSeq get_exceptions
        ,in ExceptionDefSeq put_exceptions
        */
      );
    OperationDef create_operation (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in IDLType result,
        in OperationMode mode,
        in ParDescriptionSeq params,
        in ExceptionDefSeq exceptions,
        in ContextIdSeq contexts
      );
  };

  struct InterfaceDescription 
  {
    Identifier name;
    RepositoryId id;
    RepositoryId defined_in;
    VersionSpec version;

    /* CCM specific
    OpDescriptionSeq operations;
    AttrDescriptionSeq attributes;
    */

    RepositoryIdSeq base_interfaces;

    /* CCM specific.
    CORBA::TypeCode type;
    boolean is_abstract;
    boolean is_local;
    */
  };

  struct ValueMember 
  {
    Identifier name;
    RepositoryId id;
    RepositoryId defined_in;
    VersionSpec version;
    CORBA::TypeCode type;
    IDLType type_def;
    CORBA::Visibility access;
  };

  typedef sequence <ValueMember> ValueMemberSeq;

  interface ValueMemberDef : Contained 
  {
    readonly attribute CORBA::TypeCode type;
    attribute IDLType type_def;
    attribute CORBA::Visibility access;
  };

  interface ValueDef : Container, Contained, IDLType 
  {
    // read/write interface
    attribute InterfaceDefSeq supported_interfaces;
    attribute InitializerSeq initializers;
    attribute ValueDef base_value;
    attribute ValueDefSeq abstract_base_values;
    // read interface
    attribute boolean is_abstract;
    attribute boolean is_custom;
    attribute boolean is_truncatable;
    boolean is_a (
        in RepositoryId id
      );

    // CORBA 2.x specific.

    struct FullValueDescription 
    {
      Identifier name;
      RepositoryId id;
      boolean is_abstract;
      boolean is_custom;
      RepositoryId defined_in;
      VersionSpec version;
      OpDescriptionSeq operations;
      AttrDescriptionSeq attributes;
      ValueMemberSeq members;
      InitializerSeq initializers;
      RepositoryIdSeq supported_interfaces;
      RepositoryIdSeq abstract_base_values;
      boolean is_truncatable;
      RepositoryId base_value;
      CORBA::TypeCode type;
    };

    FullValueDescription describe_value ();
      
    ValueMemberDef create_value_member (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in IDLType type,
        in CORBA::Visibility access
      );
    AttributeDef create_attribute (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in IDLType type,
        in AttributeMode mode

        /* CCM specific
        ,in ExceptionDefSeq get_exceptions
        ,in ExceptionDefSeq put_exceptions
        */
      );
    OperationDef create_operation (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in IDLType result,
        in OperationMode mode,
        in ParDescriptionSeq params,
        in ExceptionDefSeq exceptions,
        in ContextIdSeq contexts
      );
  };

  struct ValueDescription 
  {
    Identifier name;
    RepositoryId id;
    boolean is_abstract;
    boolean is_custom;
    RepositoryId defined_in;
    VersionSpec version;

    /* CCM specific.
    OpDescriptionSeq operations;
    AttrDescriptionSeq attributes;
    ValueMemberSeq members;
    InitializerSeq initializers;
    */

    RepositoryIdSeq supported_interfaces;
    RepositoryIdSeq abstract_base_values;
    boolean is_truncatable;
    RepositoryId base_value;
    
    /* CCM specific
    CORBA::TypeCode type;
    */
  };

  interface ValueBoxDef : TypedefDef 
  {
    attribute IDLType original_type_def;
  };

  // CORBA 2.x specific.

  interface AbstractInterfaceDef : InterfaceDef 
  {
  };

  interface LocalInterfaceDef : InterfaceDef 
  {
  };

  // The rest of this file is CCM specific.

  interface ProvidesDef : Contained 
  {
    // read interface
    readonly attribute InterfaceDef interface_type;
  };

  struct ProvidesDescription 
  {
    Identifier name;
    RepositoryId id;
    RepositoryId defined_in;
    VersionSpec version;
    InterfaceDef interface_type;
  };

  interface UsesDef : Contained 
  {
    // read interface
    readonly attribute InterfaceDef interface_type;
    readonly attribute boolean is_multiple;
  };

  struct UsesDescription 
  {
    Identifier name;
    RepositoryId id;
    RepositoryId defined_in;
    VersionSpec version;
    InterfaceDef interface_type;
    boolean is_multiple;
  };

  typedef sequence <ProvidesDescription> ProvidesDescSeq;
  typedef sequence <UsesDescription> UsesDescSeq;

  interface EventDef : Contained 
  { // abstract - never instantiated
    // read interface
    boolean is_a (in RepositoryId event_id);
    readonly attribute ValueDef event;
  };

  struct EventDescription 
  {
    Identifier name;
    RepositoryId id;
    RepositoryId defined_in;
    VersionSpec version;
    ValueDef value;
  };

  interface EmitsDef : EventDef 
  {
  };

  interface PublishesDef : EventDef 
  {
  };

  interface ConsumesDef : EventDef 
  {
  };

  interface ComponentDef : InterfaceDef 
  {
    // read/write interface
    attribute InterfaceDefSeq supported_interfaces;
    // read interface
    readonly attribute ComponentDef base_component;
    readonly attribute ProvidesDefSeq provides_interfaces;
    readonly attribute UsesDefSeq uses_interfaces;
    readonly attribute EmitsDefSeq emits_events;
    readonly attribute PublishesDefSeq publishes_events;
    readonly attribute ConsumesDefSeq consumes_events;
    readonly attribute boolean is_basic;
    // write interface
    ProvidesDef create_provides (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in InterfaceDef interface_type
      );
    UsesDef create_uses (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in InterfaceDef interface_type,
        in boolean is_multiple
      );
    EmitsDef create_emits (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in ValueDef value
      );
    PublishesDef create_publishes (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in ValueDef value
      );
    ConsumesDef create_consumes (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in ValueDef value
      );
  };

  struct ComponentDescription 
  {
    Identifier name;
    RepositoryId id;
    RepositoryId defined_in;
    VersionSpec version;
    RepositoryId base_component;
    RepositoryIdSeq supports_interfaces;
    ProvidesDefSeq provides_interfaces;
    UsesDefSeq uses_interfaces;
    AttrDescriptionSeq attributes;
    EmitsDefSeq emits_events;
    PublishesDefSeq publishes_events;
    ConsumesDefSeq consumes_events;
    boolean is_basic;
  };

  interface PrimaryKeyDef : Contained 
  {
    // read interface
    boolean is_a (in RepositoryId primary_key_id);
    readonly attribute ValueDef primary_key;
  };

  struct PrimaryKeyDescription 
  {
    Identifier name;
    RepositoryId id;
    RepositoryId defined_in;
    VersionSpec version;
    ValueDef primary_key;
  };

  interface FactoryDef : OperationDef 
  { // only PARAM_IN parameters
  };

  interface FinderDef : OperationDef 
  { // only PARAM_IN parameters
  };

  interface HomeDef : InterfaceDef 
  {
    // read operations
    readonly attribute HomeDef base_home;
    readonly attribute ComponentDef managed_component;
    readonly attribute PrimaryKeyDef primary_key;
    readonly attribute FactoryDefSeq factories;
    readonly attribute FinderDefSeq finders;
    readonly attribute boolean is_basic;
    // write interfaces
    PrimaryKeyDef create_primary_key (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in ValueDef primary_key
      );
    FactoryDef create_factory (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in ParDescriptionSeq params, // only PARAM_INs
        in ExceptionDefSeq exceptions
      );
    FinderDef create_finder (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in ParDescriptionSeq params, // only PARAM_INs
        in ExceptionDefSeq exceptions
      );
  };

  struct HomeDescription 
  {
    Identifier name;
    RepositoryId id;
    RepositoryId defined_in;
    VersionSpec version;
    RepositoryId base_home;
    RepositoryId managed_component;
    PrimaryKeyDef primary_key_def;
    FactoryDefSeq factories;
    FinderDefSeq finders;
    OpDescriptionSeq operations;
    AttrDescriptionSeq attributes;
    boolean is_basic;
  };
};

#pragma prefix ""
#endif // _INTERFACE_IDL_