path: root/TAO/tao/Interface.pidl

//$Id$

#pragma prefix "omg.org"
module IR 
{
  typedef CORBA::Identifier Identifier;
  typedef CORBA::ScopedName ScopedName;
  typedef CORBA::RepositoryId RepositoryId;

  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,
    dk_Component, 
    dk_Home,
    dk_Factory, 
    dk_Finder, 
    dk_PrimaryKey,
    dk_Emits, 
    dk_Publishes, 
    dk_Consumes,
    dk_Provides, 
    dk_Uses
  };

  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;
  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;
  typedef sequence <Contained> ContainedSeq;

  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,
        in boolean is_abstract
      );
    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
      );
  };

  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
      );
  };

  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;
    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
    attribute boolean is_abstract;
    attribute boolean is_local;
    boolean is_a (
        in RepositoryId interface_id
      );
    // write interface
    AttributeDef create_attribute (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in IDLType type,
        in AttributeMode mode,
        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;
    OpDescriptionSeq operations;
    AttrDescriptionSeq attributes;
    RepositoryIdSeq base_interfaces;
    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
      );
    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,
        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;
    OpDescriptionSeq operations;
    AttrDescriptionSeq attributes;
    ValueMemberSeq members;
    InitializerSeq initializers;
    RepositoryIdSeq supported_interfaces;
    RepositoryIdSeq abstract_base_values;
    boolean is_truncatable;
    RepositoryId base_value;
    CORBA::TypeCode type;
  };

  interface ValueBoxDef : TypedefDef 
  {
    attribute IDLType original_type_def;
  };

  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;
  };
};

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

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

// This just gets put in corbafwd.h.
#if 0
  enum TCKind 
  { // PIDL
    tk_null, tk_void,
    tk_short, tk_long, tk_ushort, tk_ulong,
    tk_float, tk_double, tk_boolean, tk_char,
    tk_octet, tk_any, tk_TypeCode, tk_Principal, tk_objref,
    tk_struct, tk_union, tk_enum, tk_string,
    tk_sequence, tk_array, tk_alias, tk_except,
    tk_longlong, tk_ulonglong, tk_longdouble,
    tk_wchar, tk_wstring, tk_fixed,
    tk_value, tk_value_box,
    tk_native,
    tk_abstract_interface,
    tk_component, tk_home
  };
#endif /* 0 */

  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;

// Not generated.
#if 0
  interface TypeCode 
  { // PIDL
    exception Bounds {};
    exception BadKind {};
    // for all TypeCode kinds
    boolean equal (in TypeCode tc);
    boolean equivalent(in TypeCode tc);
    TypeCode get_compact_typecode();
    TCKind kind ();
    // for tk_objref, tk_struct, tk_union, tk_enum, tk_alias,
    // tk_value, tk_value_box, tk_native, tk_abstract_interface,
    // tk_except, tk_component, tk_home
    RepositoryId id () raises (BadKind);
    // for tk_objref, tk_struct, tk_union, tk_enum, tk_alias,
    // tk_value, tk_value_box, tk_native, tk_abstract_interface
    // tk_except, tk_component, tk_home
    Identifier name () raises (BadKind);
    // for tk_struct, tk_union, tk_enum, tk_value,
    // and tk_except
    unsigned long member_count () raises (BadKind);
    Identifier member_name (in unsigned long index)
      raises (BadKind, Bounds);
    // for tk_struct, tk_union, tk_value, and tk_except
    TypeCode member_type (in unsigned long index)
      raises (BadKind, Bounds);
    // for tk_union
    any member_label (in unsigned long index)
      raises (BadKind, Bounds);
    TypeCode discriminator_type () raises (BadKind);
    long default_index () raises (BadKind);
    // for tk_string, tk_sequence, and tk_array
    unsigned long length () raises (BadKind);
    // for tk_sequence, tk_array, tk_value_box, and tk_alias
    TypeCode content_type () raises (BadKind);
    // for tk_fixed
    unsigned short fixed_digits() raises (BadKind);
    short fixed_scale() raises (BadKind);
    // for tk_value
    Visibility member_visibility(in unsigned long index)
      raises(BadKind, Bounds);
    ValueModifier type_modifier() raises(BadKind);
    TypeCode concrete_base_type() raises(BadKind);
  };
#endif /* 0 */

  // The TypeCode related part of interface ORB moved to
  // the TypeCodeFactory interface.
  // A reference to this interface can be obtained from
  // resolve_initial_references with argument "TypeCodeFactory".
  interface TypeCodeFactory 
  { // PIDL
    TypeCode create_struct_tc (
        in RepositoryId id,
        in Identifier name,
        in StructMemberSeq members
      );
    TypeCode create_union_tc (
        in RepositoryId id,
        in Identifier name,
        in TypeCode discriminator_type,
        in UnionMemberSeq members
      );
    TypeCode create_enum_tc (
        in RepositoryId id,
        in Identifier name,
        in EnumMemberSeq members
      );
    TypeCode create_alias_tc (
        in RepositoryId id,
        in Identifier name,
        in TypeCode original_type
      );
    TypeCode create_exception_tc (
        in RepositoryId id,
        in Identifier name,
        in StructMemberSeq members
      );
    TypeCode create_interface_tc (
        in RepositoryId id,
        in Identifier name
      );
    TypeCode create_string_tc (
        in unsigned long bound
      );
    TypeCode create_wstring_tc (
        in unsigned long bound
      );
    TypeCode create_fixed_tc (
        in unsigned short digits,
        in unsigned short scale
      );
    TypeCode create_sequence_tc (
        in unsigned long bound,
        in TypeCode element_type
      );
    TypeCode create_array_tc (
        in unsigned long length,
        in TypeCode element_type
      );
    TypeCode create_value_tc (
        in RepositoryId id,
        in Identifier name,
        in ValueModifier type_modifier,
        in TypeCode concrete_base,
        in ValueMemberSeq members
      );
    TypeCode create_value_box_tc (
        in RepositoryId id,
        in Identifier name,
        in TypeCode boxed_type
      );
    TypeCode create_native_tc (
        in RepositoryId id,
        in Identifier name
      );
    TypeCode create_recursive_tc (
        in RepositoryId id
      );
    TypeCode create_abstract_interface_tc (
        in RepositoryId id,
        in Identifier name
      );
    TypeCode create_component_tc (
        in RepositoryId id,
        in Identifier name
      );
    TypeCode create_home_tc (
        in RepositoryId id,
        in Identifier name
      );
  };
};