pragma Style_Checks ("NM32766");
pragma Warnings (Off, "use of an anonymous access type allocator");
pragma Warnings (Off, "unnecessary with of ancestor");

---------------------------------------------------
--  This file has been generated automatically from
--  /pbulk/work/net/ada-polyorb/work/PolyORB-25.0/idls/CORBA_IDL/orb.idl
--  by IAC (IDL to Ada Compiler) 25.0w (rev. unknown).
---------------------------------------------------
--  NOTE: If you modify this file by hand, your
--  changes will be lost when you re-run the
--  IDL to Ada compiler.
---------------------------------------------------

with PolyORB.Std;
with Ada.Unchecked_Conversion;
with Ada.Unchecked_Deallocation;
with CORBA.Object.Helper;
with CORBA.Repository_Root.InterfaceDef.Helper;
with CORBA.Repository_Root.ValueDef.Helper;
with CORBA.Repository_Root.AbstractInterfaceDef.Helper;
with CORBA.Repository_Root.LocalInterfaceDef.Helper;
with CORBA.Repository_Root.ExtInterfaceDef.Helper;
with CORBA.Repository_Root.ExtAbstractInterfaceDef.Helper;
with CORBA.Repository_Root.ExtLocalInterfaceDef.Helper;
with CORBA.Repository_Root.Contained.Helper;
with CORBA.Repository_Root.IDLType.Helper;
with CORBA.Repository_Root.ExceptionDef.Helper;
with PolyORB.Utils.Strings;
with PolyORB.Utils.Strings.Lists;
with PolyORB.Initialization;

package body CORBA.Repository_Root.Helper is

   
   package body Internals is

      ArrayDef_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------
      -- Initialize_ArrayDef --
      -------------------------

      procedure Initialize_ArrayDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ArrayDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ArrayDef:1.0");
      begin
         if not ArrayDef_Initialized
         then
            ArrayDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ArrayDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_ArrayDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ArrayDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ArrayDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_ArrayDef);
         end if;
      end Initialize_ArrayDef;

      AttributeDef_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------
      -- Initialize_AttributeDef --
      -----------------------------

      procedure Initialize_AttributeDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("AttributeDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/AttributeDef:1.0");
      begin
         if not AttributeDef_Initialized
         then
            AttributeDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_AttributeDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_AttributeDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_AttributeDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_AttributeDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_AttributeDef);
         end if;
      end Initialize_AttributeDef;

      Contained_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------
      -- Initialize_Contained --
      --------------------------

      procedure Initialize_Contained is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("Contained");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/Contained:1.0");
      begin
         if not Contained_Initialized
         then
            Contained_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_Contained :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_Contained,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_Contained,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_Contained);
            CORBA.TypeCode.Internals.Freeze
              (TC_Contained);
         end if;
      end Initialize_Contained;

      Container_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------
      -- Initialize_Container --
      --------------------------

      procedure Initialize_Container is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("Container");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/Container:1.0");
      begin
         if not Container_Initialized
         then
            Container_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_Container :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_Container,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_Container,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_Container);
            CORBA.TypeCode.Internals.Freeze
              (TC_Container);
         end if;
      end Initialize_Container;

      FixedDef_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------
      -- Initialize_FixedDef --
      -------------------------

      procedure Initialize_FixedDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("FixedDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/FixedDef:1.0");
      begin
         if not FixedDef_Initialized
         then
            FixedDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_FixedDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_FixedDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_FixedDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_FixedDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_FixedDef);
         end if;
      end Initialize_FixedDef;

      IRObject_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------
      -- Initialize_IRObject --
      -------------------------

      procedure Initialize_IRObject is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IRObject");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/IRObject:1.0");
      begin
         if not IRObject_Initialized
         then
            IRObject_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_IRObject :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_IRObject,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_IRObject,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_IRObject);
            CORBA.TypeCode.Internals.Freeze
              (TC_IRObject);
         end if;
      end Initialize_IRObject;

      OperationDef_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------
      -- Initialize_OperationDef --
      -----------------------------

      procedure Initialize_OperationDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("OperationDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/OperationDef:1.0");
      begin
         if not OperationDef_Initialized
         then
            OperationDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_OperationDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_OperationDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_OperationDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_OperationDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_OperationDef);
         end if;
      end Initialize_OperationDef;

      PrimitiveDef_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------
      -- Initialize_PrimitiveDef --
      -----------------------------

      procedure Initialize_PrimitiveDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("PrimitiveDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/PrimitiveDef:1.0");
      begin
         if not PrimitiveDef_Initialized
         then
            PrimitiveDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_PrimitiveDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_PrimitiveDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_PrimitiveDef);
         end if;
      end Initialize_PrimitiveDef;

      Repository_Initialized : PolyORB.Std.Boolean :=
        False;

      ---------------------------
      -- Initialize_Repository --
      ---------------------------

      procedure Initialize_Repository is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("Repository");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/Repository:1.0");
      begin
         if not Repository_Initialized
         then
            Repository_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_Repository :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_Repository,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_Repository,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_Repository);
            CORBA.TypeCode.Internals.Freeze
              (TC_Repository);
         end if;
      end Initialize_Repository;

      SequenceDef_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------
      -- Initialize_SequenceDef --
      ----------------------------

      procedure Initialize_SequenceDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("SequenceDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/SequenceDef:1.0");
      begin
         if not SequenceDef_Initialized
         then
            SequenceDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_SequenceDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_SequenceDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_SequenceDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_SequenceDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_SequenceDef);
         end if;
      end Initialize_SequenceDef;

      StringDef_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------
      -- Initialize_StringDef --
      --------------------------

      procedure Initialize_StringDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("StringDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/StringDef:1.0");
      begin
         if not StringDef_Initialized
         then
            StringDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_StringDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_StringDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_StringDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_StringDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_StringDef);
         end if;
      end Initialize_StringDef;

      TypedefDef_Initialized : PolyORB.Std.Boolean :=
        False;

      ---------------------------
      -- Initialize_TypedefDef --
      ---------------------------

      procedure Initialize_TypedefDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("TypedefDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/TypedefDef:1.0");
      begin
         if not TypedefDef_Initialized
         then
            TypedefDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_TypedefDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_TypedefDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_TypedefDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_TypedefDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_TypedefDef);
         end if;
      end Initialize_TypedefDef;

      ValueMemberDef_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------
      -- Initialize_ValueMemberDef --
      -------------------------------

      procedure Initialize_ValueMemberDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ValueMemberDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ValueMemberDef:1.0");
      begin
         if not ValueMemberDef_Initialized
         then
            ValueMemberDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ValueMemberDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_ValueMemberDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ValueMemberDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ValueMemberDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_ValueMemberDef);
         end if;
      end Initialize_ValueMemberDef;

      WstringDef_Initialized : PolyORB.Std.Boolean :=
        False;

      ---------------------------
      -- Initialize_WstringDef --
      ---------------------------

      procedure Initialize_WstringDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("WstringDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/WstringDef:1.0");
      begin
         if not WstringDef_Initialized
         then
            WstringDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_WstringDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_WstringDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_WstringDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_WstringDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_WstringDef);
         end if;
      end Initialize_WstringDef;

      --------------
      -- From_Any --
      --------------

      function From_Any
        (C : PolyORB.Any.Any_Container'Class)
        return CORBA.Repository_Root.DefinitionKind
      is
      begin
         return CORBA.Repository_Root.DefinitionKind'Val
           (PolyORB.Types.Unsigned_Long'
              (PolyORB.Any.Get_Aggregate_Element
                 (C,
                  0)));
      end From_Any;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_DefinitionKind;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc, Index);
      begin
         Acc.Repr_Cache :=
           CORBA.Repository_Root.DefinitionKind'Pos
              (Acc.V.all);
         Mech.all :=
           PolyORB.Any.By_Value;
         return PolyORB.Any.Wrap
           (Acc.Repr_Cache'Unrestricted_Access);
      end Get_Aggregate_Element;

      ---------------------------
      -- Set_Aggregate_Element --
      ---------------------------

      procedure Set_Aggregate_Element
        (Acc : in out Content_Ü_DefinitionKind;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         From_C : in out PolyORB.Any.Any_Container'Class)
      is
         use type PolyORB.Types.Unsigned_Long;
         pragma Assert ((Index
            = 0));
         pragma Unreferenced (Tc);
      begin
         Acc.V.all :=
           CORBA.Repository_Root.DefinitionKind'Val
              (PolyORB.Types.Unsigned_Long'
                 (PolyORB.Any.From_Any
                    (From_C)));
      end Set_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_DefinitionKind)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 1;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_DefinitionKind;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_DefinitionKind)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_DefinitionKind,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_DefinitionKind;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_DefinitionKind)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_DefinitionKind
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_DefinitionKind;
            Content_Ü_DefinitionKind
              (Target.all).V :=
              new CORBA.Repository_Root.DefinitionKind'
                 (Acc.V.all);
         end if;
         Content_Ü_DefinitionKind
           (Target.all).Repr_Cache :=
           Acc.Repr_Cache;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_DefinitionKind)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.DefinitionKind,
               Ptr_Ü_DefinitionKind);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.DefinitionKind)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_DefinitionKind'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_DefinitionKind'
              (X.all'Unchecked_Access),
            Repr_Cache => 0);
      end Wrap;

      DefinitionKind_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------
      -- Initialize_DefinitionKind --
      -------------------------------

      procedure Initialize_DefinitionKind is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("DefinitionKind");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/DefinitionKind:1.0");
         dk_none_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_none");
         dk_all_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_all");
         dk_Attribute_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Attribute");
         dk_Constant_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Constant");
         dk_Exception_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Exception");
         dk_Interface_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Interface");
         dk_Module_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Module");
         dk_Operation_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Operation");
         dk_Typedef_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Typedef");
         dk_Alias_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Alias");
         dk_Struct_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Struct");
         dk_Union_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Union");
         dk_Enum_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Enum");
         dk_Primitive_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Primitive");
         dk_String_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_String");
         dk_Sequence_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Sequence");
         dk_Array_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Array");
         dk_Repository_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Repository");
         dk_Wstring_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Wstring");
         dk_Fixed_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Fixed");
         dk_Value_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Value");
         dk_ValueBox_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_ValueBox");
         dk_ValueMember_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_ValueMember");
         dk_Native_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Native");
         dk_AbstractInterface_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_AbstractInterface");
         dk_LocalInterface_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_LocalInterface");
         dk_Component_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Component");
         dk_Home_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Home");
         dk_Factory_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Factory");
         dk_Finder_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Finder");
         dk_Emits_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Emits");
         dk_Publishes_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Publishes");
         dk_Consumes_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Consumes");
         dk_Provides_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Provides");
         dk_Uses_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Uses");
         dk_Event_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("dk_Event");
      begin
         if not DefinitionKind_Initialized
         then
            DefinitionKind_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_DefinitionKind :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Enum);
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_none_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_all_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Attribute_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Constant_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Exception_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Interface_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Module_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Operation_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Typedef_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Alias_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Struct_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Union_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Enum_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Primitive_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_String_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Sequence_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Array_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Repository_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Wstring_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Fixed_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Value_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_ValueBox_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_ValueMember_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Native_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_AbstractInterface_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_LocalInterface_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Component_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Home_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Factory_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Finder_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Emits_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Publishes_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Consumes_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Provides_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Uses_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_DefinitionKind,
               CORBA.To_Any
                 (dk_Event_Name_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_DefinitionKind);
            CORBA.TypeCode.Internals.Freeze
              (TC_DefinitionKind);
         end if;
      end Initialize_DefinitionKind;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.VersionSpec)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Wrap
           (CORBA.String
              (X.all)'Unrestricted_Access);
      end Wrap;

      VersionSpec_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------
      -- Initialize_VersionSpec --
      ----------------------------

      procedure Initialize_VersionSpec is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("VersionSpec");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/VersionSpec:1.0");
      begin
         if not VersionSpec_Initialized
         then
            VersionSpec_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_VersionSpec :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.TC_String);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_VersionSpec);
            CORBA.TypeCode.Internals.Freeze
              (TC_VersionSpec);
         end if;
      end Initialize_VersionSpec;

      ModuleDef_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------
      -- Initialize_ModuleDef --
      --------------------------

      procedure Initialize_ModuleDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ModuleDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ModuleDef:1.0");
      begin
         if not ModuleDef_Initialized
         then
            ModuleDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ModuleDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_ModuleDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ModuleDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ModuleDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_ModuleDef);
         end if;
      end Initialize_ModuleDef;

      ConstantDef_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------
      -- Initialize_ConstantDef --
      ----------------------------

      procedure Initialize_ConstantDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ConstantDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ConstantDef:1.0");
      begin
         if not ConstantDef_Initialized
         then
            ConstantDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ConstantDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_ConstantDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ConstantDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ConstantDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_ConstantDef);
         end if;
      end Initialize_ConstantDef;

      IDLType_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------
      -- Initialize_IDLType --
      ------------------------

      procedure Initialize_IDLType is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDLType");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/IDLType:1.0");
      begin
         if not IDLType_Initialized
         then
            IDLType_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_IDLType :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_IDLType,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_IDLType,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_IDLType);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDLType);
         end if;
      end Initialize_IDLType;

      StructDef_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------
      -- Initialize_StructDef --
      --------------------------

      procedure Initialize_StructDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("StructDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/StructDef:1.0");
      begin
         if not StructDef_Initialized
         then
            StructDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_StructDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_StructDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_StructDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_StructDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_StructDef);
         end if;
      end Initialize_StructDef;

      UnionDef_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------
      -- Initialize_UnionDef --
      -------------------------

      procedure Initialize_UnionDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("UnionDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/UnionDef:1.0");
      begin
         if not UnionDef_Initialized
         then
            UnionDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_UnionDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_UnionDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_UnionDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_UnionDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_UnionDef);
         end if;
      end Initialize_UnionDef;

      EnumDef_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------
      -- Initialize_EnumDef --
      ------------------------

      procedure Initialize_EnumDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("EnumDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/EnumDef:1.0");
      begin
         if not EnumDef_Initialized
         then
            EnumDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_EnumDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_EnumDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_EnumDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_EnumDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_EnumDef);
         end if;
      end Initialize_EnumDef;

      AliasDef_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------
      -- Initialize_AliasDef --
      -------------------------

      procedure Initialize_AliasDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("AliasDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/AliasDef:1.0");
      begin
         if not AliasDef_Initialized
         then
            AliasDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_AliasDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_AliasDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_AliasDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_AliasDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_AliasDef);
         end if;
      end Initialize_AliasDef;

      ExceptionDef_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------
      -- Initialize_ExceptionDef --
      -----------------------------

      procedure Initialize_ExceptionDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ExceptionDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ExceptionDef:1.0");
      begin
         if not ExceptionDef_Initialized
         then
            ExceptionDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ExceptionDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_ExceptionDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ExceptionDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ExceptionDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_ExceptionDef);
         end if;
      end Initialize_ExceptionDef;

      NativeDef_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------
      -- Initialize_NativeDef --
      --------------------------

      procedure Initialize_NativeDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("NativeDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/NativeDef:1.0");
      begin
         if not NativeDef_Initialized
         then
            NativeDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_NativeDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_NativeDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_NativeDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_NativeDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_NativeDef);
         end if;
      end Initialize_NativeDef;

      InterfaceDef_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------
      -- Initialize_InterfaceDef --
      -----------------------------

      procedure Initialize_InterfaceDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("InterfaceDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/InterfaceDef:1.0");
      begin
         if not InterfaceDef_Initialized
         then
            InterfaceDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_InterfaceDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_InterfaceDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_InterfaceDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_InterfaceDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_InterfaceDef);
         end if;
      end Initialize_InterfaceDef;

      ----------------------------------------------------------
      -- IDL_SEQUENCE_CORBA_InterfaceDef_Forward_Element_Wrap --
      ----------------------------------------------------------

      function IDL_SEQUENCE_CORBA_InterfaceDef_Forward_Element_Wrap
        (X : access CORBA.Repository_Root.InterfaceDef_Forward.Ref)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (X.all)'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_InterfaceDef_Forward_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_InterfaceDef_Forward.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_InterfaceDef_Forward_Helper.Wrap;

      IDL_SEQUENCE_CORBA_InterfaceDef_Forward_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_InterfaceDef_Forward --
      --------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_InterfaceDef_Forward is
      begin
         if not IDL_SEQUENCE_CORBA_InterfaceDef_Forward_Initialized
         then
            IDL_SEQUENCE_CORBA_InterfaceDef_Forward_Initialized :=
              True;
            CORBA.Repository_Root.InterfaceDef.Helper.Internals.Initialize_InterfaceDef;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_InterfaceDef_Forward :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.InterfaceDef.Helper.TC_InterfaceDef,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_InterfaceDef_Forward);
            IDL_SEQUENCE_CORBA_InterfaceDef_Forward_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.InterfaceDef.Helper.TC_InterfaceDef,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_InterfaceDef_Forward);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_InterfaceDef_Forward);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_InterfaceDef_Forward;

      InterfaceDefSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------
      -- Initialize_InterfaceDefSeq --
      --------------------------------

      procedure Initialize_InterfaceDefSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("InterfaceDefSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/InterfaceDefSeq:1.0");
      begin
         if not InterfaceDefSeq_Initialized
         then
            InterfaceDefSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_InterfaceDef_Forward;
            CORBA.Repository_Root.Helper.TC_InterfaceDefSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_InterfaceDef_Forward);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_InterfaceDefSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_InterfaceDefSeq);
         end if;
      end Initialize_InterfaceDefSeq;

      ValueDef_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------
      -- Initialize_ValueDef --
      -------------------------

      procedure Initialize_ValueDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ValueDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ValueDef:1.0");
      begin
         if not ValueDef_Initialized
         then
            ValueDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ValueDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_ValueDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ValueDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ValueDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_ValueDef);
         end if;
      end Initialize_ValueDef;

      ------------------------------------------------------
      -- IDL_SEQUENCE_CORBA_ValueDef_Forward_Element_Wrap --
      ------------------------------------------------------

      function IDL_SEQUENCE_CORBA_ValueDef_Forward_Element_Wrap
        (X : access CORBA.Repository_Root.ValueDef_Forward.Ref)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (X.all)'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_ValueDef_Forward_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ValueDef_Forward.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_ValueDef_Forward_Helper.Wrap;

      IDL_SEQUENCE_CORBA_ValueDef_Forward_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_ValueDef_Forward --
      ----------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_ValueDef_Forward is
      begin
         if not IDL_SEQUENCE_CORBA_ValueDef_Forward_Initialized
         then
            IDL_SEQUENCE_CORBA_ValueDef_Forward_Initialized :=
              True;
            CORBA.Repository_Root.ValueDef.Helper.Internals.Initialize_ValueDef;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ValueDef_Forward :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.ValueDef.Helper.TC_ValueDef,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ValueDef_Forward);
            IDL_SEQUENCE_CORBA_ValueDef_Forward_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.ValueDef.Helper.TC_ValueDef,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ValueDef_Forward);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_ValueDef_Forward);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_ValueDef_Forward;

      ValueDefSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------
      -- Initialize_ValueDefSeq --
      ----------------------------

      procedure Initialize_ValueDefSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ValueDefSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ValueDefSeq:1.0");
      begin
         if not ValueDefSeq_Initialized
         then
            ValueDefSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ValueDef_Forward;
            CORBA.Repository_Root.Helper.TC_ValueDefSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ValueDef_Forward);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ValueDefSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_ValueDefSeq);
         end if;
      end Initialize_ValueDefSeq;

      ValueBoxDef_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------
      -- Initialize_ValueBoxDef --
      ----------------------------

      procedure Initialize_ValueBoxDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ValueBoxDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ValueBoxDef:1.0");
      begin
         if not ValueBoxDef_Initialized
         then
            ValueBoxDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ValueBoxDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_ValueBoxDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ValueBoxDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ValueBoxDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_ValueBoxDef);
         end if;
      end Initialize_ValueBoxDef;

      AbstractInterfaceDef_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------------
      -- Initialize_AbstractInterfaceDef --
      -------------------------------------

      procedure Initialize_AbstractInterfaceDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("AbstractInterfaceDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/AbstractInterfaceDef:1.0");
      begin
         if not AbstractInterfaceDef_Initialized
         then
            AbstractInterfaceDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_AbstractInterfaceDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_AbstractInterfaceDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_AbstractInterfaceDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_AbstractInterfaceDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_AbstractInterfaceDef);
         end if;
      end Initialize_AbstractInterfaceDef;

      ------------------------------------------------------------------
      -- IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward_Element_Wrap --
      ------------------------------------------------------------------

      function IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward_Element_Wrap
        (X : access CORBA.Repository_Root.AbstractInterfaceDef_Forward.Ref)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (X.all)'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward_Helper.Wrap;

      IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward --
      ----------------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward is
      begin
         if not IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward_Initialized
         then
            IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward_Initialized :=
              True;
            CORBA.Repository_Root.AbstractInterfaceDef.Helper.Internals.Initialize_AbstractInterfaceDef;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.AbstractInterfaceDef.Helper.TC_AbstractInterfaceDef,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward);
            IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.AbstractInterfaceDef.Helper.TC_AbstractInterfaceDef,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward;

      AbstractInterfaceDefSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------------------
      -- Initialize_AbstractInterfaceDefSeq --
      ----------------------------------------

      procedure Initialize_AbstractInterfaceDefSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("AbstractInterfaceDefSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/AbstractInterfaceDefSeq:1.0");
      begin
         if not AbstractInterfaceDefSeq_Initialized
         then
            AbstractInterfaceDefSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward;
            CORBA.Repository_Root.Helper.TC_AbstractInterfaceDefSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_AbstractInterfaceDefSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_AbstractInterfaceDefSeq);
         end if;
      end Initialize_AbstractInterfaceDefSeq;

      LocalInterfaceDef_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------------
      -- Initialize_LocalInterfaceDef --
      ----------------------------------

      procedure Initialize_LocalInterfaceDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("LocalInterfaceDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/LocalInterfaceDef:1.0");
      begin
         if not LocalInterfaceDef_Initialized
         then
            LocalInterfaceDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_LocalInterfaceDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_LocalInterfaceDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_LocalInterfaceDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_LocalInterfaceDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_LocalInterfaceDef);
         end if;
      end Initialize_LocalInterfaceDef;

      ---------------------------------------------------------------
      -- IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward_Element_Wrap --
      ---------------------------------------------------------------

      function IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward_Element_Wrap
        (X : access CORBA.Repository_Root.LocalInterfaceDef_Forward.Ref)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (X.all)'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward_Helper.Wrap;

      IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward --
      -------------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward is
      begin
         if not IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward_Initialized
         then
            IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward_Initialized :=
              True;
            CORBA.Repository_Root.LocalInterfaceDef.Helper.Internals.Initialize_LocalInterfaceDef;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.LocalInterfaceDef.Helper.TC_LocalInterfaceDef,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward);
            IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.LocalInterfaceDef.Helper.TC_LocalInterfaceDef,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward;

      LocalInterfaceDefSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------------
      -- Initialize_LocalInterfaceDefSeq --
      -------------------------------------

      procedure Initialize_LocalInterfaceDefSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("LocalInterfaceDefSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/LocalInterfaceDefSeq:1.0");
      begin
         if not LocalInterfaceDefSeq_Initialized
         then
            LocalInterfaceDefSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward;
            CORBA.Repository_Root.Helper.TC_LocalInterfaceDefSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_LocalInterfaceDefSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_LocalInterfaceDefSeq);
         end if;
      end Initialize_LocalInterfaceDefSeq;

      ExtInterfaceDef_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------
      -- Initialize_ExtInterfaceDef --
      --------------------------------

      procedure Initialize_ExtInterfaceDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ExtInterfaceDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ExtInterfaceDef:1.0");
      begin
         if not ExtInterfaceDef_Initialized
         then
            ExtInterfaceDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ExtInterfaceDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_ExtInterfaceDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ExtInterfaceDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ExtInterfaceDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_ExtInterfaceDef);
         end if;
      end Initialize_ExtInterfaceDef;

      -------------------------------------------------------------
      -- IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward_Element_Wrap --
      -------------------------------------------------------------

      function IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward_Element_Wrap
        (X : access CORBA.Repository_Root.ExtInterfaceDef_Forward.Ref)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (X.all)'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward_Helper.Wrap;

      IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward --
      -----------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward is
      begin
         if not IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward_Initialized
         then
            IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward_Initialized :=
              True;
            CORBA.Repository_Root.ExtInterfaceDef.Helper.Internals.Initialize_ExtInterfaceDef;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.ExtInterfaceDef.Helper.TC_ExtInterfaceDef,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward);
            IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.ExtInterfaceDef.Helper.TC_ExtInterfaceDef,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward;

      ExtInterfaceDefSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------------
      -- Initialize_ExtInterfaceDefSeq --
      -----------------------------------

      procedure Initialize_ExtInterfaceDefSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ExtInterfaceDefSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ExtInterfaceDefSeq:1.0");
      begin
         if not ExtInterfaceDefSeq_Initialized
         then
            ExtInterfaceDefSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward;
            CORBA.Repository_Root.Helper.TC_ExtInterfaceDefSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ExtInterfaceDefSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_ExtInterfaceDefSeq);
         end if;
      end Initialize_ExtInterfaceDefSeq;

      ExtAbstractInterfaceDef_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------------------
      -- Initialize_ExtAbstractInterfaceDef --
      ----------------------------------------

      procedure Initialize_ExtAbstractInterfaceDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ExtAbstractInterfaceDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ExtAbstractInterfaceDef:1.0");
      begin
         if not ExtAbstractInterfaceDef_Initialized
         then
            ExtAbstractInterfaceDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ExtAbstractInterfaceDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_ExtAbstractInterfaceDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ExtAbstractInterfaceDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ExtAbstractInterfaceDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_ExtAbstractInterfaceDef);
         end if;
      end Initialize_ExtAbstractInterfaceDef;

      ---------------------------------------------------------------------
      -- IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward_Element_Wrap --
      ---------------------------------------------------------------------

      function IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward_Element_Wrap
        (X : access CORBA.Repository_Root.ExtAbstractInterfaceDef_Forward.Ref)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (X.all)'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward_Helper.Wrap;

      IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward --
      -------------------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward is
      begin
         if not IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward_Initialized
         then
            IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward_Initialized :=
              True;
            CORBA.Repository_Root.ExtAbstractInterfaceDef.Helper.Internals.Initialize_ExtAbstractInterfaceDef;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.ExtAbstractInterfaceDef.Helper.TC_ExtAbstractInterfaceDef,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward);
            IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.ExtAbstractInterfaceDef.Helper.TC_ExtAbstractInterfaceDef,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward;

      ExtAbstractInterfaceDefSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------------------
      -- Initialize_ExtAbstractInterfaceDefSeq --
      -------------------------------------------

      procedure Initialize_ExtAbstractInterfaceDefSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ExtAbstractInterfaceDefSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ExtAbstractInterfaceDefSeq:1.0");
      begin
         if not ExtAbstractInterfaceDefSeq_Initialized
         then
            ExtAbstractInterfaceDefSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward;
            CORBA.Repository_Root.Helper.TC_ExtAbstractInterfaceDefSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ExtAbstractInterfaceDefSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_ExtAbstractInterfaceDefSeq);
         end if;
      end Initialize_ExtAbstractInterfaceDefSeq;

      ExtLocalInterfaceDef_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------------
      -- Initialize_ExtLocalInterfaceDef --
      -------------------------------------

      procedure Initialize_ExtLocalInterfaceDef is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ExtLocalInterfaceDef");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ExtLocalInterfaceDef:1.0");
      begin
         if not ExtLocalInterfaceDef_Initialized
         then
            ExtLocalInterfaceDef_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ExtLocalInterfaceDef :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Object);
            CORBA.Internals.Add_Parameter
              (TC_ExtLocalInterfaceDef,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ExtLocalInterfaceDef,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ExtLocalInterfaceDef);
            CORBA.TypeCode.Internals.Freeze
              (TC_ExtLocalInterfaceDef);
         end if;
      end Initialize_ExtLocalInterfaceDef;

      ------------------------------------------------------------------
      -- IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward_Element_Wrap --
      ------------------------------------------------------------------

      function IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward_Element_Wrap
        (X : access CORBA.Repository_Root.ExtLocalInterfaceDef_Forward.Ref)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (X.all)'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward_Helper.Wrap;

      IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward --
      ----------------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward is
      begin
         if not IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward_Initialized
         then
            IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward_Initialized :=
              True;
            CORBA.Repository_Root.ExtLocalInterfaceDef.Helper.Internals.Initialize_ExtLocalInterfaceDef;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.ExtLocalInterfaceDef.Helper.TC_ExtLocalInterfaceDef,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward);
            IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.ExtLocalInterfaceDef.Helper.TC_ExtLocalInterfaceDef,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward;

      ExtLocalInterfaceDefSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------------------
      -- Initialize_ExtLocalInterfaceDefSeq --
      ----------------------------------------

      procedure Initialize_ExtLocalInterfaceDefSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ExtLocalInterfaceDefSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ExtLocalInterfaceDefSeq:1.0");
      begin
         if not ExtLocalInterfaceDefSeq_Initialized
         then
            ExtLocalInterfaceDefSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward;
            CORBA.Repository_Root.Helper.TC_ExtLocalInterfaceDefSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ExtLocalInterfaceDefSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_ExtLocalInterfaceDefSeq);
         end if;
      end Initialize_ExtLocalInterfaceDefSeq;

      -------------------------------------------------------
      -- IDL_SEQUENCE_CORBA_Contained_Forward_Element_Wrap --
      -------------------------------------------------------

      function IDL_SEQUENCE_CORBA_Contained_Forward_Element_Wrap
        (X : access CORBA.Repository_Root.Contained_Forward.Ref)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (X.all)'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_Contained_Forward_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Contained_Forward.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_Contained_Forward_Helper.Wrap;

      IDL_SEQUENCE_CORBA_Contained_Forward_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_Contained_Forward --
      -----------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_Contained_Forward is
      begin
         if not IDL_SEQUENCE_CORBA_Contained_Forward_Initialized
         then
            IDL_SEQUENCE_CORBA_Contained_Forward_Initialized :=
              True;
            CORBA.Repository_Root.Contained.Helper.Internals.Initialize_Contained;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_Contained_Forward :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.Contained.Helper.TC_Contained,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_Contained_Forward);
            IDL_SEQUENCE_CORBA_Contained_Forward_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.Contained.Helper.TC_Contained,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_Contained_Forward);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_Contained_Forward);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_Contained_Forward;

      ContainedSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------
      -- Initialize_ContainedSeq --
      -----------------------------

      procedure Initialize_ContainedSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ContainedSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ContainedSeq:1.0");
      begin
         if not ContainedSeq_Initialized
         then
            ContainedSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_Contained_Forward;
            CORBA.Repository_Root.Helper.TC_ContainedSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_Contained_Forward);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ContainedSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_ContainedSeq);
         end if;
      end Initialize_ContainedSeq;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_StructMember;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc);
      begin
         Mech.all :=
           PolyORB.Any.By_Reference;
         case Index is
            when 0 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.name)'Unrestricted_Access);
            when 1 =>
               return CORBA.Wrap
                 (Acc.V.IDL_type'Unrestricted_Access);
            when 2 =>
               return CORBA.Object.Helper.Wrap
                 (CORBA.Object.Ref
                    (Acc.V.type_def)'Unrestricted_Access);
            pragma Warnings (Off);
            when others =>
               raise Constraint_Error;
            pragma Warnings (On);

         end case;
      end Get_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_StructMember)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 3;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_StructMember;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_StructMember)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_StructMember,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_StructMember;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_StructMember)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_StructMember
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_StructMember;
            Content_Ü_StructMember
              (Target.all).V :=
              new CORBA.Repository_Root.StructMember'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_StructMember)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.StructMember,
               Ptr_Ü_StructMember);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.StructMember)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_StructMember'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_StructMember'
              (X.all'Unchecked_Access));
      end Wrap;

      StructMember_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------
      -- Initialize_StructMember --
      -----------------------------

      procedure Initialize_StructMember is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("StructMember");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/StructMember:1.0");
         Argument_Name_Ü_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("name");
         Argument_Name_Ü_IDL_type : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL_type");
         Argument_Name_Ü_type_def : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("type_def");
      begin
         if not StructMember_Initialized
         then
            StructMember_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_StructMember :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_StructMember,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_StructMember,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_StructMember,
               CORBA.To_Any
                 (CORBA.Helper.TC_Identifier));
            CORBA.Internals.Add_Parameter
              (TC_StructMember,
               CORBA.To_Any
                 (Argument_Name_Ü_name));
            CORBA.Internals.Add_Parameter
              (TC_StructMember,
               CORBA.To_Any
                 (CORBA.TC_TypeCode));
            CORBA.Internals.Add_Parameter
              (TC_StructMember,
               CORBA.To_Any
                 (Argument_Name_Ü_IDL_type));
            CORBA.Repository_Root.IDLType.Helper.Internals.Initialize_IDLType;
            CORBA.Internals.Add_Parameter
              (TC_StructMember,
               CORBA.To_Any
                 (CORBA.Repository_Root.IDLType.Helper.TC_IDLType));
            CORBA.Internals.Add_Parameter
              (TC_StructMember,
               CORBA.To_Any
                 (Argument_Name_Ü_type_def));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_StructMember);
            CORBA.TypeCode.Internals.Freeze
              (TC_StructMember);
         end if;
      end Initialize_StructMember;

      --------------------------------------------------
      -- IDL_SEQUENCE_CORBA_StructMember_Element_Wrap --
      --------------------------------------------------

      function IDL_SEQUENCE_CORBA_StructMember_Element_Wrap
        (X : access CORBA.Repository_Root.StructMember)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Repository_Root.Helper.Internals.Wrap
           (X.all'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_StructMember_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_StructMember.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_StructMember_Helper.Wrap;

      IDL_SEQUENCE_CORBA_StructMember_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_StructMember --
      ------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_StructMember is
      begin
         if not IDL_SEQUENCE_CORBA_StructMember_Initialized
         then
            IDL_SEQUENCE_CORBA_StructMember_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_StructMember;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_StructMember :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.Helper.TC_StructMember,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_StructMember);
            IDL_SEQUENCE_CORBA_StructMember_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.Helper.TC_StructMember,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_StructMember);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_StructMember);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_StructMember;

      StructMemberSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------
      -- Initialize_StructMemberSeq --
      --------------------------------

      procedure Initialize_StructMemberSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("StructMemberSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/StructMemberSeq:1.0");
      begin
         if not StructMemberSeq_Initialized
         then
            StructMemberSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_StructMember;
            CORBA.Repository_Root.Helper.TC_StructMemberSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_StructMember);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_StructMemberSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_StructMemberSeq);
         end if;
      end Initialize_StructMemberSeq;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_Initializer;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc);
      begin
         Mech.all :=
           PolyORB.Any.By_Reference;
         case Index is
            when 0 =>
               return CORBA.Repository_Root.Helper.Internals.Wrap
                 (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_StructMember.Sequence
                    (Acc.V.members)'Unrestricted_Access);
            when 1 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.name)'Unrestricted_Access);
            pragma Warnings (Off);
            when others =>
               raise Constraint_Error;
            pragma Warnings (On);

         end case;
      end Get_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_Initializer)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 2;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_Initializer;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_Initializer)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_Initializer,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_Initializer;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_Initializer)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_Initializer
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_Initializer;
            Content_Ü_Initializer
              (Target.all).V :=
              new CORBA.Repository_Root.Initializer'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_Initializer)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.Initializer,
               Ptr_Ü_Initializer);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.Initializer)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_Initializer'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_Initializer'
              (X.all'Unchecked_Access));
      end Wrap;

      Initializer_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------
      -- Initialize_Initializer --
      ----------------------------

      procedure Initialize_Initializer is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("Initializer");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/Initializer:1.0");
         Argument_Name_Ü_members : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("members");
         Argument_Name_Ü_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("name");
      begin
         if not Initializer_Initialized
         then
            Initializer_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_Initializer :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_Initializer,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_Initializer,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Repository_Root.Helper.Internals.Initialize_StructMemberSeq;
            CORBA.Internals.Add_Parameter
              (TC_Initializer,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_StructMemberSeq));
            CORBA.Internals.Add_Parameter
              (TC_Initializer,
               CORBA.To_Any
                 (Argument_Name_Ü_members));
            CORBA.Internals.Add_Parameter
              (TC_Initializer,
               CORBA.To_Any
                 (CORBA.Helper.TC_Identifier));
            CORBA.Internals.Add_Parameter
              (TC_Initializer,
               CORBA.To_Any
                 (Argument_Name_Ü_name));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_Initializer);
            CORBA.TypeCode.Internals.Freeze
              (TC_Initializer);
         end if;
      end Initialize_Initializer;

      -------------------------------------------------
      -- IDL_SEQUENCE_CORBA_Initializer_Element_Wrap --
      -------------------------------------------------

      function IDL_SEQUENCE_CORBA_Initializer_Element_Wrap
        (X : access CORBA.Repository_Root.Initializer)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Repository_Root.Helper.Internals.Wrap
           (X.all'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_Initializer_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Initializer.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_Initializer_Helper.Wrap;

      IDL_SEQUENCE_CORBA_Initializer_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_Initializer --
      -----------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_Initializer is
      begin
         if not IDL_SEQUENCE_CORBA_Initializer_Initialized
         then
            IDL_SEQUENCE_CORBA_Initializer_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_Initializer;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_Initializer :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.Helper.TC_Initializer,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_Initializer);
            IDL_SEQUENCE_CORBA_Initializer_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.Helper.TC_Initializer,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_Initializer);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_Initializer);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_Initializer;

      InitializerSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------
      -- Initialize_InitializerSeq --
      -------------------------------

      procedure Initialize_InitializerSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("InitializerSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/InitializerSeq:1.0");
      begin
         if not InitializerSeq_Initialized
         then
            InitializerSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_Initializer;
            CORBA.Repository_Root.Helper.TC_InitializerSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_Initializer);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_InitializerSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_InitializerSeq);
         end if;
      end Initialize_InitializerSeq;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_UnionMember;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc);
      begin
         Mech.all :=
           PolyORB.Any.By_Reference;
         case Index is
            when 0 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.name)'Unrestricted_Access);
            when 1 =>
               return CORBA.Wrap
                 (Acc.V.label'Unrestricted_Access);
            when 2 =>
               return CORBA.Wrap
                 (Acc.V.IDL_type'Unrestricted_Access);
            when 3 =>
               return CORBA.Object.Helper.Wrap
                 (CORBA.Object.Ref
                    (Acc.V.type_def)'Unrestricted_Access);
            pragma Warnings (Off);
            when others =>
               raise Constraint_Error;
            pragma Warnings (On);

         end case;
      end Get_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_UnionMember)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 4;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_UnionMember;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_UnionMember)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_UnionMember,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_UnionMember;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_UnionMember)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_UnionMember
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_UnionMember;
            Content_Ü_UnionMember
              (Target.all).V :=
              new CORBA.Repository_Root.UnionMember'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_UnionMember)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.UnionMember,
               Ptr_Ü_UnionMember);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.UnionMember)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_UnionMember'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_UnionMember'
              (X.all'Unchecked_Access));
      end Wrap;

      UnionMember_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------
      -- Initialize_UnionMember --
      ----------------------------

      procedure Initialize_UnionMember is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("UnionMember");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/UnionMember:1.0");
         Argument_Name_Ü_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("name");
         Argument_Name_Ü_label : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("label");
         Argument_Name_Ü_IDL_type : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL_type");
         Argument_Name_Ü_type_def : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("type_def");
      begin
         if not UnionMember_Initialized
         then
            UnionMember_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_UnionMember :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_UnionMember,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_UnionMember,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_UnionMember,
               CORBA.To_Any
                 (CORBA.Helper.TC_Identifier));
            CORBA.Internals.Add_Parameter
              (TC_UnionMember,
               CORBA.To_Any
                 (Argument_Name_Ü_name));
            CORBA.Internals.Add_Parameter
              (TC_UnionMember,
               CORBA.To_Any
                 (CORBA.TC_Any));
            CORBA.Internals.Add_Parameter
              (TC_UnionMember,
               CORBA.To_Any
                 (Argument_Name_Ü_label));
            CORBA.Internals.Add_Parameter
              (TC_UnionMember,
               CORBA.To_Any
                 (CORBA.TC_TypeCode));
            CORBA.Internals.Add_Parameter
              (TC_UnionMember,
               CORBA.To_Any
                 (Argument_Name_Ü_IDL_type));
            CORBA.Repository_Root.IDLType.Helper.Internals.Initialize_IDLType;
            CORBA.Internals.Add_Parameter
              (TC_UnionMember,
               CORBA.To_Any
                 (CORBA.Repository_Root.IDLType.Helper.TC_IDLType));
            CORBA.Internals.Add_Parameter
              (TC_UnionMember,
               CORBA.To_Any
                 (Argument_Name_Ü_type_def));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_UnionMember);
            CORBA.TypeCode.Internals.Freeze
              (TC_UnionMember);
         end if;
      end Initialize_UnionMember;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_ExceptionDescription;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc);
      begin
         Mech.all :=
           PolyORB.Any.By_Reference;
         case Index is
            when 0 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.name)'Unrestricted_Access);
            when 1 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.id)'Unrestricted_Access);
            when 2 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.defined_in)'Unrestricted_Access);
            when 3 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.version)'Unrestricted_Access);
            when 4 =>
               return CORBA.Wrap
                 (Acc.V.IDL_type'Unrestricted_Access);
            pragma Warnings (Off);
            when others =>
               raise Constraint_Error;
            pragma Warnings (On);

         end case;
      end Get_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_ExceptionDescription)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 5;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_ExceptionDescription;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_ExceptionDescription)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_ExceptionDescription,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_ExceptionDescription;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_ExceptionDescription)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_ExceptionDescription
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_ExceptionDescription;
            Content_Ü_ExceptionDescription
              (Target.all).V :=
              new CORBA.Repository_Root.ExceptionDescription'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_ExceptionDescription)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.ExceptionDescription,
               Ptr_Ü_ExceptionDescription);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.ExceptionDescription)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_ExceptionDescription'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_ExceptionDescription'
              (X.all'Unchecked_Access));
      end Wrap;

      ExceptionDescription_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------------
      -- Initialize_ExceptionDescription --
      -------------------------------------

      procedure Initialize_ExceptionDescription is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ExceptionDescription");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ExceptionDescription:1.0");
         Argument_Name_Ü_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("name");
         Argument_Name_Ü_id : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("id");
         Argument_Name_Ü_defined_in : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("defined_in");
         Argument_Name_Ü_version : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("version");
         Argument_Name_Ü_IDL_type : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL_type");
      begin
         if not ExceptionDescription_Initialized
         then
            ExceptionDescription_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ExceptionDescription :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_ExceptionDescription,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ExceptionDescription,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ExceptionDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_Identifier));
            CORBA.Internals.Add_Parameter
              (TC_ExceptionDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_name));
            CORBA.Internals.Add_Parameter
              (TC_ExceptionDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_ExceptionDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_id));
            CORBA.Internals.Add_Parameter
              (TC_ExceptionDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_ExceptionDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_defined_in));
            CORBA.Repository_Root.Helper.Internals.Initialize_VersionSpec;
            CORBA.Internals.Add_Parameter
              (TC_ExceptionDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_VersionSpec));
            CORBA.Internals.Add_Parameter
              (TC_ExceptionDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_version));
            CORBA.Internals.Add_Parameter
              (TC_ExceptionDescription,
               CORBA.To_Any
                 (CORBA.TC_TypeCode));
            CORBA.Internals.Add_Parameter
              (TC_ExceptionDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_IDL_type));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ExceptionDescription);
            CORBA.TypeCode.Internals.Freeze
              (TC_ExceptionDescription);
         end if;
      end Initialize_ExceptionDescription;

      ----------------------------------------------------------
      -- IDL_SEQUENCE_CORBA_ExceptionDescription_Element_Wrap --
      ----------------------------------------------------------

      function IDL_SEQUENCE_CORBA_ExceptionDescription_Element_Wrap
        (X : access CORBA.Repository_Root.ExceptionDescription)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Repository_Root.Helper.Internals.Wrap
           (X.all'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_ExceptionDescription_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExceptionDescription.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_ExceptionDescription_Helper.Wrap;

      IDL_SEQUENCE_CORBA_ExceptionDescription_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_ExceptionDescription --
      --------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_ExceptionDescription is
      begin
         if not IDL_SEQUENCE_CORBA_ExceptionDescription_Initialized
         then
            IDL_SEQUENCE_CORBA_ExceptionDescription_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_ExceptionDescription;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExceptionDescription :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.Helper.TC_ExceptionDescription,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExceptionDescription);
            IDL_SEQUENCE_CORBA_ExceptionDescription_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.Helper.TC_ExceptionDescription,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExceptionDescription);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_ExceptionDescription);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_ExceptionDescription;

      ExcDescriptionSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------------
      -- Initialize_ExcDescriptionSeq --
      ----------------------------------

      procedure Initialize_ExcDescriptionSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ExcDescriptionSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ExcDescriptionSeq:1.0");
      begin
         if not ExcDescriptionSeq_Initialized
         then
            ExcDescriptionSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ExceptionDescription;
            CORBA.Repository_Root.Helper.TC_ExcDescriptionSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExceptionDescription);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ExcDescriptionSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_ExcDescriptionSeq);
         end if;
      end Initialize_ExcDescriptionSeq;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_ExtInitializer;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc);
      begin
         Mech.all :=
           PolyORB.Any.By_Reference;
         case Index is
            when 0 =>
               return CORBA.Repository_Root.Helper.Internals.Wrap
                 (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_StructMember.Sequence
                    (Acc.V.members)'Unrestricted_Access);
            when 1 =>
               return CORBA.Repository_Root.Helper.Internals.Wrap
                 (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExceptionDescription.Sequence
                    (Acc.V.exceptions)'Unrestricted_Access);
            when 2 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.name)'Unrestricted_Access);
            pragma Warnings (Off);
            when others =>
               raise Constraint_Error;
            pragma Warnings (On);

         end case;
      end Get_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_ExtInitializer)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 3;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_ExtInitializer;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_ExtInitializer)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_ExtInitializer,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_ExtInitializer;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_ExtInitializer)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_ExtInitializer
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_ExtInitializer;
            Content_Ü_ExtInitializer
              (Target.all).V :=
              new CORBA.Repository_Root.ExtInitializer'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_ExtInitializer)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.ExtInitializer,
               Ptr_Ü_ExtInitializer);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.ExtInitializer)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_ExtInitializer'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_ExtInitializer'
              (X.all'Unchecked_Access));
      end Wrap;

      ExtInitializer_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------
      -- Initialize_ExtInitializer --
      -------------------------------

      procedure Initialize_ExtInitializer is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ExtInitializer");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ExtInitializer:1.0");
         Argument_Name_Ü_members : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("members");
         Argument_Name_Ü_exceptions : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("exceptions");
         Argument_Name_Ü_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("name");
      begin
         if not ExtInitializer_Initialized
         then
            ExtInitializer_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ExtInitializer :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_ExtInitializer,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ExtInitializer,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Repository_Root.Helper.Internals.Initialize_StructMemberSeq;
            CORBA.Internals.Add_Parameter
              (TC_ExtInitializer,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_StructMemberSeq));
            CORBA.Internals.Add_Parameter
              (TC_ExtInitializer,
               CORBA.To_Any
                 (Argument_Name_Ü_members));
            CORBA.Repository_Root.Helper.Internals.Initialize_ExcDescriptionSeq;
            CORBA.Internals.Add_Parameter
              (TC_ExtInitializer,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_ExcDescriptionSeq));
            CORBA.Internals.Add_Parameter
              (TC_ExtInitializer,
               CORBA.To_Any
                 (Argument_Name_Ü_exceptions));
            CORBA.Internals.Add_Parameter
              (TC_ExtInitializer,
               CORBA.To_Any
                 (CORBA.Helper.TC_Identifier));
            CORBA.Internals.Add_Parameter
              (TC_ExtInitializer,
               CORBA.To_Any
                 (Argument_Name_Ü_name));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ExtInitializer);
            CORBA.TypeCode.Internals.Freeze
              (TC_ExtInitializer);
         end if;
      end Initialize_ExtInitializer;

      ----------------------------------------------------
      -- IDL_SEQUENCE_CORBA_ExtInitializer_Element_Wrap --
      ----------------------------------------------------

      function IDL_SEQUENCE_CORBA_ExtInitializer_Element_Wrap
        (X : access CORBA.Repository_Root.ExtInitializer)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Repository_Root.Helper.Internals.Wrap
           (X.all'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_ExtInitializer_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtInitializer.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_ExtInitializer_Helper.Wrap;

      IDL_SEQUENCE_CORBA_ExtInitializer_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_ExtInitializer --
      --------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_ExtInitializer is
      begin
         if not IDL_SEQUENCE_CORBA_ExtInitializer_Initialized
         then
            IDL_SEQUENCE_CORBA_ExtInitializer_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_ExtInitializer;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtInitializer :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.Helper.TC_ExtInitializer,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtInitializer);
            IDL_SEQUENCE_CORBA_ExtInitializer_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.Helper.TC_ExtInitializer,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtInitializer);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_ExtInitializer);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_ExtInitializer;

      ExtInitializerSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------------
      -- Initialize_ExtInitializerSeq --
      ----------------------------------

      procedure Initialize_ExtInitializerSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ExtInitializerSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ExtInitializerSeq:1.0");
      begin
         if not ExtInitializerSeq_Initialized
         then
            ExtInitializerSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ExtInitializer;
            CORBA.Repository_Root.Helper.TC_ExtInitializerSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtInitializer);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ExtInitializerSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_ExtInitializerSeq);
         end if;
      end Initialize_ExtInitializerSeq;

      -------------------------------------------------
      -- IDL_SEQUENCE_CORBA_UnionMember_Element_Wrap --
      -------------------------------------------------

      function IDL_SEQUENCE_CORBA_UnionMember_Element_Wrap
        (X : access CORBA.Repository_Root.UnionMember)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Repository_Root.Helper.Internals.Wrap
           (X.all'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_UnionMember_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_UnionMember.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_UnionMember_Helper.Wrap;

      IDL_SEQUENCE_CORBA_UnionMember_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_UnionMember --
      -----------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_UnionMember is
      begin
         if not IDL_SEQUENCE_CORBA_UnionMember_Initialized
         then
            IDL_SEQUENCE_CORBA_UnionMember_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_UnionMember;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_UnionMember :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.Helper.TC_UnionMember,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_UnionMember);
            IDL_SEQUENCE_CORBA_UnionMember_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.Helper.TC_UnionMember,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_UnionMember);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_UnionMember);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_UnionMember;

      UnionMemberSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------
      -- Initialize_UnionMemberSeq --
      -------------------------------

      procedure Initialize_UnionMemberSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("UnionMemberSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/UnionMemberSeq:1.0");
      begin
         if not UnionMemberSeq_Initialized
         then
            UnionMemberSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_UnionMember;
            CORBA.Repository_Root.Helper.TC_UnionMemberSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_UnionMember);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_UnionMemberSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_UnionMemberSeq);
         end if;
      end Initialize_UnionMemberSeq;

      ------------------------------------------------
      -- IDL_SEQUENCE_CORBA_Identifier_Element_Wrap --
      ------------------------------------------------

      function IDL_SEQUENCE_CORBA_Identifier_Element_Wrap
        (X : access CORBA.Identifier)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Wrap
           (CORBA.String
              (X.all)'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_Identifier_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Identifier.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_Identifier_Helper.Wrap;

      IDL_SEQUENCE_CORBA_Identifier_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_Identifier --
      ----------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_Identifier is
      begin
         if not IDL_SEQUENCE_CORBA_Identifier_Initialized
         then
            IDL_SEQUENCE_CORBA_Identifier_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_Identifier :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Helper.TC_Identifier,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_Identifier);
            IDL_SEQUENCE_CORBA_Identifier_Helper.Initialize
              (Element_TC => CORBA.Helper.TC_Identifier,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_Identifier);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_Identifier);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_Identifier;

      EnumMemberSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------
      -- Initialize_EnumMemberSeq --
      ------------------------------

      procedure Initialize_EnumMemberSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("EnumMemberSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/EnumMemberSeq:1.0");
      begin
         if not EnumMemberSeq_Initialized
         then
            EnumMemberSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_Identifier;
            CORBA.Repository_Root.Helper.TC_EnumMemberSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_Identifier);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_EnumMemberSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_EnumMemberSeq);
         end if;
      end Initialize_EnumMemberSeq;

      --------------
      -- From_Any --
      --------------

      function From_Any
        (C : PolyORB.Any.Any_Container'Class)
        return CORBA.Repository_Root.PrimitiveKind
      is
      begin
         return CORBA.Repository_Root.PrimitiveKind'Val
           (PolyORB.Types.Unsigned_Long'
              (PolyORB.Any.Get_Aggregate_Element
                 (C,
                  0)));
      end From_Any;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_PrimitiveKind;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc, Index);
      begin
         Acc.Repr_Cache :=
           CORBA.Repository_Root.PrimitiveKind'Pos
              (Acc.V.all);
         Mech.all :=
           PolyORB.Any.By_Value;
         return PolyORB.Any.Wrap
           (Acc.Repr_Cache'Unrestricted_Access);
      end Get_Aggregate_Element;

      ---------------------------
      -- Set_Aggregate_Element --
      ---------------------------

      procedure Set_Aggregate_Element
        (Acc : in out Content_Ü_PrimitiveKind;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         From_C : in out PolyORB.Any.Any_Container'Class)
      is
         use type PolyORB.Types.Unsigned_Long;
         pragma Assert ((Index
            = 0));
         pragma Unreferenced (Tc);
      begin
         Acc.V.all :=
           CORBA.Repository_Root.PrimitiveKind'Val
              (PolyORB.Types.Unsigned_Long'
                 (PolyORB.Any.From_Any
                    (From_C)));
      end Set_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_PrimitiveKind)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 1;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_PrimitiveKind;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_PrimitiveKind)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_PrimitiveKind,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_PrimitiveKind;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_PrimitiveKind)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_PrimitiveKind
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_PrimitiveKind;
            Content_Ü_PrimitiveKind
              (Target.all).V :=
              new CORBA.Repository_Root.PrimitiveKind'
                 (Acc.V.all);
         end if;
         Content_Ü_PrimitiveKind
           (Target.all).Repr_Cache :=
           Acc.Repr_Cache;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_PrimitiveKind)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.PrimitiveKind,
               Ptr_Ü_PrimitiveKind);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.PrimitiveKind)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_PrimitiveKind'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_PrimitiveKind'
              (X.all'Unchecked_Access),
            Repr_Cache => 0);
      end Wrap;

      PrimitiveKind_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------
      -- Initialize_PrimitiveKind --
      ------------------------------

      procedure Initialize_PrimitiveKind is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("PrimitiveKind");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/PrimitiveKind:1.0");
         pk_null_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_null");
         pk_void_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_void");
         pk_short_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_short");
         pk_long_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_long");
         pk_ushort_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_ushort");
         pk_ulong_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_ulong");
         pk_float_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_float");
         pk_double_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_double");
         pk_boolean_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_boolean");
         pk_char_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_char");
         pk_octet_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_octet");
         pk_any_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_any");
         pk_TypeCode_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_TypeCode");
         pk_Principal_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_Principal");
         pk_string_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_string");
         pk_objref_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_objref");
         pk_longlong_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_longlong");
         pk_ulonglong_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_ulonglong");
         pk_longdouble_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_longdouble");
         pk_wchar_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_wchar");
         pk_wstring_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_wstring");
         pk_value_base_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("pk_value_base");
      begin
         if not PrimitiveKind_Initialized
         then
            PrimitiveKind_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_PrimitiveKind :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Enum);
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_null_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_void_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_short_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_long_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_ushort_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_ulong_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_float_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_double_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_boolean_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_char_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_octet_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_any_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_TypeCode_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_Principal_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_string_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_objref_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_longlong_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_ulonglong_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_longdouble_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_wchar_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_wstring_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_PrimitiveKind,
               CORBA.To_Any
                 (pk_value_base_Name_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_PrimitiveKind);
            CORBA.TypeCode.Internals.Freeze
              (TC_PrimitiveKind);
         end if;
      end Initialize_PrimitiveKind;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_ModuleDescription;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc);
      begin
         Mech.all :=
           PolyORB.Any.By_Reference;
         case Index is
            when 0 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.name)'Unrestricted_Access);
            when 1 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.id)'Unrestricted_Access);
            when 2 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.defined_in)'Unrestricted_Access);
            when 3 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.version)'Unrestricted_Access);
            pragma Warnings (Off);
            when others =>
               raise Constraint_Error;
            pragma Warnings (On);

         end case;
      end Get_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_ModuleDescription)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 4;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_ModuleDescription;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_ModuleDescription)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_ModuleDescription,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_ModuleDescription;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_ModuleDescription)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_ModuleDescription
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_ModuleDescription;
            Content_Ü_ModuleDescription
              (Target.all).V :=
              new CORBA.Repository_Root.ModuleDescription'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_ModuleDescription)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.ModuleDescription,
               Ptr_Ü_ModuleDescription);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.ModuleDescription)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_ModuleDescription'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_ModuleDescription'
              (X.all'Unchecked_Access));
      end Wrap;

      ModuleDescription_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------------
      -- Initialize_ModuleDescription --
      ----------------------------------

      procedure Initialize_ModuleDescription is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ModuleDescription");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ModuleDescription:1.0");
         Argument_Name_Ü_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("name");
         Argument_Name_Ü_id : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("id");
         Argument_Name_Ü_defined_in : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("defined_in");
         Argument_Name_Ü_version : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("version");
      begin
         if not ModuleDescription_Initialized
         then
            ModuleDescription_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ModuleDescription :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_ModuleDescription,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ModuleDescription,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ModuleDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_Identifier));
            CORBA.Internals.Add_Parameter
              (TC_ModuleDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_name));
            CORBA.Internals.Add_Parameter
              (TC_ModuleDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_ModuleDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_id));
            CORBA.Internals.Add_Parameter
              (TC_ModuleDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_ModuleDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_defined_in));
            CORBA.Repository_Root.Helper.Internals.Initialize_VersionSpec;
            CORBA.Internals.Add_Parameter
              (TC_ModuleDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_VersionSpec));
            CORBA.Internals.Add_Parameter
              (TC_ModuleDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_version));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ModuleDescription);
            CORBA.TypeCode.Internals.Freeze
              (TC_ModuleDescription);
         end if;
      end Initialize_ModuleDescription;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_ConstantDescription;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc);
      begin
         Mech.all :=
           PolyORB.Any.By_Reference;
         case Index is
            when 0 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.name)'Unrestricted_Access);
            when 1 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.id)'Unrestricted_Access);
            when 2 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.defined_in)'Unrestricted_Access);
            when 3 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.version)'Unrestricted_Access);
            when 4 =>
               return CORBA.Wrap
                 (Acc.V.IDL_type'Unrestricted_Access);
            when 5 =>
               return CORBA.Wrap
                 (Acc.V.value'Unrestricted_Access);
            pragma Warnings (Off);
            when others =>
               raise Constraint_Error;
            pragma Warnings (On);

         end case;
      end Get_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_ConstantDescription)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 6;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_ConstantDescription;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_ConstantDescription)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_ConstantDescription,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_ConstantDescription;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_ConstantDescription)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_ConstantDescription
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_ConstantDescription;
            Content_Ü_ConstantDescription
              (Target.all).V :=
              new CORBA.Repository_Root.ConstantDescription'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_ConstantDescription)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.ConstantDescription,
               Ptr_Ü_ConstantDescription);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.ConstantDescription)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_ConstantDescription'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_ConstantDescription'
              (X.all'Unchecked_Access));
      end Wrap;

      ConstantDescription_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------------
      -- Initialize_ConstantDescription --
      ------------------------------------

      procedure Initialize_ConstantDescription is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ConstantDescription");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ConstantDescription:1.0");
         Argument_Name_Ü_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("name");
         Argument_Name_Ü_id : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("id");
         Argument_Name_Ü_defined_in : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("defined_in");
         Argument_Name_Ü_version : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("version");
         Argument_Name_Ü_IDL_type : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL_type");
         Argument_Name_Ü_value : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("value");
      begin
         if not ConstantDescription_Initialized
         then
            ConstantDescription_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ConstantDescription :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_ConstantDescription,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ConstantDescription,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ConstantDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_Identifier));
            CORBA.Internals.Add_Parameter
              (TC_ConstantDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_name));
            CORBA.Internals.Add_Parameter
              (TC_ConstantDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_ConstantDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_id));
            CORBA.Internals.Add_Parameter
              (TC_ConstantDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_ConstantDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_defined_in));
            CORBA.Repository_Root.Helper.Internals.Initialize_VersionSpec;
            CORBA.Internals.Add_Parameter
              (TC_ConstantDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_VersionSpec));
            CORBA.Internals.Add_Parameter
              (TC_ConstantDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_version));
            CORBA.Internals.Add_Parameter
              (TC_ConstantDescription,
               CORBA.To_Any
                 (CORBA.TC_TypeCode));
            CORBA.Internals.Add_Parameter
              (TC_ConstantDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_IDL_type));
            CORBA.Internals.Add_Parameter
              (TC_ConstantDescription,
               CORBA.To_Any
                 (CORBA.TC_Any));
            CORBA.Internals.Add_Parameter
              (TC_ConstantDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_value));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ConstantDescription);
            CORBA.TypeCode.Internals.Freeze
              (TC_ConstantDescription);
         end if;
      end Initialize_ConstantDescription;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_TypeDescription;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc);
      begin
         Mech.all :=
           PolyORB.Any.By_Reference;
         case Index is
            when 0 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.name)'Unrestricted_Access);
            when 1 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.id)'Unrestricted_Access);
            when 2 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.defined_in)'Unrestricted_Access);
            when 3 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.version)'Unrestricted_Access);
            when 4 =>
               return CORBA.Wrap
                 (Acc.V.IDL_type'Unrestricted_Access);
            pragma Warnings (Off);
            when others =>
               raise Constraint_Error;
            pragma Warnings (On);

         end case;
      end Get_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_TypeDescription)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 5;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_TypeDescription;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_TypeDescription)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_TypeDescription,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_TypeDescription;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_TypeDescription)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_TypeDescription
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_TypeDescription;
            Content_Ü_TypeDescription
              (Target.all).V :=
              new CORBA.Repository_Root.TypeDescription'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_TypeDescription)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.TypeDescription,
               Ptr_Ü_TypeDescription);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.TypeDescription)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_TypeDescription'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_TypeDescription'
              (X.all'Unchecked_Access));
      end Wrap;

      TypeDescription_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------
      -- Initialize_TypeDescription --
      --------------------------------

      procedure Initialize_TypeDescription is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("TypeDescription");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/TypeDescription:1.0");
         Argument_Name_Ü_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("name");
         Argument_Name_Ü_id : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("id");
         Argument_Name_Ü_defined_in : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("defined_in");
         Argument_Name_Ü_version : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("version");
         Argument_Name_Ü_IDL_type : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL_type");
      begin
         if not TypeDescription_Initialized
         then
            TypeDescription_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_TypeDescription :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_TypeDescription,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_TypeDescription,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_TypeDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_Identifier));
            CORBA.Internals.Add_Parameter
              (TC_TypeDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_name));
            CORBA.Internals.Add_Parameter
              (TC_TypeDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_TypeDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_id));
            CORBA.Internals.Add_Parameter
              (TC_TypeDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_TypeDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_defined_in));
            CORBA.Repository_Root.Helper.Internals.Initialize_VersionSpec;
            CORBA.Internals.Add_Parameter
              (TC_TypeDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_VersionSpec));
            CORBA.Internals.Add_Parameter
              (TC_TypeDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_version));
            CORBA.Internals.Add_Parameter
              (TC_TypeDescription,
               CORBA.To_Any
                 (CORBA.TC_TypeCode));
            CORBA.Internals.Add_Parameter
              (TC_TypeDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_IDL_type));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_TypeDescription);
            CORBA.TypeCode.Internals.Freeze
              (TC_TypeDescription);
         end if;
      end Initialize_TypeDescription;

      --------------
      -- From_Any --
      --------------

      function From_Any
        (C : PolyORB.Any.Any_Container'Class)
        return CORBA.Repository_Root.AttributeMode
      is
      begin
         return CORBA.Repository_Root.AttributeMode'Val
           (PolyORB.Types.Unsigned_Long'
              (PolyORB.Any.Get_Aggregate_Element
                 (C,
                  0)));
      end From_Any;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_AttributeMode;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc, Index);
      begin
         Acc.Repr_Cache :=
           CORBA.Repository_Root.AttributeMode'Pos
              (Acc.V.all);
         Mech.all :=
           PolyORB.Any.By_Value;
         return PolyORB.Any.Wrap
           (Acc.Repr_Cache'Unrestricted_Access);
      end Get_Aggregate_Element;

      ---------------------------
      -- Set_Aggregate_Element --
      ---------------------------

      procedure Set_Aggregate_Element
        (Acc : in out Content_Ü_AttributeMode;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         From_C : in out PolyORB.Any.Any_Container'Class)
      is
         use type PolyORB.Types.Unsigned_Long;
         pragma Assert ((Index
            = 0));
         pragma Unreferenced (Tc);
      begin
         Acc.V.all :=
           CORBA.Repository_Root.AttributeMode'Val
              (PolyORB.Types.Unsigned_Long'
                 (PolyORB.Any.From_Any
                    (From_C)));
      end Set_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_AttributeMode)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 1;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_AttributeMode;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_AttributeMode)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_AttributeMode,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_AttributeMode;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_AttributeMode)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_AttributeMode
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_AttributeMode;
            Content_Ü_AttributeMode
              (Target.all).V :=
              new CORBA.Repository_Root.AttributeMode'
                 (Acc.V.all);
         end if;
         Content_Ü_AttributeMode
           (Target.all).Repr_Cache :=
           Acc.Repr_Cache;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_AttributeMode)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.AttributeMode,
               Ptr_Ü_AttributeMode);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.AttributeMode)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_AttributeMode'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_AttributeMode'
              (X.all'Unchecked_Access),
            Repr_Cache => 0);
      end Wrap;

      AttributeMode_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------
      -- Initialize_AttributeMode --
      ------------------------------

      procedure Initialize_AttributeMode is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("AttributeMode");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/AttributeMode:1.0");
         ATTR_NORMAL_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ATTR_NORMAL");
         ATTR_READONLY_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ATTR_READONLY");
      begin
         if not AttributeMode_Initialized
         then
            AttributeMode_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_AttributeMode :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Enum);
            CORBA.Internals.Add_Parameter
              (TC_AttributeMode,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_AttributeMode,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_AttributeMode,
               CORBA.To_Any
                 (ATTR_NORMAL_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_AttributeMode,
               CORBA.To_Any
                 (ATTR_READONLY_Name_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_AttributeMode);
            CORBA.TypeCode.Internals.Freeze
              (TC_AttributeMode);
         end if;
      end Initialize_AttributeMode;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_AttributeDescription;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc);
      begin
         Mech.all :=
           PolyORB.Any.By_Reference;
         case Index is
            when 0 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.name)'Unrestricted_Access);
            when 1 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.id)'Unrestricted_Access);
            when 2 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.defined_in)'Unrestricted_Access);
            when 3 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.version)'Unrestricted_Access);
            when 4 =>
               return CORBA.Wrap
                 (Acc.V.IDL_type'Unrestricted_Access);
            when 5 =>
               return CORBA.Repository_Root.Helper.Internals.Wrap
                 (Acc.V.mode'Unrestricted_Access);
            pragma Warnings (Off);
            when others =>
               raise Constraint_Error;
            pragma Warnings (On);

         end case;
      end Get_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_AttributeDescription)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 6;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_AttributeDescription;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_AttributeDescription)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_AttributeDescription,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_AttributeDescription;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_AttributeDescription)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_AttributeDescription
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_AttributeDescription;
            Content_Ü_AttributeDescription
              (Target.all).V :=
              new CORBA.Repository_Root.AttributeDescription'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_AttributeDescription)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.AttributeDescription,
               Ptr_Ü_AttributeDescription);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.AttributeDescription)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_AttributeDescription'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_AttributeDescription'
              (X.all'Unchecked_Access));
      end Wrap;

      AttributeDescription_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------------
      -- Initialize_AttributeDescription --
      -------------------------------------

      procedure Initialize_AttributeDescription is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("AttributeDescription");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/AttributeDescription:1.0");
         Argument_Name_Ü_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("name");
         Argument_Name_Ü_id : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("id");
         Argument_Name_Ü_defined_in : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("defined_in");
         Argument_Name_Ü_version : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("version");
         Argument_Name_Ü_IDL_type : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL_type");
         Argument_Name_Ü_mode : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("mode");
      begin
         if not AttributeDescription_Initialized
         then
            AttributeDescription_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_AttributeDescription :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_AttributeDescription,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_AttributeDescription,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_AttributeDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_Identifier));
            CORBA.Internals.Add_Parameter
              (TC_AttributeDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_name));
            CORBA.Internals.Add_Parameter
              (TC_AttributeDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_AttributeDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_id));
            CORBA.Internals.Add_Parameter
              (TC_AttributeDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_AttributeDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_defined_in));
            CORBA.Repository_Root.Helper.Internals.Initialize_VersionSpec;
            CORBA.Internals.Add_Parameter
              (TC_AttributeDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_VersionSpec));
            CORBA.Internals.Add_Parameter
              (TC_AttributeDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_version));
            CORBA.Internals.Add_Parameter
              (TC_AttributeDescription,
               CORBA.To_Any
                 (CORBA.TC_TypeCode));
            CORBA.Internals.Add_Parameter
              (TC_AttributeDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_IDL_type));
            CORBA.Repository_Root.Helper.Internals.Initialize_AttributeMode;
            CORBA.Internals.Add_Parameter
              (TC_AttributeDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_AttributeMode));
            CORBA.Internals.Add_Parameter
              (TC_AttributeDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_mode));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_AttributeDescription);
            CORBA.TypeCode.Internals.Freeze
              (TC_AttributeDescription);
         end if;
      end Initialize_AttributeDescription;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_ExtAttributeDescription;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc);
      begin
         Mech.all :=
           PolyORB.Any.By_Reference;
         case Index is
            when 0 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.name)'Unrestricted_Access);
            when 1 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.id)'Unrestricted_Access);
            when 2 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.defined_in)'Unrestricted_Access);
            when 3 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.version)'Unrestricted_Access);
            when 4 =>
               return CORBA.Wrap
                 (Acc.V.IDL_type'Unrestricted_Access);
            when 5 =>
               return CORBA.Repository_Root.Helper.Internals.Wrap
                 (Acc.V.mode'Unrestricted_Access);
            when 6 =>
               return CORBA.Repository_Root.Helper.Internals.Wrap
                 (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExceptionDescription.Sequence
                    (Acc.V.get_exceptions)'Unrestricted_Access);
            when 7 =>
               return CORBA.Repository_Root.Helper.Internals.Wrap
                 (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExceptionDescription.Sequence
                    (Acc.V.put_exceptions)'Unrestricted_Access);
            pragma Warnings (Off);
            when others =>
               raise Constraint_Error;
            pragma Warnings (On);

         end case;
      end Get_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_ExtAttributeDescription)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 8;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_ExtAttributeDescription;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_ExtAttributeDescription)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_ExtAttributeDescription,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_ExtAttributeDescription;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_ExtAttributeDescription)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_ExtAttributeDescription
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_ExtAttributeDescription;
            Content_Ü_ExtAttributeDescription
              (Target.all).V :=
              new CORBA.Repository_Root.ExtAttributeDescription'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_ExtAttributeDescription)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.ExtAttributeDescription,
               Ptr_Ü_ExtAttributeDescription);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.ExtAttributeDescription)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_ExtAttributeDescription'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_ExtAttributeDescription'
              (X.all'Unchecked_Access));
      end Wrap;

      ExtAttributeDescription_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------------------
      -- Initialize_ExtAttributeDescription --
      ----------------------------------------

      procedure Initialize_ExtAttributeDescription is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ExtAttributeDescription");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ExtAttributeDescription:1.0");
         Argument_Name_Ü_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("name");
         Argument_Name_Ü_id : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("id");
         Argument_Name_Ü_defined_in : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("defined_in");
         Argument_Name_Ü_version : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("version");
         Argument_Name_Ü_IDL_type : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL_type");
         Argument_Name_Ü_mode : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("mode");
         Argument_Name_Ü_get_exceptions : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("get_exceptions");
         Argument_Name_Ü_put_exceptions : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("put_exceptions");
      begin
         if not ExtAttributeDescription_Initialized
         then
            ExtAttributeDescription_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ExtAttributeDescription :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_ExtAttributeDescription,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ExtAttributeDescription,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ExtAttributeDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_Identifier));
            CORBA.Internals.Add_Parameter
              (TC_ExtAttributeDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_name));
            CORBA.Internals.Add_Parameter
              (TC_ExtAttributeDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_ExtAttributeDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_id));
            CORBA.Internals.Add_Parameter
              (TC_ExtAttributeDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_ExtAttributeDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_defined_in));
            CORBA.Repository_Root.Helper.Internals.Initialize_VersionSpec;
            CORBA.Internals.Add_Parameter
              (TC_ExtAttributeDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_VersionSpec));
            CORBA.Internals.Add_Parameter
              (TC_ExtAttributeDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_version));
            CORBA.Internals.Add_Parameter
              (TC_ExtAttributeDescription,
               CORBA.To_Any
                 (CORBA.TC_TypeCode));
            CORBA.Internals.Add_Parameter
              (TC_ExtAttributeDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_IDL_type));
            CORBA.Repository_Root.Helper.Internals.Initialize_AttributeMode;
            CORBA.Internals.Add_Parameter
              (TC_ExtAttributeDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_AttributeMode));
            CORBA.Internals.Add_Parameter
              (TC_ExtAttributeDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_mode));
            CORBA.Repository_Root.Helper.Internals.Initialize_ExcDescriptionSeq;
            CORBA.Internals.Add_Parameter
              (TC_ExtAttributeDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_ExcDescriptionSeq));
            CORBA.Internals.Add_Parameter
              (TC_ExtAttributeDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_get_exceptions));
            CORBA.Repository_Root.Helper.Internals.Initialize_ExcDescriptionSeq;
            CORBA.Internals.Add_Parameter
              (TC_ExtAttributeDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_ExcDescriptionSeq));
            CORBA.Internals.Add_Parameter
              (TC_ExtAttributeDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_put_exceptions));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ExtAttributeDescription);
            CORBA.TypeCode.Internals.Freeze
              (TC_ExtAttributeDescription);
         end if;
      end Initialize_ExtAttributeDescription;

      --------------
      -- From_Any --
      --------------

      function From_Any
        (C : PolyORB.Any.Any_Container'Class)
        return CORBA.Repository_Root.OperationMode
      is
      begin
         return CORBA.Repository_Root.OperationMode'Val
           (PolyORB.Types.Unsigned_Long'
              (PolyORB.Any.Get_Aggregate_Element
                 (C,
                  0)));
      end From_Any;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_OperationMode;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc, Index);
      begin
         Acc.Repr_Cache :=
           CORBA.Repository_Root.OperationMode'Pos
              (Acc.V.all);
         Mech.all :=
           PolyORB.Any.By_Value;
         return PolyORB.Any.Wrap
           (Acc.Repr_Cache'Unrestricted_Access);
      end Get_Aggregate_Element;

      ---------------------------
      -- Set_Aggregate_Element --
      ---------------------------

      procedure Set_Aggregate_Element
        (Acc : in out Content_Ü_OperationMode;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         From_C : in out PolyORB.Any.Any_Container'Class)
      is
         use type PolyORB.Types.Unsigned_Long;
         pragma Assert ((Index
            = 0));
         pragma Unreferenced (Tc);
      begin
         Acc.V.all :=
           CORBA.Repository_Root.OperationMode'Val
              (PolyORB.Types.Unsigned_Long'
                 (PolyORB.Any.From_Any
                    (From_C)));
      end Set_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_OperationMode)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 1;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_OperationMode;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_OperationMode)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_OperationMode,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_OperationMode;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_OperationMode)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_OperationMode
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_OperationMode;
            Content_Ü_OperationMode
              (Target.all).V :=
              new CORBA.Repository_Root.OperationMode'
                 (Acc.V.all);
         end if;
         Content_Ü_OperationMode
           (Target.all).Repr_Cache :=
           Acc.Repr_Cache;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_OperationMode)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.OperationMode,
               Ptr_Ü_OperationMode);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.OperationMode)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_OperationMode'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_OperationMode'
              (X.all'Unchecked_Access),
            Repr_Cache => 0);
      end Wrap;

      OperationMode_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------
      -- Initialize_OperationMode --
      ------------------------------

      procedure Initialize_OperationMode is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("OperationMode");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/OperationMode:1.0");
         OP_NORMAL_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("OP_NORMAL");
         OP_ONEWAY_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("OP_ONEWAY");
      begin
         if not OperationMode_Initialized
         then
            OperationMode_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_OperationMode :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Enum);
            CORBA.Internals.Add_Parameter
              (TC_OperationMode,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_OperationMode,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_OperationMode,
               CORBA.To_Any
                 (OP_NORMAL_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_OperationMode,
               CORBA.To_Any
                 (OP_ONEWAY_Name_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_OperationMode);
            CORBA.TypeCode.Internals.Freeze
              (TC_OperationMode);
         end if;
      end Initialize_OperationMode;

      --------------
      -- From_Any --
      --------------

      function From_Any
        (C : PolyORB.Any.Any_Container'Class)
        return CORBA.Repository_Root.ParameterMode
      is
      begin
         return CORBA.Repository_Root.ParameterMode'Val
           (PolyORB.Types.Unsigned_Long'
              (PolyORB.Any.Get_Aggregate_Element
                 (C,
                  0)));
      end From_Any;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_ParameterMode;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc, Index);
      begin
         Acc.Repr_Cache :=
           CORBA.Repository_Root.ParameterMode'Pos
              (Acc.V.all);
         Mech.all :=
           PolyORB.Any.By_Value;
         return PolyORB.Any.Wrap
           (Acc.Repr_Cache'Unrestricted_Access);
      end Get_Aggregate_Element;

      ---------------------------
      -- Set_Aggregate_Element --
      ---------------------------

      procedure Set_Aggregate_Element
        (Acc : in out Content_Ü_ParameterMode;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         From_C : in out PolyORB.Any.Any_Container'Class)
      is
         use type PolyORB.Types.Unsigned_Long;
         pragma Assert ((Index
            = 0));
         pragma Unreferenced (Tc);
      begin
         Acc.V.all :=
           CORBA.Repository_Root.ParameterMode'Val
              (PolyORB.Types.Unsigned_Long'
                 (PolyORB.Any.From_Any
                    (From_C)));
      end Set_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_ParameterMode)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 1;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_ParameterMode;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_ParameterMode)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_ParameterMode,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_ParameterMode;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_ParameterMode)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_ParameterMode
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_ParameterMode;
            Content_Ü_ParameterMode
              (Target.all).V :=
              new CORBA.Repository_Root.ParameterMode'
                 (Acc.V.all);
         end if;
         Content_Ü_ParameterMode
           (Target.all).Repr_Cache :=
           Acc.Repr_Cache;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_ParameterMode)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.ParameterMode,
               Ptr_Ü_ParameterMode);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.ParameterMode)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_ParameterMode'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_ParameterMode'
              (X.all'Unchecked_Access),
            Repr_Cache => 0);
      end Wrap;

      ParameterMode_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------
      -- Initialize_ParameterMode --
      ------------------------------

      procedure Initialize_ParameterMode is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ParameterMode");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ParameterMode:1.0");
         PARAM_IN_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("PARAM_IN");
         PARAM_OUT_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("PARAM_OUT");
         PARAM_INOUT_Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("PARAM_INOUT");
      begin
         if not ParameterMode_Initialized
         then
            ParameterMode_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ParameterMode :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Enum);
            CORBA.Internals.Add_Parameter
              (TC_ParameterMode,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ParameterMode,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ParameterMode,
               CORBA.To_Any
                 (PARAM_IN_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ParameterMode,
               CORBA.To_Any
                 (PARAM_OUT_Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ParameterMode,
               CORBA.To_Any
                 (PARAM_INOUT_Name_Ü));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ParameterMode);
            CORBA.TypeCode.Internals.Freeze
              (TC_ParameterMode);
         end if;
      end Initialize_ParameterMode;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_ParameterDescription;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc);
      begin
         Mech.all :=
           PolyORB.Any.By_Reference;
         case Index is
            when 0 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.name)'Unrestricted_Access);
            when 1 =>
               return CORBA.Wrap
                 (Acc.V.IDL_type'Unrestricted_Access);
            when 2 =>
               return CORBA.Object.Helper.Wrap
                 (CORBA.Object.Ref
                    (Acc.V.type_def)'Unrestricted_Access);
            when 3 =>
               return CORBA.Repository_Root.Helper.Internals.Wrap
                 (Acc.V.mode'Unrestricted_Access);
            pragma Warnings (Off);
            when others =>
               raise Constraint_Error;
            pragma Warnings (On);

         end case;
      end Get_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_ParameterDescription)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 4;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_ParameterDescription;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_ParameterDescription)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_ParameterDescription,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_ParameterDescription;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_ParameterDescription)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_ParameterDescription
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_ParameterDescription;
            Content_Ü_ParameterDescription
              (Target.all).V :=
              new CORBA.Repository_Root.ParameterDescription'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_ParameterDescription)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.ParameterDescription,
               Ptr_Ü_ParameterDescription);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.ParameterDescription)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_ParameterDescription'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_ParameterDescription'
              (X.all'Unchecked_Access));
      end Wrap;

      ParameterDescription_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------------
      -- Initialize_ParameterDescription --
      -------------------------------------

      procedure Initialize_ParameterDescription is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ParameterDescription");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ParameterDescription:1.0");
         Argument_Name_Ü_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("name");
         Argument_Name_Ü_IDL_type : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL_type");
         Argument_Name_Ü_type_def : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("type_def");
         Argument_Name_Ü_mode : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("mode");
      begin
         if not ParameterDescription_Initialized
         then
            ParameterDescription_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ParameterDescription :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_ParameterDescription,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ParameterDescription,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ParameterDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_Identifier));
            CORBA.Internals.Add_Parameter
              (TC_ParameterDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_name));
            CORBA.Internals.Add_Parameter
              (TC_ParameterDescription,
               CORBA.To_Any
                 (CORBA.TC_TypeCode));
            CORBA.Internals.Add_Parameter
              (TC_ParameterDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_IDL_type));
            CORBA.Repository_Root.IDLType.Helper.Internals.Initialize_IDLType;
            CORBA.Internals.Add_Parameter
              (TC_ParameterDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.IDLType.Helper.TC_IDLType));
            CORBA.Internals.Add_Parameter
              (TC_ParameterDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_type_def));
            CORBA.Repository_Root.Helper.Internals.Initialize_ParameterMode;
            CORBA.Internals.Add_Parameter
              (TC_ParameterDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_ParameterMode));
            CORBA.Internals.Add_Parameter
              (TC_ParameterDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_mode));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ParameterDescription);
            CORBA.TypeCode.Internals.Freeze
              (TC_ParameterDescription);
         end if;
      end Initialize_ParameterDescription;

      ----------------------------------------------------------
      -- IDL_SEQUENCE_CORBA_ParameterDescription_Element_Wrap --
      ----------------------------------------------------------

      function IDL_SEQUENCE_CORBA_ParameterDescription_Element_Wrap
        (X : access CORBA.Repository_Root.ParameterDescription)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Repository_Root.Helper.Internals.Wrap
           (X.all'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_ParameterDescription_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ParameterDescription.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_ParameterDescription_Helper.Wrap;

      IDL_SEQUENCE_CORBA_ParameterDescription_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_ParameterDescription --
      --------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_ParameterDescription is
      begin
         if not IDL_SEQUENCE_CORBA_ParameterDescription_Initialized
         then
            IDL_SEQUENCE_CORBA_ParameterDescription_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_ParameterDescription;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ParameterDescription :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.Helper.TC_ParameterDescription,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ParameterDescription);
            IDL_SEQUENCE_CORBA_ParameterDescription_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.Helper.TC_ParameterDescription,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ParameterDescription);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_ParameterDescription);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_ParameterDescription;

      ParDescriptionSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------------
      -- Initialize_ParDescriptionSeq --
      ----------------------------------

      procedure Initialize_ParDescriptionSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ParDescriptionSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ParDescriptionSeq:1.0");
      begin
         if not ParDescriptionSeq_Initialized
         then
            ParDescriptionSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ParameterDescription;
            CORBA.Repository_Root.Helper.TC_ParDescriptionSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ParameterDescription);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ParDescriptionSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_ParDescriptionSeq);
         end if;
      end Initialize_ParDescriptionSeq;

      ContextIdentifier_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------------
      -- Initialize_ContextIdentifier --
      ----------------------------------

      procedure Initialize_ContextIdentifier is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ContextIdentifier");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ContextIdentifier:1.0");
      begin
         if not ContextIdentifier_Initialized
         then
            ContextIdentifier_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ContextIdentifier :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Helper.TC_Identifier);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ContextIdentifier);
            CORBA.TypeCode.Internals.Freeze
              (TC_ContextIdentifier);
         end if;
      end Initialize_ContextIdentifier;

      -------------------------------------------------------
      -- IDL_SEQUENCE_CORBA_ContextIdentifier_Element_Wrap --
      -------------------------------------------------------

      function IDL_SEQUENCE_CORBA_ContextIdentifier_Element_Wrap
        (X : access CORBA.Repository_Root.ContextIdentifier)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Wrap
           (CORBA.String
              (X.all)'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_ContextIdentifier_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ContextIdentifier.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_ContextIdentifier_Helper.Wrap;

      IDL_SEQUENCE_CORBA_ContextIdentifier_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_ContextIdentifier --
      -----------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_ContextIdentifier is
      begin
         if not IDL_SEQUENCE_CORBA_ContextIdentifier_Initialized
         then
            IDL_SEQUENCE_CORBA_ContextIdentifier_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_ContextIdentifier;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ContextIdentifier :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.Helper.TC_ContextIdentifier,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ContextIdentifier);
            IDL_SEQUENCE_CORBA_ContextIdentifier_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.Helper.TC_ContextIdentifier,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ContextIdentifier);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_ContextIdentifier);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_ContextIdentifier;

      ContextIdSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------
      -- Initialize_ContextIdSeq --
      -----------------------------

      procedure Initialize_ContextIdSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ContextIdSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ContextIdSeq:1.0");
      begin
         if not ContextIdSeq_Initialized
         then
            ContextIdSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ContextIdentifier;
            CORBA.Repository_Root.Helper.TC_ContextIdSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ContextIdentifier);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ContextIdSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_ContextIdSeq);
         end if;
      end Initialize_ContextIdSeq;

      ----------------------------------------------------------
      -- IDL_SEQUENCE_CORBA_ExceptionDef_Forward_Element_Wrap --
      ----------------------------------------------------------

      function IDL_SEQUENCE_CORBA_ExceptionDef_Forward_Element_Wrap
        (X : access CORBA.Repository_Root.ExceptionDef_Forward.Ref)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (X.all)'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_ExceptionDef_Forward_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExceptionDef_Forward.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_ExceptionDef_Forward_Helper.Wrap;

      IDL_SEQUENCE_CORBA_ExceptionDef_Forward_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_ExceptionDef_Forward --
      --------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_ExceptionDef_Forward is
      begin
         if not IDL_SEQUENCE_CORBA_ExceptionDef_Forward_Initialized
         then
            IDL_SEQUENCE_CORBA_ExceptionDef_Forward_Initialized :=
              True;
            CORBA.Repository_Root.ExceptionDef.Helper.Internals.Initialize_ExceptionDef;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExceptionDef_Forward :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.ExceptionDef.Helper.TC_ExceptionDef,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExceptionDef_Forward);
            IDL_SEQUENCE_CORBA_ExceptionDef_Forward_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.ExceptionDef.Helper.TC_ExceptionDef,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExceptionDef_Forward);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_ExceptionDef_Forward);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_ExceptionDef_Forward;

      ExceptionDefSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------
      -- Initialize_ExceptionDefSeq --
      --------------------------------

      procedure Initialize_ExceptionDefSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ExceptionDefSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ExceptionDefSeq:1.0");
      begin
         if not ExceptionDefSeq_Initialized
         then
            ExceptionDefSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ExceptionDef_Forward;
            CORBA.Repository_Root.Helper.TC_ExceptionDefSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExceptionDef_Forward);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ExceptionDefSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_ExceptionDefSeq);
         end if;
      end Initialize_ExceptionDefSeq;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_OperationDescription;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc);
      begin
         Mech.all :=
           PolyORB.Any.By_Reference;
         case Index is
            when 0 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.name)'Unrestricted_Access);
            when 1 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.id)'Unrestricted_Access);
            when 2 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.defined_in)'Unrestricted_Access);
            when 3 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.version)'Unrestricted_Access);
            when 4 =>
               return CORBA.Wrap
                 (Acc.V.result'Unrestricted_Access);
            when 5 =>
               return CORBA.Repository_Root.Helper.Internals.Wrap
                 (Acc.V.mode'Unrestricted_Access);
            when 6 =>
               return CORBA.Repository_Root.Helper.Internals.Wrap
                 (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ContextIdentifier.Sequence
                    (Acc.V.contexts)'Unrestricted_Access);
            when 7 =>
               return CORBA.Repository_Root.Helper.Internals.Wrap
                 (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ParameterDescription.Sequence
                    (Acc.V.parameters)'Unrestricted_Access);
            when 8 =>
               return CORBA.Repository_Root.Helper.Internals.Wrap
                 (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExceptionDescription.Sequence
                    (Acc.V.exceptions)'Unrestricted_Access);
            pragma Warnings (Off);
            when others =>
               raise Constraint_Error;
            pragma Warnings (On);

         end case;
      end Get_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_OperationDescription)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 9;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_OperationDescription;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_OperationDescription)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_OperationDescription,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_OperationDescription;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_OperationDescription)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_OperationDescription
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_OperationDescription;
            Content_Ü_OperationDescription
              (Target.all).V :=
              new CORBA.Repository_Root.OperationDescription'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_OperationDescription)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.OperationDescription,
               Ptr_Ü_OperationDescription);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.OperationDescription)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_OperationDescription'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_OperationDescription'
              (X.all'Unchecked_Access));
      end Wrap;

      OperationDescription_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------------
      -- Initialize_OperationDescription --
      -------------------------------------

      procedure Initialize_OperationDescription is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("OperationDescription");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/OperationDescription:1.0");
         Argument_Name_Ü_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("name");
         Argument_Name_Ü_id : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("id");
         Argument_Name_Ü_defined_in : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("defined_in");
         Argument_Name_Ü_version : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("version");
         Argument_Name_Ü_result : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("result");
         Argument_Name_Ü_mode : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("mode");
         Argument_Name_Ü_contexts : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("contexts");
         Argument_Name_Ü_parameters : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("parameters");
         Argument_Name_Ü_exceptions : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("exceptions");
      begin
         if not OperationDescription_Initialized
         then
            OperationDescription_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_OperationDescription :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_Identifier));
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_name));
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_id));
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_defined_in));
            CORBA.Repository_Root.Helper.Internals.Initialize_VersionSpec;
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_VersionSpec));
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_version));
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (CORBA.TC_TypeCode));
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_result));
            CORBA.Repository_Root.Helper.Internals.Initialize_OperationMode;
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_OperationMode));
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_mode));
            CORBA.Repository_Root.Helper.Internals.Initialize_ContextIdSeq;
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_ContextIdSeq));
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_contexts));
            CORBA.Repository_Root.Helper.Internals.Initialize_ParDescriptionSeq;
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_ParDescriptionSeq));
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_parameters));
            CORBA.Repository_Root.Helper.Internals.Initialize_ExcDescriptionSeq;
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_ExcDescriptionSeq));
            CORBA.Internals.Add_Parameter
              (TC_OperationDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_exceptions));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_OperationDescription);
            CORBA.TypeCode.Internals.Freeze
              (TC_OperationDescription);
         end if;
      end Initialize_OperationDescription;

      --------------------------------------------------
      -- IDL_SEQUENCE_CORBA_RepositoryId_Element_Wrap --
      --------------------------------------------------

      function IDL_SEQUENCE_CORBA_RepositoryId_Element_Wrap
        (X : access CORBA.RepositoryId)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Wrap
           (CORBA.String
              (X.all)'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_RepositoryId_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_RepositoryId.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_RepositoryId_Helper.Wrap;

      IDL_SEQUENCE_CORBA_RepositoryId_Initialized : PolyORB.Std.Boolean :=
        False;

      ------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_RepositoryId --
      ------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_RepositoryId is
      begin
         if not IDL_SEQUENCE_CORBA_RepositoryId_Initialized
         then
            IDL_SEQUENCE_CORBA_RepositoryId_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_RepositoryId :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Helper.TC_RepositoryId,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_RepositoryId);
            IDL_SEQUENCE_CORBA_RepositoryId_Helper.Initialize
              (Element_TC => CORBA.Helper.TC_RepositoryId,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_RepositoryId);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_RepositoryId);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_RepositoryId;

      RepositoryIdSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------
      -- Initialize_RepositoryIdSeq --
      --------------------------------

      procedure Initialize_RepositoryIdSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("RepositoryIdSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/RepositoryIdSeq:1.0");
      begin
         if not RepositoryIdSeq_Initialized
         then
            RepositoryIdSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_RepositoryId;
            CORBA.Repository_Root.Helper.TC_RepositoryIdSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_RepositoryId);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_RepositoryIdSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_RepositoryIdSeq);
         end if;
      end Initialize_RepositoryIdSeq;

      ----------------------------------------------------------
      -- IDL_SEQUENCE_CORBA_OperationDescription_Element_Wrap --
      ----------------------------------------------------------

      function IDL_SEQUENCE_CORBA_OperationDescription_Element_Wrap
        (X : access CORBA.Repository_Root.OperationDescription)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Repository_Root.Helper.Internals.Wrap
           (X.all'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_OperationDescription_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_OperationDescription.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_OperationDescription_Helper.Wrap;

      IDL_SEQUENCE_CORBA_OperationDescription_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_OperationDescription --
      --------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_OperationDescription is
      begin
         if not IDL_SEQUENCE_CORBA_OperationDescription_Initialized
         then
            IDL_SEQUENCE_CORBA_OperationDescription_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_OperationDescription;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_OperationDescription :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.Helper.TC_OperationDescription,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_OperationDescription);
            IDL_SEQUENCE_CORBA_OperationDescription_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.Helper.TC_OperationDescription,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_OperationDescription);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_OperationDescription);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_OperationDescription;

      OpDescriptionSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      ---------------------------------
      -- Initialize_OpDescriptionSeq --
      ---------------------------------

      procedure Initialize_OpDescriptionSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("OpDescriptionSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/OpDescriptionSeq:1.0");
      begin
         if not OpDescriptionSeq_Initialized
         then
            OpDescriptionSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_OperationDescription;
            CORBA.Repository_Root.Helper.TC_OpDescriptionSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_OperationDescription);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_OpDescriptionSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_OpDescriptionSeq);
         end if;
      end Initialize_OpDescriptionSeq;

      ----------------------------------------------------------
      -- IDL_SEQUENCE_CORBA_AttributeDescription_Element_Wrap --
      ----------------------------------------------------------

      function IDL_SEQUENCE_CORBA_AttributeDescription_Element_Wrap
        (X : access CORBA.Repository_Root.AttributeDescription)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Repository_Root.Helper.Internals.Wrap
           (X.all'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_AttributeDescription_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_AttributeDescription.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_AttributeDescription_Helper.Wrap;

      IDL_SEQUENCE_CORBA_AttributeDescription_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_AttributeDescription --
      --------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_AttributeDescription is
      begin
         if not IDL_SEQUENCE_CORBA_AttributeDescription_Initialized
         then
            IDL_SEQUENCE_CORBA_AttributeDescription_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_AttributeDescription;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_AttributeDescription :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.Helper.TC_AttributeDescription,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_AttributeDescription);
            IDL_SEQUENCE_CORBA_AttributeDescription_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.Helper.TC_AttributeDescription,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_AttributeDescription);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_AttributeDescription);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_AttributeDescription;

      AttrDescriptionSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------------
      -- Initialize_AttrDescriptionSeq --
      -----------------------------------

      procedure Initialize_AttrDescriptionSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("AttrDescriptionSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/AttrDescriptionSeq:1.0");
      begin
         if not AttrDescriptionSeq_Initialized
         then
            AttrDescriptionSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_AttributeDescription;
            CORBA.Repository_Root.Helper.TC_AttrDescriptionSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_AttributeDescription);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_AttrDescriptionSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_AttrDescriptionSeq);
         end if;
      end Initialize_AttrDescriptionSeq;

      -------------------------------------------------------------
      -- IDL_SEQUENCE_CORBA_ExtAttributeDescription_Element_Wrap --
      -------------------------------------------------------------

      function IDL_SEQUENCE_CORBA_ExtAttributeDescription_Element_Wrap
        (X : access CORBA.Repository_Root.ExtAttributeDescription)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Repository_Root.Helper.Internals.Wrap
           (X.all'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_ExtAttributeDescription_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtAttributeDescription.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_ExtAttributeDescription_Helper.Wrap;

      IDL_SEQUENCE_CORBA_ExtAttributeDescription_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_ExtAttributeDescription --
      -----------------------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_ExtAttributeDescription is
      begin
         if not IDL_SEQUENCE_CORBA_ExtAttributeDescription_Initialized
         then
            IDL_SEQUENCE_CORBA_ExtAttributeDescription_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_ExtAttributeDescription;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtAttributeDescription :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.Helper.TC_ExtAttributeDescription,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtAttributeDescription);
            IDL_SEQUENCE_CORBA_ExtAttributeDescription_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.Helper.TC_ExtAttributeDescription,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtAttributeDescription);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_ExtAttributeDescription);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_ExtAttributeDescription;

      ExtAttrDescriptionSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      --------------------------------------
      -- Initialize_ExtAttrDescriptionSeq --
      --------------------------------------

      procedure Initialize_ExtAttrDescriptionSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ExtAttrDescriptionSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ExtAttrDescriptionSeq:1.0");
      begin
         if not ExtAttrDescriptionSeq_Initialized
         then
            ExtAttrDescriptionSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ExtAttributeDescription;
            CORBA.Repository_Root.Helper.TC_ExtAttrDescriptionSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ExtAttributeDescription);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ExtAttrDescriptionSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_ExtAttrDescriptionSeq);
         end if;
      end Initialize_ExtAttrDescriptionSeq;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_InterfaceDescription;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc);
      begin
         Mech.all :=
           PolyORB.Any.By_Reference;
         case Index is
            when 0 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.name)'Unrestricted_Access);
            when 1 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.id)'Unrestricted_Access);
            when 2 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.defined_in)'Unrestricted_Access);
            when 3 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.version)'Unrestricted_Access);
            when 4 =>
               return CORBA.Repository_Root.Helper.Internals.Wrap
                 (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_RepositoryId.Sequence
                    (Acc.V.base_interfaces)'Unrestricted_Access);
            when 5 =>
               return CORBA.Wrap
                 (Acc.V.is_abstract'Unrestricted_Access);
            pragma Warnings (Off);
            when others =>
               raise Constraint_Error;
            pragma Warnings (On);

         end case;
      end Get_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_InterfaceDescription)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 6;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_InterfaceDescription;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_InterfaceDescription)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_InterfaceDescription,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_InterfaceDescription;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_InterfaceDescription)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_InterfaceDescription
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_InterfaceDescription;
            Content_Ü_InterfaceDescription
              (Target.all).V :=
              new CORBA.Repository_Root.InterfaceDescription'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_InterfaceDescription)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.InterfaceDescription,
               Ptr_Ü_InterfaceDescription);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.InterfaceDescription)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_InterfaceDescription'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_InterfaceDescription'
              (X.all'Unchecked_Access));
      end Wrap;

      InterfaceDescription_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------------
      -- Initialize_InterfaceDescription --
      -------------------------------------

      procedure Initialize_InterfaceDescription is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("InterfaceDescription");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/InterfaceDescription:1.0");
         Argument_Name_Ü_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("name");
         Argument_Name_Ü_id : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("id");
         Argument_Name_Ü_defined_in : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("defined_in");
         Argument_Name_Ü_version : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("version");
         Argument_Name_Ü_base_interfaces : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("base_interfaces");
         Argument_Name_Ü_is_abstract : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("is_abstract");
      begin
         if not InterfaceDescription_Initialized
         then
            InterfaceDescription_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_InterfaceDescription :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_InterfaceDescription,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_InterfaceDescription,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_InterfaceDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_Identifier));
            CORBA.Internals.Add_Parameter
              (TC_InterfaceDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_name));
            CORBA.Internals.Add_Parameter
              (TC_InterfaceDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_InterfaceDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_id));
            CORBA.Internals.Add_Parameter
              (TC_InterfaceDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_InterfaceDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_defined_in));
            CORBA.Repository_Root.Helper.Internals.Initialize_VersionSpec;
            CORBA.Internals.Add_Parameter
              (TC_InterfaceDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_VersionSpec));
            CORBA.Internals.Add_Parameter
              (TC_InterfaceDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_version));
            CORBA.Repository_Root.Helper.Internals.Initialize_RepositoryIdSeq;
            CORBA.Internals.Add_Parameter
              (TC_InterfaceDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_RepositoryIdSeq));
            CORBA.Internals.Add_Parameter
              (TC_InterfaceDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_base_interfaces));
            CORBA.Internals.Add_Parameter
              (TC_InterfaceDescription,
               CORBA.To_Any
                 (CORBA.TC_Boolean));
            CORBA.Internals.Add_Parameter
              (TC_InterfaceDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_is_abstract));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_InterfaceDescription);
            CORBA.TypeCode.Internals.Freeze
              (TC_InterfaceDescription);
         end if;
      end Initialize_InterfaceDescription;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_ValueMember;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc);
      begin
         Mech.all :=
           PolyORB.Any.By_Reference;
         case Index is
            when 0 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.name)'Unrestricted_Access);
            when 1 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.id)'Unrestricted_Access);
            when 2 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.defined_in)'Unrestricted_Access);
            when 3 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.version)'Unrestricted_Access);
            when 4 =>
               return CORBA.Wrap
                 (Acc.V.IDL_type'Unrestricted_Access);
            when 5 =>
               return CORBA.Object.Helper.Wrap
                 (CORBA.Object.Ref
                    (Acc.V.type_def)'Unrestricted_Access);
            when 6 =>
               return CORBA.Wrap
                 (CORBA.Short
                    (Acc.V.IDL_access)'Unrestricted_Access);
            pragma Warnings (Off);
            when others =>
               raise Constraint_Error;
            pragma Warnings (On);

         end case;
      end Get_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_ValueMember)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 7;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_ValueMember;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_ValueMember)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_ValueMember,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_ValueMember;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_ValueMember)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_ValueMember
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_ValueMember;
            Content_Ü_ValueMember
              (Target.all).V :=
              new CORBA.Repository_Root.ValueMember'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_ValueMember)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.ValueMember,
               Ptr_Ü_ValueMember);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.ValueMember)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_ValueMember'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_ValueMember'
              (X.all'Unchecked_Access));
      end Wrap;

      ValueMember_Initialized : PolyORB.Std.Boolean :=
        False;

      ----------------------------
      -- Initialize_ValueMember --
      ----------------------------

      procedure Initialize_ValueMember is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ValueMember");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ValueMember:1.0");
         Argument_Name_Ü_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("name");
         Argument_Name_Ü_id : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("id");
         Argument_Name_Ü_defined_in : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("defined_in");
         Argument_Name_Ü_version : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("version");
         Argument_Name_Ü_IDL_type : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL_type");
         Argument_Name_Ü_type_def : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("type_def");
         Argument_Name_Ü_IDL_access : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL_access");
      begin
         if not ValueMember_Initialized
         then
            ValueMember_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ValueMember :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_ValueMember,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ValueMember,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ValueMember,
               CORBA.To_Any
                 (CORBA.Helper.TC_Identifier));
            CORBA.Internals.Add_Parameter
              (TC_ValueMember,
               CORBA.To_Any
                 (Argument_Name_Ü_name));
            CORBA.Internals.Add_Parameter
              (TC_ValueMember,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_ValueMember,
               CORBA.To_Any
                 (Argument_Name_Ü_id));
            CORBA.Internals.Add_Parameter
              (TC_ValueMember,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_ValueMember,
               CORBA.To_Any
                 (Argument_Name_Ü_defined_in));
            CORBA.Repository_Root.Helper.Internals.Initialize_VersionSpec;
            CORBA.Internals.Add_Parameter
              (TC_ValueMember,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_VersionSpec));
            CORBA.Internals.Add_Parameter
              (TC_ValueMember,
               CORBA.To_Any
                 (Argument_Name_Ü_version));
            CORBA.Internals.Add_Parameter
              (TC_ValueMember,
               CORBA.To_Any
                 (CORBA.TC_TypeCode));
            CORBA.Internals.Add_Parameter
              (TC_ValueMember,
               CORBA.To_Any
                 (Argument_Name_Ü_IDL_type));
            CORBA.Repository_Root.IDLType.Helper.Internals.Initialize_IDLType;
            CORBA.Internals.Add_Parameter
              (TC_ValueMember,
               CORBA.To_Any
                 (CORBA.Repository_Root.IDLType.Helper.TC_IDLType));
            CORBA.Internals.Add_Parameter
              (TC_ValueMember,
               CORBA.To_Any
                 (Argument_Name_Ü_type_def));
            CORBA.Internals.Add_Parameter
              (TC_ValueMember,
               CORBA.To_Any
                 (CORBA.Helper.TC_Visibility));
            CORBA.Internals.Add_Parameter
              (TC_ValueMember,
               CORBA.To_Any
                 (Argument_Name_Ü_IDL_access));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ValueMember);
            CORBA.TypeCode.Internals.Freeze
              (TC_ValueMember);
         end if;
      end Initialize_ValueMember;

      -------------------------------------------------
      -- IDL_SEQUENCE_CORBA_ValueMember_Element_Wrap --
      -------------------------------------------------

      function IDL_SEQUENCE_CORBA_ValueMember_Element_Wrap
        (X : access CORBA.Repository_Root.ValueMember)
        return PolyORB.Any.Content'Class
      is
      begin
         return CORBA.Repository_Root.Helper.Internals.Wrap
           (X.all'Unrestricted_Access);
      end IDL_SEQUENCE_CORBA_ValueMember_Element_Wrap;

      function Wrap
        (X : access CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ValueMember.Sequence)
        return PolyORB.Any.Content'Class
        renames IDL_SEQUENCE_CORBA_ValueMember_Helper.Wrap;

      IDL_SEQUENCE_CORBA_ValueMember_Initialized : PolyORB.Std.Boolean :=
        False;

      -----------------------------------------------
      -- Initialize_IDL_SEQUENCE_CORBA_ValueMember --
      -----------------------------------------------

      procedure Initialize_IDL_SEQUENCE_CORBA_ValueMember is
      begin
         if not IDL_SEQUENCE_CORBA_ValueMember_Initialized
         then
            IDL_SEQUENCE_CORBA_ValueMember_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_ValueMember;
            CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ValueMember :=
              CORBA.TypeCode.Internals.Build_Sequence_TC
                 (CORBA.Repository_Root.Helper.TC_ValueMember,
                  0);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ValueMember);
            IDL_SEQUENCE_CORBA_ValueMember_Helper.Initialize
              (Element_TC => CORBA.Repository_Root.Helper.TC_ValueMember,
               Sequence_TC => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ValueMember);
            CORBA.TypeCode.Internals.Freeze
              (TC_IDL_SEQUENCE_CORBA_ValueMember);
         end if;
      end Initialize_IDL_SEQUENCE_CORBA_ValueMember;

      ValueMemberSeq_Initialized : PolyORB.Std.Boolean :=
        False;

      -------------------------------
      -- Initialize_ValueMemberSeq --
      -------------------------------

      procedure Initialize_ValueMemberSeq is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ValueMemberSeq");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ValueMemberSeq:1.0");
      begin
         if not ValueMemberSeq_Initialized
         then
            ValueMemberSeq_Initialized :=
              True;
            CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ValueMember;
            CORBA.Repository_Root.Helper.TC_ValueMemberSeq :=
              CORBA.TypeCode.Internals.Build_Alias_TC
                 (Name => Name_Ü,
                  Id => Id_Ü,
                  Parent => CORBA.Repository_Root.Helper.TC_IDL_SEQUENCE_CORBA_ValueMember);
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ValueMemberSeq);
            CORBA.TypeCode.Internals.Freeze
              (TC_ValueMemberSeq);
         end if;
      end Initialize_ValueMemberSeq;

      ---------------------------
      -- Get_Aggregate_Element --
      ---------------------------

      function Get_Aggregate_Element
        (Acc : not null access Content_Ü_ValueDescription;
         Tc : PolyORB.Any.TypeCode.Object_Ptr;
         Index : PolyORB.Types.Unsigned_Long;
         Mech : not null access PolyORB.Any.Mechanism)
        return PolyORB.Any.Content'Class
      is
         use type PolyORB.Any.Mechanism;
         pragma Suppress (Validity_Check);
         pragma Unreferenced (Tc);
      begin
         Mech.all :=
           PolyORB.Any.By_Reference;
         case Index is
            when 0 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.name)'Unrestricted_Access);
            when 1 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.id)'Unrestricted_Access);
            when 2 =>
               return CORBA.Wrap
                 (Acc.V.is_abstract'Unrestricted_Access);
            when 3 =>
               return CORBA.Wrap
                 (Acc.V.is_custom'Unrestricted_Access);
            when 4 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.defined_in)'Unrestricted_Access);
            when 5 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.version)'Unrestricted_Access);
            when 6 =>
               return CORBA.Repository_Root.Helper.Internals.Wrap
                 (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_RepositoryId.Sequence
                    (Acc.V.supported_interfaces)'Unrestricted_Access);
            when 7 =>
               return CORBA.Repository_Root.Helper.Internals.Wrap
                 (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_RepositoryId.Sequence
                    (Acc.V.abstract_base_values)'Unrestricted_Access);
            when 8 =>
               return CORBA.Wrap
                 (Acc.V.is_truncatable'Unrestricted_Access);
            when 9 =>
               return CORBA.Wrap
                 (CORBA.String
                    (Acc.V.base_value)'Unrestricted_Access);
            pragma Warnings (Off);
            when others =>
               raise Constraint_Error;
            pragma Warnings (On);

         end case;
      end Get_Aggregate_Element;

      -------------------------
      -- Get_Aggregate_Count --
      -------------------------

      function Get_Aggregate_Count
        (Acc : Content_Ü_ValueDescription)
        return PolyORB.Types.Unsigned_Long
      is
         pragma Unreferenced (Acc);
      begin
         return 10;
      end Get_Aggregate_Count;

      -------------------------
      -- Set_Aggregate_Count --
      -------------------------

      procedure Set_Aggregate_Count
        (Acc : in out Content_Ü_ValueDescription;
         Count : PolyORB.Types.Unsigned_Long)
      is
      begin
         null;
      end Set_Aggregate_Count;

      ---------------------
      -- Unchecked_Get_V --
      ---------------------

      function Unchecked_Get_V
        (Acc : not null access Content_Ü_ValueDescription)
        return PolyORB.Types.Address
      is
         function To_Address
           is new Ada.Unchecked_Conversion
              (Ptr_Ü_ValueDescription,
               PolyORB.Types.Address);

      begin
         return To_Address
           (Acc.V);
      end Unchecked_Get_V;

      -----------
      -- Clone --
      -----------

      function Clone
        (Acc : Content_Ü_ValueDescription;
         Into : PolyORB.Any.Content_Ptr := null)
        return PolyORB.Any.Content_Ptr
      is
         use type PolyORB.Any.Content_Ptr;
         Target : PolyORB.Any.Content_Ptr;
      begin
         if (Into
            /= null)
         then
            if (Into.all
               not in Content_Ü_ValueDescription)
            then
               return null;
            end if;
            Target :=
              Into;
            Content_Ü_ValueDescription
              (Target.all).V.all :=
              Acc.V.all;
         else
            Target :=
              new Content_Ü_ValueDescription;
            Content_Ü_ValueDescription
              (Target.all).V :=
              new CORBA.Repository_Root.ValueDescription'
                 (Acc.V.all);
         end if;
         return Target;
      end Clone;

      --------------------
      -- Finalize_Value --
      --------------------

      procedure Finalize_Value
        (Acc : in out Content_Ü_ValueDescription)
      is
         procedure Free
           is new Ada.Unchecked_Deallocation
              (CORBA.Repository_Root.ValueDescription,
               Ptr_Ü_ValueDescription);

      begin
         Free
           (Acc.V);
      end Finalize_Value;

      ----------
      -- Wrap --
      ----------

      function Wrap
        (X : access CORBA.Repository_Root.ValueDescription)
        return PolyORB.Any.Content'Class
      is
      begin
         return Content_Ü_ValueDescription'
           (PolyORB.Any.Aggregate_Content with
            V => Ptr_Ü_ValueDescription'
              (X.all'Unchecked_Access));
      end Wrap;

      ValueDescription_Initialized : PolyORB.Std.Boolean :=
        False;

      ---------------------------------
      -- Initialize_ValueDescription --
      ---------------------------------

      procedure Initialize_ValueDescription is
         Name_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("ValueDescription");
         Id_Ü : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("IDL:omg.org/CORBA/ValueDescription:1.0");
         Argument_Name_Ü_name : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("name");
         Argument_Name_Ü_id : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("id");
         Argument_Name_Ü_is_abstract : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("is_abstract");
         Argument_Name_Ü_is_custom : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("is_custom");
         Argument_Name_Ü_defined_in : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("defined_in");
         Argument_Name_Ü_version : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("version");
         Argument_Name_Ü_supported_interfaces : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("supported_interfaces");
         Argument_Name_Ü_abstract_base_values : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("abstract_base_values");
         Argument_Name_Ü_is_truncatable : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("is_truncatable");
         Argument_Name_Ü_base_value : constant CORBA.String :=
           CORBA.To_CORBA_String
              ("base_value");
      begin
         if not ValueDescription_Initialized
         then
            ValueDescription_Initialized :=
              True;
            CORBA.Repository_Root.Helper.TC_ValueDescription :=
              CORBA.TypeCode.Internals.To_CORBA_Object
                 (PolyORB.Any.TypeCode.Tcf_Struct);
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (Name_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (Id_Ü));
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_Identifier));
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_name));
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_id));
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (CORBA.TC_Boolean));
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_is_abstract));
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (CORBA.TC_Boolean));
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_is_custom));
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_defined_in));
            CORBA.Repository_Root.Helper.Internals.Initialize_VersionSpec;
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_VersionSpec));
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_version));
            CORBA.Repository_Root.Helper.Internals.Initialize_RepositoryIdSeq;
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_RepositoryIdSeq));
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_supported_interfaces));
            CORBA.Repository_Root.Helper.Internals.Initialize_RepositoryIdSeq;
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (CORBA.Repository_Root.Helper.TC_RepositoryIdSeq));
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_abstract_base_values));
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (CORBA.TC_Boolean));
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_is_truncatable));
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (CORBA.Helper.TC_RepositoryId));
            CORBA.Internals.Add_Parameter
              (TC_ValueDescription,
               CORBA.To_Any
                 (Argument_Name_Ü_base_value));
            CORBA.TypeCode.Internals.Disable_Ref_Counting
              (TC_ValueDescription);
            CORBA.TypeCode.Internals.Freeze
              (TC_ValueDescription);
         end if;
      end Initialize_ValueDescription;

   end Internals;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ArrayDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ArrayDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ArrayDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.ArrayDef_Forward.Ref;
   begin
      CORBA.Repository_Root.ArrayDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ArrayDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/ArrayDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.AttributeDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.AttributeDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.AttributeDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.AttributeDef_Forward.Ref;
   begin
      CORBA.Repository_Root.AttributeDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.AttributeDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/AttributeDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.Contained_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.Contained_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.Contained_Forward.Ref
   is
      Result : CORBA.Repository_Root.Contained_Forward.Ref;
   begin
      CORBA.Repository_Root.Contained_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.Contained_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/Contained:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.Container_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.Container_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.Container_Forward.Ref
   is
      Result : CORBA.Repository_Root.Container_Forward.Ref;
   begin
      CORBA.Repository_Root.Container_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.Container_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/Container:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.FixedDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.FixedDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.FixedDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.FixedDef_Forward.Ref;
   begin
      CORBA.Repository_Root.FixedDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.FixedDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/FixedDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IRObject_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.IRObject_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.IRObject_Forward.Ref
   is
      Result : CORBA.Repository_Root.IRObject_Forward.Ref;
   begin
      CORBA.Repository_Root.IRObject_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.IRObject_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/IRObject:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.OperationDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.OperationDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.OperationDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.OperationDef_Forward.Ref;
   begin
      CORBA.Repository_Root.OperationDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.OperationDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/OperationDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.PrimitiveDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.PrimitiveDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.PrimitiveDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.PrimitiveDef_Forward.Ref;
   begin
      CORBA.Repository_Root.PrimitiveDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.PrimitiveDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/PrimitiveDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.Repository_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.Repository_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.Repository_Forward.Ref
   is
      Result : CORBA.Repository_Root.Repository_Forward.Ref;
   begin
      CORBA.Repository_Root.Repository_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.Repository_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/Repository:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.SequenceDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.SequenceDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.SequenceDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.SequenceDef_Forward.Ref;
   begin
      CORBA.Repository_Root.SequenceDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.SequenceDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/SequenceDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.StringDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.StringDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.StringDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.StringDef_Forward.Ref;
   begin
      CORBA.Repository_Root.StringDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.StringDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/StringDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.TypedefDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.TypedefDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.TypedefDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.TypedefDef_Forward.Ref;
   begin
      CORBA.Repository_Root.TypedefDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.TypedefDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/TypedefDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ValueMemberDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ValueMemberDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ValueMemberDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.ValueMemberDef_Forward.Ref;
   begin
      CORBA.Repository_Root.ValueMemberDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ValueMemberDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/ValueMemberDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.WstringDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.WstringDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.WstringDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.WstringDef_Forward.Ref;
   begin
      CORBA.Repository_Root.WstringDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.WstringDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/WstringDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.DefinitionKind
   is
   begin
      return CORBA.Repository_Root.Helper.Internals.From_Any
        (CORBA.Get_Container
           (Item).all);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.DefinitionKind)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_DefinitionKind);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.DefinitionKind'
                 (Item))),
         False);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.VersionSpec
   is
      Result : constant CORBA.String :=
        CORBA.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.VersionSpec
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.VersionSpec)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.To_Any
           (CORBA.String
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_VersionSpec);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ModuleDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ModuleDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ModuleDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.ModuleDef_Forward.Ref;
   begin
      CORBA.Repository_Root.ModuleDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ModuleDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/ModuleDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ConstantDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ConstantDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ConstantDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.ConstantDef_Forward.Ref;
   begin
      CORBA.Repository_Root.ConstantDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ConstantDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/ConstantDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDLType_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.IDLType_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.IDLType_Forward.Ref
   is
      Result : CORBA.Repository_Root.IDLType_Forward.Ref;
   begin
      CORBA.Repository_Root.IDLType_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.IDLType_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/IDLType:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.StructDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.StructDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.StructDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.StructDef_Forward.Ref;
   begin
      CORBA.Repository_Root.StructDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.StructDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/StructDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.UnionDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.UnionDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.UnionDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.UnionDef_Forward.Ref;
   begin
      CORBA.Repository_Root.UnionDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.UnionDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/UnionDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.EnumDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.EnumDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.EnumDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.EnumDef_Forward.Ref;
   begin
      CORBA.Repository_Root.EnumDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.EnumDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/EnumDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.AliasDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.AliasDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.AliasDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.AliasDef_Forward.Ref;
   begin
      CORBA.Repository_Root.AliasDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.AliasDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/AliasDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ExceptionDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ExceptionDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ExceptionDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.ExceptionDef_Forward.Ref;
   begin
      CORBA.Repository_Root.ExceptionDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ExceptionDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/ExceptionDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.NativeDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.NativeDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.NativeDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.NativeDef_Forward.Ref;
   begin
      CORBA.Repository_Root.NativeDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.NativeDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/NativeDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.InterfaceDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.InterfaceDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.InterfaceDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.InterfaceDef_Forward.Ref;
   begin
      CORBA.Repository_Root.InterfaceDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.InterfaceDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/InterfaceDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_InterfaceDef_Forward.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_InterfaceDef_Forward_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_InterfaceDef_Forward.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_InterfaceDef_Forward_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.InterfaceDefSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_InterfaceDef_Forward.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.InterfaceDefSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.InterfaceDefSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_InterfaceDef_Forward.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_InterfaceDefSeq);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ValueDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ValueDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ValueDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.ValueDef_Forward.Ref;
   begin
      CORBA.Repository_Root.ValueDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ValueDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/ValueDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ValueDef_Forward.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ValueDef_Forward_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ValueDef_Forward.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ValueDef_Forward_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ValueDefSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ValueDef_Forward.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.ValueDefSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ValueDefSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ValueDef_Forward.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ValueDefSeq);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ValueBoxDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ValueBoxDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ValueBoxDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.ValueBoxDef_Forward.Ref;
   begin
      CORBA.Repository_Root.ValueBoxDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ValueBoxDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/ValueBoxDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.AbstractInterfaceDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.AbstractInterfaceDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.AbstractInterfaceDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.AbstractInterfaceDef_Forward.Ref;
   begin
      CORBA.Repository_Root.AbstractInterfaceDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.AbstractInterfaceDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/AbstractInterfaceDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.AbstractInterfaceDefSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.AbstractInterfaceDefSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.AbstractInterfaceDefSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_AbstractInterfaceDefSeq);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.LocalInterfaceDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.LocalInterfaceDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.LocalInterfaceDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.LocalInterfaceDef_Forward.Ref;
   begin
      CORBA.Repository_Root.LocalInterfaceDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.LocalInterfaceDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/LocalInterfaceDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.LocalInterfaceDefSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.LocalInterfaceDefSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.LocalInterfaceDefSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_LocalInterfaceDefSeq);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ExtInterfaceDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ExtInterfaceDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ExtInterfaceDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.ExtInterfaceDef_Forward.Ref;
   begin
      CORBA.Repository_Root.ExtInterfaceDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ExtInterfaceDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/ExtInterfaceDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ExtInterfaceDefSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.ExtInterfaceDefSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ExtInterfaceDefSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ExtInterfaceDefSeq);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ExtAbstractInterfaceDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ExtAbstractInterfaceDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ExtAbstractInterfaceDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.ExtAbstractInterfaceDef_Forward.Ref;
   begin
      CORBA.Repository_Root.ExtAbstractInterfaceDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ExtAbstractInterfaceDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/ExtAbstractInterfaceDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ExtAbstractInterfaceDefSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.ExtAbstractInterfaceDefSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ExtAbstractInterfaceDefSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ExtAbstractInterfaceDefSeq);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ExtLocalInterfaceDef_Forward.Ref
   is
   begin
      return To_Ref
        (CORBA.Object.Helper.From_Any
           (Item));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ExtLocalInterfaceDef_Forward.Ref)
     return CORBA.Any
   is
   begin
      return CORBA.Object.Helper.To_Any
        (CORBA.Object.Ref
           (Item));
   end To_Any;

   ----------------------
   -- Unchecked_To_Ref --
   ----------------------

   function Unchecked_To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ExtLocalInterfaceDef_Forward.Ref
   is
      Result : CORBA.Repository_Root.ExtLocalInterfaceDef_Forward.Ref;
   begin
      CORBA.Repository_Root.ExtLocalInterfaceDef_Forward.Set
        (Result,
         CORBA.Object.Object_Of
           (The_Ref));
      return Result;
   end Unchecked_To_Ref;

   ------------
   -- To_Ref --
   ------------

   function To_Ref
     (The_Ref : CORBA.Object.Ref'Class)
     return CORBA.Repository_Root.ExtLocalInterfaceDef_Forward.Ref
   is
   begin
      if (CORBA.Object.Is_Nil
        (The_Ref)
         or else CORBA.Object.Is_A
           (The_Ref,
            "IDL:omg.org/CORBA/ExtLocalInterfaceDef:1.0"))
      then
         return Unchecked_To_Ref
           (The_Ref);
      end if;
      CORBA.Raise_Bad_Param
        (CORBA.Default_Sys_Member);
   end To_Ref;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ExtLocalInterfaceDefSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.ExtLocalInterfaceDefSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ExtLocalInterfaceDefSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ExtLocalInterfaceDefSeq);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Contained_Forward.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_Contained_Forward_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Contained_Forward.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_Contained_Forward_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ContainedSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Contained_Forward.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.ContainedSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ContainedSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Contained_Forward.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ContainedSeq);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.StructMember
   is
   begin
      return (name => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_Identifier,
            0)),
      IDL_type => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_TypeCode,
            1)),
      type_def => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.IDLType.Helper.TC_IDLType,
            2)));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.StructMember)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_StructMember);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.StructMember'
                 (Item))),
         False);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_StructMember.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_StructMember_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_StructMember.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_StructMember_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.StructMemberSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_StructMember.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.StructMemberSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.StructMemberSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_StructMember.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_StructMemberSeq);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.Initializer
   is
   begin
      return (members => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_StructMemberSeq,
            0)),
      name => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_Identifier,
            1)));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.Initializer)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_Initializer);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.Initializer'
                 (Item))),
         False);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Initializer.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_Initializer_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Initializer.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_Initializer_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.InitializerSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Initializer.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.InitializerSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.InitializerSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Initializer.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_InitializerSeq);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.UnionMember
   is
   begin
      return (name => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_Identifier,
            0)),
      label => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_Any,
            1)),
      IDL_type => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_TypeCode,
            2)),
      type_def => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.IDLType.Helper.TC_IDLType,
            3)));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.UnionMember)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_UnionMember);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.UnionMember'
                 (Item))),
         False);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ExceptionDescription
   is
   begin
      return (name => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_Identifier,
            0)),
      id => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            1)),
      defined_in => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            2)),
      version => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_VersionSpec,
            3)),
      IDL_type => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_TypeCode,
            4)));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ExceptionDescription)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_ExceptionDescription);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.ExceptionDescription'
                 (Item))),
         False);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExceptionDescription.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ExceptionDescription_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExceptionDescription.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ExceptionDescription_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ExcDescriptionSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExceptionDescription.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.ExcDescriptionSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ExcDescriptionSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExceptionDescription.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ExcDescriptionSeq);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ExtInitializer
   is
   begin
      return (members => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_StructMemberSeq,
            0)),
      exceptions => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_ExcDescriptionSeq,
            1)),
      name => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_Identifier,
            2)));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ExtInitializer)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_ExtInitializer);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.ExtInitializer'
                 (Item))),
         False);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtInitializer.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ExtInitializer_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtInitializer.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ExtInitializer_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ExtInitializerSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtInitializer.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.ExtInitializerSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ExtInitializerSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtInitializer.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ExtInitializerSeq);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_UnionMember.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_UnionMember_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_UnionMember.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_UnionMember_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.UnionMemberSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_UnionMember.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.UnionMemberSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.UnionMemberSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_UnionMember.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_UnionMemberSeq);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Identifier.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_Identifier_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Identifier.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_Identifier_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.EnumMemberSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Identifier.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.EnumMemberSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.EnumMemberSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Identifier.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_EnumMemberSeq);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.PrimitiveKind
   is
   begin
      return CORBA.Repository_Root.Helper.Internals.From_Any
        (CORBA.Get_Container
           (Item).all);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.PrimitiveKind)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_PrimitiveKind);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.PrimitiveKind'
                 (Item))),
         False);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ModuleDescription
   is
   begin
      return (name => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_Identifier,
            0)),
      id => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            1)),
      defined_in => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            2)),
      version => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_VersionSpec,
            3)));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ModuleDescription)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_ModuleDescription);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.ModuleDescription'
                 (Item))),
         False);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ConstantDescription
   is
   begin
      return (name => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_Identifier,
            0)),
      id => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            1)),
      defined_in => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            2)),
      version => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_VersionSpec,
            3)),
      IDL_type => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_TypeCode,
            4)),
      value => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_Any,
            5)));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ConstantDescription)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_ConstantDescription);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.ConstantDescription'
                 (Item))),
         False);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.TypeDescription
   is
   begin
      return (name => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_Identifier,
            0)),
      id => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            1)),
      defined_in => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            2)),
      version => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_VersionSpec,
            3)),
      IDL_type => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_TypeCode,
            4)));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.TypeDescription)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_TypeDescription);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.TypeDescription'
                 (Item))),
         False);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.AttributeMode
   is
   begin
      return CORBA.Repository_Root.Helper.Internals.From_Any
        (CORBA.Get_Container
           (Item).all);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.AttributeMode)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_AttributeMode);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.AttributeMode'
                 (Item))),
         False);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.AttributeDescription
   is
   begin
      return (name => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_Identifier,
            0)),
      id => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            1)),
      defined_in => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            2)),
      version => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_VersionSpec,
            3)),
      IDL_type => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_TypeCode,
            4)),
      mode => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_AttributeMode,
            5)));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.AttributeDescription)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_AttributeDescription);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.AttributeDescription'
                 (Item))),
         False);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ExtAttributeDescription
   is
   begin
      return (name => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_Identifier,
            0)),
      id => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            1)),
      defined_in => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            2)),
      version => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_VersionSpec,
            3)),
      IDL_type => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_TypeCode,
            4)),
      mode => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_AttributeMode,
            5)),
      get_exceptions => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_ExcDescriptionSeq,
            6)),
      put_exceptions => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_ExcDescriptionSeq,
            7)));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ExtAttributeDescription)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_ExtAttributeDescription);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.ExtAttributeDescription'
                 (Item))),
         False);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.OperationMode
   is
   begin
      return CORBA.Repository_Root.Helper.Internals.From_Any
        (CORBA.Get_Container
           (Item).all);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.OperationMode)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_OperationMode);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.OperationMode'
                 (Item))),
         False);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ParameterMode
   is
   begin
      return CORBA.Repository_Root.Helper.Internals.From_Any
        (CORBA.Get_Container
           (Item).all);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ParameterMode)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_ParameterMode);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.ParameterMode'
                 (Item))),
         False);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ParameterDescription
   is
   begin
      return (name => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_Identifier,
            0)),
      IDL_type => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_TypeCode,
            1)),
      type_def => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.IDLType.Helper.TC_IDLType,
            2)),
      mode => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_ParameterMode,
            3)));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ParameterDescription)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_ParameterDescription);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.ParameterDescription'
                 (Item))),
         False);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ParameterDescription.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ParameterDescription_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ParameterDescription.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ParameterDescription_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ParDescriptionSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ParameterDescription.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.ParDescriptionSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ParDescriptionSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ParameterDescription.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ParDescriptionSeq);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ContextIdentifier
   is
      Result : constant CORBA.Identifier :=
        CORBA.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.ContextIdentifier
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ContextIdentifier)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Helper.To_Any
           (CORBA.Identifier
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ContextIdentifier);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ContextIdentifier.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ContextIdentifier_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ContextIdentifier.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ContextIdentifier_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ContextIdSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ContextIdentifier.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.ContextIdSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ContextIdSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ContextIdentifier.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ContextIdSeq);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExceptionDef_Forward.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ExceptionDef_Forward_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExceptionDef_Forward.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ExceptionDef_Forward_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ExceptionDefSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExceptionDef_Forward.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.ExceptionDefSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ExceptionDefSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExceptionDef_Forward.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ExceptionDefSeq);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.OperationDescription
   is
   begin
      return (name => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_Identifier,
            0)),
      id => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            1)),
      defined_in => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            2)),
      version => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_VersionSpec,
            3)),
      result => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_TypeCode,
            4)),
      mode => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_OperationMode,
            5)),
      contexts => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_ContextIdSeq,
            6)),
      parameters => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_ParDescriptionSeq,
            7)),
      exceptions => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_ExcDescriptionSeq,
            8)));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.OperationDescription)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_OperationDescription);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.OperationDescription'
                 (Item))),
         False);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_RepositoryId.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_RepositoryId_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_RepositoryId.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_RepositoryId_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.RepositoryIdSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_RepositoryId.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.RepositoryIdSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.RepositoryIdSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_RepositoryId.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_RepositoryIdSeq);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_OperationDescription.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_OperationDescription_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_OperationDescription.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_OperationDescription_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.OpDescriptionSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_OperationDescription.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.OpDescriptionSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.OpDescriptionSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_OperationDescription.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_OpDescriptionSeq);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_AttributeDescription.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_AttributeDescription_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_AttributeDescription.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_AttributeDescription_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.AttrDescriptionSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_AttributeDescription.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.AttrDescriptionSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.AttrDescriptionSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_AttributeDescription.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_AttrDescriptionSeq);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtAttributeDescription.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ExtAttributeDescription_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtAttributeDescription.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ExtAttributeDescription_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ExtAttrDescriptionSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtAttributeDescription.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.ExtAttrDescriptionSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ExtAttrDescriptionSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExtAttributeDescription.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ExtAttrDescriptionSeq);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.InterfaceDescription
   is
   begin
      return (name => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_Identifier,
            0)),
      id => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            1)),
      defined_in => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            2)),
      version => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_VersionSpec,
            3)),
      base_interfaces => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_RepositoryIdSeq,
            4)),
      is_abstract => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_Boolean,
            5)));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.InterfaceDescription)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_InterfaceDescription);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.InterfaceDescription'
                 (Item))),
         False);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ValueMember
   is
   begin
      return (name => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_Identifier,
            0)),
      id => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            1)),
      defined_in => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            2)),
      version => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_VersionSpec,
            3)),
      IDL_type => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_TypeCode,
            4)),
      type_def => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.IDLType.Helper.TC_IDLType,
            5)),
      IDL_access => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_Visibility,
            6)));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ValueMember)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_ValueMember);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.ValueMember'
                 (Item))),
         False);
      return Result;
   end To_Any;

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ValueMember.Sequence
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ValueMember_Helper.From_Any;

   function To_Any
     (Item : CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ValueMember.Sequence)
     return CORBA.Any
     renames CORBA.Repository_Root.Helper.Internals.IDL_SEQUENCE_CORBA_ValueMember_Helper.To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ValueMemberSeq
   is
      Result : constant CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ValueMember.Sequence :=
        CORBA.Repository_Root.Helper.From_Any
           (Item);
   begin
      return CORBA.Repository_Root.ValueMemberSeq
        (Result);
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ValueMemberSeq)
     return CORBA.Any
   is
      Result : CORBA.Any :=
        CORBA.Repository_Root.Helper.To_Any
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ValueMember.Sequence
              (Item));
   begin
      CORBA.Internals.Set_Type
        (Result,
         TC_ValueMemberSeq);
      return Result;
   end To_Any;

   --------------
   -- From_Any --
   --------------

   function From_Any
     (Item : CORBA.Any)
     return CORBA.Repository_Root.ValueDescription
   is
   begin
      return (name => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_Identifier,
            0)),
      id => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            1)),
      is_abstract => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_Boolean,
            2)),
      is_custom => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_Boolean,
            3)),
      defined_in => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            4)),
      version => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_VersionSpec,
            5)),
      supported_interfaces => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_RepositoryIdSeq,
            6)),
      abstract_base_values => CORBA.Repository_Root.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Repository_Root.Helper.TC_RepositoryIdSeq,
            7)),
      is_truncatable => CORBA.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.TC_Boolean,
            8)),
      base_value => CORBA.Helper.From_Any
        (CORBA.Internals.Get_Aggregate_Element
           (Item,
            CORBA.Helper.TC_RepositoryId,
            9)));
   end From_Any;

   ------------
   -- To_Any --
   ------------

   function To_Any
     (Item : CORBA.Repository_Root.ValueDescription)
     return CORBA.Any
   is
      Result : constant CORBA.Any :=
        CORBA.Internals.Get_Empty_Any
           (TC_ValueDescription);
   begin
      PolyORB.Any.Set_Value
        (CORBA.Get_Container
           (Result).all,
         new PolyORB.Any.Content'Class'
           (CORBA.Repository_Root.Helper.Internals.Wrap
              (new CORBA.Repository_Root.ValueDescription'
                 (Item))),
         False);
      return Result;
   end To_Any;

   -----------------------------
   -- Deferred_Initialization --
   -----------------------------

   procedure Deferred_Initialization is
   begin
      CORBA.Repository_Root.Helper.Internals.Initialize_ArrayDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_AttributeDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_Contained;
      CORBA.Repository_Root.Helper.Internals.Initialize_Container;
      CORBA.Repository_Root.Helper.Internals.Initialize_FixedDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_IRObject;
      CORBA.Repository_Root.Helper.Internals.Initialize_OperationDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_PrimitiveDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_Repository;
      CORBA.Repository_Root.Helper.Internals.Initialize_SequenceDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_StringDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_TypedefDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_ValueMemberDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_WstringDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_DefinitionKind;
      CORBA.Repository_Root.Helper.Internals.Initialize_VersionSpec;
      CORBA.Repository_Root.Helper.Internals.Initialize_ModuleDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_ConstantDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDLType;
      CORBA.Repository_Root.Helper.Internals.Initialize_StructDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_UnionDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_EnumDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_AliasDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_ExceptionDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_NativeDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_InterfaceDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_InterfaceDef_Forward;
      CORBA.Repository_Root.Helper.Internals.Initialize_InterfaceDefSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_ValueDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ValueDef_Forward;
      CORBA.Repository_Root.Helper.Internals.Initialize_ValueDefSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_ValueBoxDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_AbstractInterfaceDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward;
      CORBA.Repository_Root.Helper.Internals.Initialize_AbstractInterfaceDefSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_LocalInterfaceDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_LocalInterfaceDef_Forward;
      CORBA.Repository_Root.Helper.Internals.Initialize_LocalInterfaceDefSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_ExtInterfaceDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ExtInterfaceDef_Forward;
      CORBA.Repository_Root.Helper.Internals.Initialize_ExtInterfaceDefSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_ExtAbstractInterfaceDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ExtAbstractInterfaceDef_Forward;
      CORBA.Repository_Root.Helper.Internals.Initialize_ExtAbstractInterfaceDefSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_ExtLocalInterfaceDef;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ExtLocalInterfaceDef_Forward;
      CORBA.Repository_Root.Helper.Internals.Initialize_ExtLocalInterfaceDefSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_Contained_Forward;
      CORBA.Repository_Root.Helper.Internals.Initialize_ContainedSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_StructMember;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_StructMember;
      CORBA.Repository_Root.Helper.Internals.Initialize_StructMemberSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_Initializer;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_Initializer;
      CORBA.Repository_Root.Helper.Internals.Initialize_InitializerSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_UnionMember;
      CORBA.Repository_Root.Helper.Internals.Initialize_ExceptionDescription;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ExceptionDescription;
      CORBA.Repository_Root.Helper.Internals.Initialize_ExcDescriptionSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_ExtInitializer;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ExtInitializer;
      CORBA.Repository_Root.Helper.Internals.Initialize_ExtInitializerSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_UnionMember;
      CORBA.Repository_Root.Helper.Internals.Initialize_UnionMemberSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_Identifier;
      CORBA.Repository_Root.Helper.Internals.Initialize_EnumMemberSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_PrimitiveKind;
      CORBA.Repository_Root.Helper.Internals.Initialize_ModuleDescription;
      CORBA.Repository_Root.Helper.Internals.Initialize_ConstantDescription;
      CORBA.Repository_Root.Helper.Internals.Initialize_TypeDescription;
      CORBA.Repository_Root.Helper.Internals.Initialize_AttributeMode;
      CORBA.Repository_Root.Helper.Internals.Initialize_AttributeDescription;
      CORBA.Repository_Root.Helper.Internals.Initialize_ExtAttributeDescription;
      CORBA.Repository_Root.Helper.Internals.Initialize_OperationMode;
      CORBA.Repository_Root.Helper.Internals.Initialize_ParameterMode;
      CORBA.Repository_Root.Helper.Internals.Initialize_ParameterDescription;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ParameterDescription;
      CORBA.Repository_Root.Helper.Internals.Initialize_ParDescriptionSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_ContextIdentifier;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ContextIdentifier;
      CORBA.Repository_Root.Helper.Internals.Initialize_ContextIdSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ExceptionDef_Forward;
      CORBA.Repository_Root.Helper.Internals.Initialize_ExceptionDefSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_OperationDescription;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_RepositoryId;
      CORBA.Repository_Root.Helper.Internals.Initialize_RepositoryIdSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_OperationDescription;
      CORBA.Repository_Root.Helper.Internals.Initialize_OpDescriptionSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_AttributeDescription;
      CORBA.Repository_Root.Helper.Internals.Initialize_AttrDescriptionSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ExtAttributeDescription;
      CORBA.Repository_Root.Helper.Internals.Initialize_ExtAttrDescriptionSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_InterfaceDescription;
      CORBA.Repository_Root.Helper.Internals.Initialize_ValueMember;
      CORBA.Repository_Root.Helper.Internals.Initialize_IDL_SEQUENCE_CORBA_ValueMember;
      CORBA.Repository_Root.Helper.Internals.Initialize_ValueMemberSeq;
      CORBA.Repository_Root.Helper.Internals.Initialize_ValueDescription;
   end Deferred_Initialization;

begin
   declare
      use PolyORB.Utils.Strings;
      use PolyORB.Utils.Strings.Lists;
   begin
      PolyORB.Initialization.Register_Module
        (PolyORB.Initialization.Module_Info'
           (Name => +"CORBA.Repository_Root.Helper",
            Conflicts => PolyORB.Utils.Strings.Lists.Empty,
            Depends => +"any"
               & "corba"
               & "corba.helper",
            Provides => PolyORB.Utils.Strings.Lists.Empty,
            Implicit => False,
            Init => Deferred_Initialization'Access,
            Shutdown => null));
   end;
end CORBA.Repository_Root.Helper;
