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.Any.NVList;
with CORBA.Repository_Root.Helper;
with CORBA.Repository_Root;
with PolyORB.Any;
with PolyORB.Requests;
with PolyORB.Types;
with CORBA.Object;
with PolyORB.CORBA_P.Interceptors_Hooks;
with PolyORB.CORBA_P.Exceptions;
with CORBA.Object.Helper;
with CORBA.Helper;
with CORBA.Repository_Root.Contained.Helper;
with CORBA.Repository_Root.Container.Helper;
with CORBA.Repository_Root.ModuleDef.Helper;
with CORBA.Repository_Root.IDLType.Helper;
with CORBA.Repository_Root.ConstantDef.Helper;
with CORBA.Repository_Root.StructDef.Helper;
with CORBA.Repository_Root.UnionDef.Helper;
with CORBA.Repository_Root.EnumDef.Helper;
with CORBA.Repository_Root.AliasDef.Helper;
with CORBA.Repository_Root.InterfaceDef.Helper;
with CORBA.Repository_Root.ValueDef.Helper;
with CORBA.Repository_Root.ValueBoxDef.Helper;
with CORBA.Repository_Root.ExceptionDef.Helper;
with CORBA.Repository_Root.NativeDef.Helper;
with CORBA.Repository_Root.AbstractInterfaceDef.Helper;
with CORBA.Repository_Root.LocalInterfaceDef.Helper;
with CORBA.Repository_Root.IRObject;
with CORBA.Repository_Root.IDLType;

package body CORBA.Repository_Root.StructDef is

   get_members_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   --------------------------
   -- get_members_Result_Ü --
   --------------------------

   function get_members_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_members_Result_Ü);
   begin
      return (Name => get_members_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.Helper.TC_StructMemberSeq),
      Arg_Modes => 0);
   end get_members_Result_Ü;

   -----------------
   -- get_members --
   -----------------

   function get_members
     (Self : Ref)
     return CORBA.Repository_Root.StructMemberSeq
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.StructMemberSeq;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Helper.Internals.Wrap
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_StructMember.Sequence
              (Result_Ü)'Unrestricted_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_members_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "_get_members",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end get_members;

   set_members_Arg_Name_To_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("To");

   set_members_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   --------------------------
   -- set_members_Result_Ü --
   --------------------------

   function set_members_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (set_members_Result_Ü);
   begin
      return (Name => set_members_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.TC_Void),
      Arg_Modes => 0);
   end set_members_Result_Ü;

   -----------------
   -- set_members --
   -----------------

   procedure set_members
     (Self : Ref;
      To : CORBA.Repository_Root.StructMemberSeq)
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Arg_CC_To_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Helper.Internals.Wrap
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_StructMember.Sequence
              (To)'Unrestricted_Access);
      Arg_Any_To_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_StructMemberSeq,
            Arg_CC_To_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        set_members_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         set_members_Arg_Name_To_Ü,
         PolyORB.Any.Any
           (Arg_Any_To_Ü),
         PolyORB.Any.ARG_IN);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "_set_members",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
   end set_members;

   lookup_Arg_Name_search_name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("search_name");

   lookup_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   ---------------------
   -- lookup_Result_Ü --
   ---------------------

   function lookup_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (lookup_Result_Ü);
   begin
      return (Name => lookup_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.Contained.Helper.TC_Contained),
      Arg_Modes => 0);
   end lookup_Result_Ü;

   ------------
   -- lookup --
   ------------

   function lookup
     (Self : Ref;
      search_name : CORBA.ScopedName)
     return CORBA.Repository_Root.Contained.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.Contained.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_search_name_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (search_name)'Unrestricted_Access);
      Arg_Any_search_name_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_ScopedName,
            Arg_CC_search_name_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        lookup_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         lookup_Arg_Name_search_name_Ü,
         PolyORB.Any.Any
           (Arg_Any_search_name_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "lookup",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end lookup;

   contents_Arg_Name_limit_type_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("limit_type");

   contents_Arg_Name_exclude_inherited_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("exclude_inherited");

   contents_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   -----------------------
   -- contents_Result_Ü --
   -----------------------

   function contents_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (contents_Result_Ü);
   begin
      return (Name => contents_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.Helper.TC_ContainedSeq),
      Arg_Modes => 0);
   end contents_Result_Ü;

   --------------
   -- contents --
   --------------

   function contents
     (Self : Ref;
      limit_type : CORBA.Repository_Root.DefinitionKind;
      exclude_inherited : CORBA.Boolean)
     return CORBA.Repository_Root.ContainedSeq
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.ContainedSeq;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Helper.Internals.Wrap
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Contained_Forward.Sequence
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_limit_type_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Helper.Internals.Wrap
           (limit_type'Unrestricted_Access);
      Arg_Any_limit_type_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_DefinitionKind,
            Arg_CC_limit_type_Ü'Unchecked_Access);
      Arg_CC_exclude_inherited_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (exclude_inherited'Unrestricted_Access);
      Arg_Any_exclude_inherited_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.TC_Boolean,
            Arg_CC_exclude_inherited_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        contents_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         contents_Arg_Name_limit_type_Ü,
         PolyORB.Any.Any
           (Arg_Any_limit_type_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         contents_Arg_Name_exclude_inherited_Ü,
         PolyORB.Any.Any
           (Arg_Any_exclude_inherited_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "contents",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end contents;

   lookup_name_Arg_Name_search_name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("search_name");

   lookup_name_Arg_Name_levels_to_search_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("levels_to_search");

   lookup_name_Arg_Name_limit_type_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("limit_type");

   lookup_name_Arg_Name_exclude_inherited_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("exclude_inherited");

   lookup_name_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   --------------------------
   -- lookup_name_Result_Ü --
   --------------------------

   function lookup_name_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (lookup_name_Result_Ü);
   begin
      return (Name => lookup_name_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.Helper.TC_ContainedSeq),
      Arg_Modes => 0);
   end lookup_name_Result_Ü;

   -----------------
   -- lookup_name --
   -----------------

   function lookup_name
     (Self : Ref;
      search_name : CORBA.Identifier;
      levels_to_search : CORBA.Long;
      limit_type : CORBA.Repository_Root.DefinitionKind;
      exclude_inherited : CORBA.Boolean)
     return CORBA.Repository_Root.ContainedSeq
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.ContainedSeq;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Helper.Internals.Wrap
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Contained_Forward.Sequence
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_search_name_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (search_name)'Unrestricted_Access);
      Arg_Any_search_name_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_Identifier,
            Arg_CC_search_name_Ü'Unchecked_Access);
      Arg_CC_levels_to_search_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (levels_to_search'Unrestricted_Access);
      Arg_Any_levels_to_search_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.TC_Long,
            Arg_CC_levels_to_search_Ü'Unchecked_Access);
      Arg_CC_limit_type_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Helper.Internals.Wrap
           (limit_type'Unrestricted_Access);
      Arg_Any_limit_type_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_DefinitionKind,
            Arg_CC_limit_type_Ü'Unchecked_Access);
      Arg_CC_exclude_inherited_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (exclude_inherited'Unrestricted_Access);
      Arg_Any_exclude_inherited_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.TC_Boolean,
            Arg_CC_exclude_inherited_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        lookup_name_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         lookup_name_Arg_Name_search_name_Ü,
         PolyORB.Any.Any
           (Arg_Any_search_name_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         lookup_name_Arg_Name_levels_to_search_Ü,
         PolyORB.Any.Any
           (Arg_Any_levels_to_search_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         lookup_name_Arg_Name_limit_type_Ü,
         PolyORB.Any.Any
           (Arg_Any_limit_type_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         lookup_name_Arg_Name_exclude_inherited_Ü,
         PolyORB.Any.Any
           (Arg_Any_exclude_inherited_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "lookup_name",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end lookup_name;

   describe_contents_Arg_Name_limit_type_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("limit_type");

   describe_contents_Arg_Name_exclude_inherited_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("exclude_inherited");

   describe_contents_Arg_Name_max_returned_objs_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("max_returned_objs");

   describe_contents_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   --------------------------------
   -- describe_contents_Result_Ü --
   --------------------------------

   function describe_contents_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (describe_contents_Result_Ü);
   begin
      return (Name => describe_contents_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.Container.Helper.TC_DescriptionSeq),
      Arg_Modes => 0);
   end describe_contents_Result_Ü;

   -----------------------
   -- describe_contents --
   -----------------------

   function describe_contents
     (Self : Ref;
      limit_type : CORBA.Repository_Root.DefinitionKind;
      exclude_inherited : CORBA.Boolean;
      max_returned_objs : CORBA.Long)
     return CORBA.Repository_Root.Container.DescriptionSeq
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.Container.DescriptionSeq;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Container.Helper.Internals.Wrap
           (CORBA.Repository_Root.Container.IDL_SEQUENCE_CORBA_Container_Description.Sequence
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_limit_type_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Helper.Internals.Wrap
           (limit_type'Unrestricted_Access);
      Arg_Any_limit_type_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_DefinitionKind,
            Arg_CC_limit_type_Ü'Unchecked_Access);
      Arg_CC_exclude_inherited_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (exclude_inherited'Unrestricted_Access);
      Arg_Any_exclude_inherited_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.TC_Boolean,
            Arg_CC_exclude_inherited_Ü'Unchecked_Access);
      Arg_CC_max_returned_objs_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (max_returned_objs'Unrestricted_Access);
      Arg_Any_max_returned_objs_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.TC_Long,
            Arg_CC_max_returned_objs_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        describe_contents_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         describe_contents_Arg_Name_limit_type_Ü,
         PolyORB.Any.Any
           (Arg_Any_limit_type_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         describe_contents_Arg_Name_exclude_inherited_Ü,
         PolyORB.Any.Any
           (Arg_Any_exclude_inherited_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         describe_contents_Arg_Name_max_returned_objs_Ü,
         PolyORB.Any.Any
           (Arg_Any_max_returned_objs_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "describe_contents",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end describe_contents;

   create_module_Arg_Name_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("id");

   create_module_Arg_Name_name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("name");

   create_module_Arg_Name_version_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("version");

   create_module_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   ----------------------------
   -- create_module_Result_Ü --
   ----------------------------

   function create_module_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (create_module_Result_Ü);
   begin
      return (Name => create_module_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.ModuleDef.Helper.TC_ModuleDef),
      Arg_Modes => 0);
   end create_module_Result_Ü;

   -------------------
   -- create_module --
   -------------------

   function create_module
     (Self : Ref;
      id : CORBA.RepositoryId;
      name : CORBA.Identifier;
      version : CORBA.Repository_Root.VersionSpec)
     return CORBA.Repository_Root.ModuleDef_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.ModuleDef_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (id)'Unrestricted_Access);
      Arg_Any_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_RepositoryId,
            Arg_CC_id_Ü'Unchecked_Access);
      Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (name)'Unrestricted_Access);
      Arg_Any_name_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_Identifier,
            Arg_CC_name_Ü'Unchecked_Access);
      Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (version)'Unrestricted_Access);
      Arg_Any_version_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_VersionSpec,
            Arg_CC_version_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        create_module_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_module_Arg_Name_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_id_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_module_Arg_Name_name_Ü,
         PolyORB.Any.Any
           (Arg_Any_name_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_module_Arg_Name_version_Ü,
         PolyORB.Any.Any
           (Arg_Any_version_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "create_module",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end create_module;

   create_constant_Arg_Name_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("id");

   create_constant_Arg_Name_name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("name");

   create_constant_Arg_Name_version_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("version");

   create_constant_Arg_Name_IDL_type_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("IDL_type");

   create_constant_Arg_Name_value_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("value");

   create_constant_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   ------------------------------
   -- create_constant_Result_Ü --
   ------------------------------

   function create_constant_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (create_constant_Result_Ü);
   begin
      return (Name => create_constant_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.ConstantDef.Helper.TC_ConstantDef),
      Arg_Modes => 0);
   end create_constant_Result_Ü;

   ---------------------
   -- create_constant --
   ---------------------

   function create_constant
     (Self : Ref;
      id : CORBA.RepositoryId;
      name : CORBA.Identifier;
      version : CORBA.Repository_Root.VersionSpec;
      IDL_type : CORBA.Repository_Root.IDLType_Forward.Ref;
      value : CORBA.Any)
     return CORBA.Repository_Root.ConstantDef_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.ConstantDef_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (id)'Unrestricted_Access);
      Arg_Any_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_RepositoryId,
            Arg_CC_id_Ü'Unchecked_Access);
      Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (name)'Unrestricted_Access);
      Arg_Any_name_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_Identifier,
            Arg_CC_name_Ü'Unchecked_Access);
      Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (version)'Unrestricted_Access);
      Arg_Any_version_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_VersionSpec,
            Arg_CC_version_Ü'Unchecked_Access);
      Arg_CC_IDL_type_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (IDL_type)'Unrestricted_Access);
      Arg_Any_IDL_type_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.IDLType.Helper.TC_IDLType,
            Arg_CC_IDL_type_Ü'Unchecked_Access);
      Arg_CC_value_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (value'Unrestricted_Access);
      Arg_Any_value_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.TC_Any,
            Arg_CC_value_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        create_constant_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_constant_Arg_Name_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_id_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_constant_Arg_Name_name_Ü,
         PolyORB.Any.Any
           (Arg_Any_name_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_constant_Arg_Name_version_Ü,
         PolyORB.Any.Any
           (Arg_Any_version_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_constant_Arg_Name_IDL_type_Ü,
         PolyORB.Any.Any
           (Arg_Any_IDL_type_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_constant_Arg_Name_value_Ü,
         PolyORB.Any.Any
           (Arg_Any_value_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "create_constant",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end create_constant;

   create_struct_Arg_Name_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("id");

   create_struct_Arg_Name_name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("name");

   create_struct_Arg_Name_version_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("version");

   create_struct_Arg_Name_members_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("members");

   create_struct_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   ----------------------------
   -- create_struct_Result_Ü --
   ----------------------------

   function create_struct_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (create_struct_Result_Ü);
   begin
      return (Name => create_struct_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.StructDef.Helper.TC_StructDef),
      Arg_Modes => 0);
   end create_struct_Result_Ü;

   -------------------
   -- create_struct --
   -------------------

   function create_struct
     (Self : Ref;
      id : CORBA.RepositoryId;
      name : CORBA.Identifier;
      version : CORBA.Repository_Root.VersionSpec;
      members : CORBA.Repository_Root.StructMemberSeq)
     return CORBA.Repository_Root.StructDef_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.StructDef_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (id)'Unrestricted_Access);
      Arg_Any_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_RepositoryId,
            Arg_CC_id_Ü'Unchecked_Access);
      Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (name)'Unrestricted_Access);
      Arg_Any_name_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_Identifier,
            Arg_CC_name_Ü'Unchecked_Access);
      Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (version)'Unrestricted_Access);
      Arg_Any_version_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_VersionSpec,
            Arg_CC_version_Ü'Unchecked_Access);
      Arg_CC_members_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Helper.Internals.Wrap
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_StructMember.Sequence
              (members)'Unrestricted_Access);
      Arg_Any_members_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_StructMemberSeq,
            Arg_CC_members_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        create_struct_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_struct_Arg_Name_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_id_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_struct_Arg_Name_name_Ü,
         PolyORB.Any.Any
           (Arg_Any_name_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_struct_Arg_Name_version_Ü,
         PolyORB.Any.Any
           (Arg_Any_version_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_struct_Arg_Name_members_Ü,
         PolyORB.Any.Any
           (Arg_Any_members_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "create_struct",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end create_struct;

   create_union_Arg_Name_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("id");

   create_union_Arg_Name_name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("name");

   create_union_Arg_Name_version_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("version");

   create_union_Arg_Name_discriminator_type_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("discriminator_type");

   create_union_Arg_Name_members_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("members");

   create_union_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   ---------------------------
   -- create_union_Result_Ü --
   ---------------------------

   function create_union_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (create_union_Result_Ü);
   begin
      return (Name => create_union_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.UnionDef.Helper.TC_UnionDef),
      Arg_Modes => 0);
   end create_union_Result_Ü;

   ------------------
   -- create_union --
   ------------------

   function create_union
     (Self : Ref;
      id : CORBA.RepositoryId;
      name : CORBA.Identifier;
      version : CORBA.Repository_Root.VersionSpec;
      discriminator_type : CORBA.Repository_Root.IDLType_Forward.Ref;
      members : CORBA.Repository_Root.UnionMemberSeq)
     return CORBA.Repository_Root.UnionDef_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.UnionDef_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (id)'Unrestricted_Access);
      Arg_Any_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_RepositoryId,
            Arg_CC_id_Ü'Unchecked_Access);
      Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (name)'Unrestricted_Access);
      Arg_Any_name_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_Identifier,
            Arg_CC_name_Ü'Unchecked_Access);
      Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (version)'Unrestricted_Access);
      Arg_Any_version_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_VersionSpec,
            Arg_CC_version_Ü'Unchecked_Access);
      Arg_CC_discriminator_type_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (discriminator_type)'Unrestricted_Access);
      Arg_Any_discriminator_type_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.IDLType.Helper.TC_IDLType,
            Arg_CC_discriminator_type_Ü'Unchecked_Access);
      Arg_CC_members_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Helper.Internals.Wrap
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_UnionMember.Sequence
              (members)'Unrestricted_Access);
      Arg_Any_members_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_UnionMemberSeq,
            Arg_CC_members_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        create_union_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_union_Arg_Name_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_id_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_union_Arg_Name_name_Ü,
         PolyORB.Any.Any
           (Arg_Any_name_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_union_Arg_Name_version_Ü,
         PolyORB.Any.Any
           (Arg_Any_version_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_union_Arg_Name_discriminator_type_Ü,
         PolyORB.Any.Any
           (Arg_Any_discriminator_type_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_union_Arg_Name_members_Ü,
         PolyORB.Any.Any
           (Arg_Any_members_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "create_union",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end create_union;

   create_enum_Arg_Name_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("id");

   create_enum_Arg_Name_name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("name");

   create_enum_Arg_Name_version_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("version");

   create_enum_Arg_Name_members_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("members");

   create_enum_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   --------------------------
   -- create_enum_Result_Ü --
   --------------------------

   function create_enum_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (create_enum_Result_Ü);
   begin
      return (Name => create_enum_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.EnumDef.Helper.TC_EnumDef),
      Arg_Modes => 0);
   end create_enum_Result_Ü;

   -----------------
   -- create_enum --
   -----------------

   function create_enum
     (Self : Ref;
      id : CORBA.RepositoryId;
      name : CORBA.Identifier;
      version : CORBA.Repository_Root.VersionSpec;
      members : CORBA.Repository_Root.EnumMemberSeq)
     return CORBA.Repository_Root.EnumDef_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.EnumDef_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (id)'Unrestricted_Access);
      Arg_Any_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_RepositoryId,
            Arg_CC_id_Ü'Unchecked_Access);
      Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (name)'Unrestricted_Access);
      Arg_Any_name_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_Identifier,
            Arg_CC_name_Ü'Unchecked_Access);
      Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (version)'Unrestricted_Access);
      Arg_Any_version_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_VersionSpec,
            Arg_CC_version_Ü'Unchecked_Access);
      Arg_CC_members_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Helper.Internals.Wrap
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Identifier.Sequence
              (members)'Unrestricted_Access);
      Arg_Any_members_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_EnumMemberSeq,
            Arg_CC_members_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        create_enum_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_enum_Arg_Name_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_id_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_enum_Arg_Name_name_Ü,
         PolyORB.Any.Any
           (Arg_Any_name_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_enum_Arg_Name_version_Ü,
         PolyORB.Any.Any
           (Arg_Any_version_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_enum_Arg_Name_members_Ü,
         PolyORB.Any.Any
           (Arg_Any_members_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "create_enum",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end create_enum;

   create_alias_Arg_Name_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("id");

   create_alias_Arg_Name_name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("name");

   create_alias_Arg_Name_version_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("version");

   create_alias_Arg_Name_original_type_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("original_type");

   create_alias_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   ---------------------------
   -- create_alias_Result_Ü --
   ---------------------------

   function create_alias_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (create_alias_Result_Ü);
   begin
      return (Name => create_alias_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.AliasDef.Helper.TC_AliasDef),
      Arg_Modes => 0);
   end create_alias_Result_Ü;

   ------------------
   -- create_alias --
   ------------------

   function create_alias
     (Self : Ref;
      id : CORBA.RepositoryId;
      name : CORBA.Identifier;
      version : CORBA.Repository_Root.VersionSpec;
      original_type : CORBA.Repository_Root.IDLType_Forward.Ref)
     return CORBA.Repository_Root.AliasDef_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.AliasDef_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (id)'Unrestricted_Access);
      Arg_Any_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_RepositoryId,
            Arg_CC_id_Ü'Unchecked_Access);
      Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (name)'Unrestricted_Access);
      Arg_Any_name_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_Identifier,
            Arg_CC_name_Ü'Unchecked_Access);
      Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (version)'Unrestricted_Access);
      Arg_Any_version_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_VersionSpec,
            Arg_CC_version_Ü'Unchecked_Access);
      Arg_CC_original_type_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (original_type)'Unrestricted_Access);
      Arg_Any_original_type_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.IDLType.Helper.TC_IDLType,
            Arg_CC_original_type_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        create_alias_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_alias_Arg_Name_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_id_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_alias_Arg_Name_name_Ü,
         PolyORB.Any.Any
           (Arg_Any_name_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_alias_Arg_Name_version_Ü,
         PolyORB.Any.Any
           (Arg_Any_version_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_alias_Arg_Name_original_type_Ü,
         PolyORB.Any.Any
           (Arg_Any_original_type_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "create_alias",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end create_alias;

   create_interface_Arg_Name_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("id");

   create_interface_Arg_Name_name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("name");

   create_interface_Arg_Name_version_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("version");

   create_interface_Arg_Name_base_interfaces_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("base_interfaces");

   create_interface_Arg_Name_is_abstract_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("is_abstract");

   create_interface_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   -------------------------------
   -- create_interface_Result_Ü --
   -------------------------------

   function create_interface_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (create_interface_Result_Ü);
   begin
      return (Name => create_interface_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.InterfaceDef.Helper.TC_InterfaceDef),
      Arg_Modes => 0);
   end create_interface_Result_Ü;

   ----------------------
   -- create_interface --
   ----------------------

   function create_interface
     (Self : Ref;
      id : CORBA.RepositoryId;
      name : CORBA.Identifier;
      version : CORBA.Repository_Root.VersionSpec;
      base_interfaces : CORBA.Repository_Root.InterfaceDefSeq;
      is_abstract : CORBA.Boolean)
     return CORBA.Repository_Root.InterfaceDef_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.InterfaceDef_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (id)'Unrestricted_Access);
      Arg_Any_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_RepositoryId,
            Arg_CC_id_Ü'Unchecked_Access);
      Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (name)'Unrestricted_Access);
      Arg_Any_name_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_Identifier,
            Arg_CC_name_Ü'Unchecked_Access);
      Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (version)'Unrestricted_Access);
      Arg_Any_version_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_VersionSpec,
            Arg_CC_version_Ü'Unchecked_Access);
      Arg_CC_base_interfaces_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Helper.Internals.Wrap
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_InterfaceDef_Forward.Sequence
              (base_interfaces)'Unrestricted_Access);
      Arg_Any_base_interfaces_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_InterfaceDefSeq,
            Arg_CC_base_interfaces_Ü'Unchecked_Access);
      Arg_CC_is_abstract_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (is_abstract'Unrestricted_Access);
      Arg_Any_is_abstract_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.TC_Boolean,
            Arg_CC_is_abstract_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        create_interface_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_interface_Arg_Name_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_id_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_interface_Arg_Name_name_Ü,
         PolyORB.Any.Any
           (Arg_Any_name_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_interface_Arg_Name_version_Ü,
         PolyORB.Any.Any
           (Arg_Any_version_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_interface_Arg_Name_base_interfaces_Ü,
         PolyORB.Any.Any
           (Arg_Any_base_interfaces_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_interface_Arg_Name_is_abstract_Ü,
         PolyORB.Any.Any
           (Arg_Any_is_abstract_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "create_interface",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end create_interface;

   create_value_Arg_Name_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("id");

   create_value_Arg_Name_name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("name");

   create_value_Arg_Name_version_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("version");

   create_value_Arg_Name_is_custom_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("is_custom");

   create_value_Arg_Name_is_abstract_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("is_abstract");

   create_value_Arg_Name_base_value_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("base_value");

   create_value_Arg_Name_is_truncatable_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("is_truncatable");

   create_value_Arg_Name_abstract_base_values_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("abstract_base_values");

   create_value_Arg_Name_supported_interfaces_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("supported_interfaces");

   create_value_Arg_Name_initializers_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("initializers");

   create_value_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   ---------------------------
   -- create_value_Result_Ü --
   ---------------------------

   function create_value_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (create_value_Result_Ü);
   begin
      return (Name => create_value_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.ValueDef.Helper.TC_ValueDef),
      Arg_Modes => 0);
   end create_value_Result_Ü;

   ------------------
   -- create_value --
   ------------------

   function create_value
     (Self : Ref;
      id : CORBA.RepositoryId;
      name : CORBA.Identifier;
      version : CORBA.Repository_Root.VersionSpec;
      is_custom : CORBA.Boolean;
      is_abstract : CORBA.Boolean;
      base_value : CORBA.Repository_Root.ValueDef_Forward.Ref;
      is_truncatable : CORBA.Boolean;
      abstract_base_values : CORBA.Repository_Root.ValueDefSeq;
      supported_interfaces : CORBA.Repository_Root.InterfaceDefSeq;
      initializers : CORBA.Repository_Root.InitializerSeq)
     return CORBA.Repository_Root.ValueDef_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.ValueDef_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (id)'Unrestricted_Access);
      Arg_Any_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_RepositoryId,
            Arg_CC_id_Ü'Unchecked_Access);
      Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (name)'Unrestricted_Access);
      Arg_Any_name_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_Identifier,
            Arg_CC_name_Ü'Unchecked_Access);
      Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (version)'Unrestricted_Access);
      Arg_Any_version_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_VersionSpec,
            Arg_CC_version_Ü'Unchecked_Access);
      Arg_CC_is_custom_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (is_custom'Unrestricted_Access);
      Arg_Any_is_custom_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.TC_Boolean,
            Arg_CC_is_custom_Ü'Unchecked_Access);
      Arg_CC_is_abstract_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (is_abstract'Unrestricted_Access);
      Arg_Any_is_abstract_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.TC_Boolean,
            Arg_CC_is_abstract_Ü'Unchecked_Access);
      Arg_CC_base_value_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (base_value)'Unrestricted_Access);
      Arg_Any_base_value_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.ValueDef.Helper.TC_ValueDef,
            Arg_CC_base_value_Ü'Unchecked_Access);
      Arg_CC_is_truncatable_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (is_truncatable'Unrestricted_Access);
      Arg_Any_is_truncatable_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.TC_Boolean,
            Arg_CC_is_truncatable_Ü'Unchecked_Access);
      Arg_CC_abstract_base_values_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Helper.Internals.Wrap
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ValueDef_Forward.Sequence
              (abstract_base_values)'Unrestricted_Access);
      Arg_Any_abstract_base_values_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_ValueDefSeq,
            Arg_CC_abstract_base_values_Ü'Unchecked_Access);
      Arg_CC_supported_interfaces_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Helper.Internals.Wrap
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_InterfaceDef_Forward.Sequence
              (supported_interfaces)'Unrestricted_Access);
      Arg_Any_supported_interfaces_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_InterfaceDefSeq,
            Arg_CC_supported_interfaces_Ü'Unchecked_Access);
      Arg_CC_initializers_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Helper.Internals.Wrap
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Initializer.Sequence
              (initializers)'Unrestricted_Access);
      Arg_Any_initializers_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_InitializerSeq,
            Arg_CC_initializers_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        create_value_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_value_Arg_Name_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_id_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_value_Arg_Name_name_Ü,
         PolyORB.Any.Any
           (Arg_Any_name_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_value_Arg_Name_version_Ü,
         PolyORB.Any.Any
           (Arg_Any_version_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_value_Arg_Name_is_custom_Ü,
         PolyORB.Any.Any
           (Arg_Any_is_custom_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_value_Arg_Name_is_abstract_Ü,
         PolyORB.Any.Any
           (Arg_Any_is_abstract_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_value_Arg_Name_base_value_Ü,
         PolyORB.Any.Any
           (Arg_Any_base_value_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_value_Arg_Name_is_truncatable_Ü,
         PolyORB.Any.Any
           (Arg_Any_is_truncatable_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_value_Arg_Name_abstract_base_values_Ü,
         PolyORB.Any.Any
           (Arg_Any_abstract_base_values_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_value_Arg_Name_supported_interfaces_Ü,
         PolyORB.Any.Any
           (Arg_Any_supported_interfaces_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_value_Arg_Name_initializers_Ü,
         PolyORB.Any.Any
           (Arg_Any_initializers_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "create_value",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end create_value;

   create_value_box_Arg_Name_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("id");

   create_value_box_Arg_Name_name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("name");

   create_value_box_Arg_Name_version_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("version");

   create_value_box_Arg_Name_original_type_def_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("original_type_def");

   create_value_box_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   -------------------------------
   -- create_value_box_Result_Ü --
   -------------------------------

   function create_value_box_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (create_value_box_Result_Ü);
   begin
      return (Name => create_value_box_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.ValueBoxDef.Helper.TC_ValueBoxDef),
      Arg_Modes => 0);
   end create_value_box_Result_Ü;

   ----------------------
   -- create_value_box --
   ----------------------

   function create_value_box
     (Self : Ref;
      id : CORBA.RepositoryId;
      name : CORBA.Identifier;
      version : CORBA.Repository_Root.VersionSpec;
      original_type_def : CORBA.Repository_Root.IDLType_Forward.Ref)
     return CORBA.Repository_Root.ValueBoxDef_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.ValueBoxDef_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (id)'Unrestricted_Access);
      Arg_Any_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_RepositoryId,
            Arg_CC_id_Ü'Unchecked_Access);
      Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (name)'Unrestricted_Access);
      Arg_Any_name_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_Identifier,
            Arg_CC_name_Ü'Unchecked_Access);
      Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (version)'Unrestricted_Access);
      Arg_Any_version_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_VersionSpec,
            Arg_CC_version_Ü'Unchecked_Access);
      Arg_CC_original_type_def_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (original_type_def)'Unrestricted_Access);
      Arg_Any_original_type_def_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.IDLType.Helper.TC_IDLType,
            Arg_CC_original_type_def_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        create_value_box_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_value_box_Arg_Name_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_id_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_value_box_Arg_Name_name_Ü,
         PolyORB.Any.Any
           (Arg_Any_name_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_value_box_Arg_Name_version_Ü,
         PolyORB.Any.Any
           (Arg_Any_version_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_value_box_Arg_Name_original_type_def_Ü,
         PolyORB.Any.Any
           (Arg_Any_original_type_def_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "create_value_box",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end create_value_box;

   create_exception_Arg_Name_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("id");

   create_exception_Arg_Name_name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("name");

   create_exception_Arg_Name_version_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("version");

   create_exception_Arg_Name_members_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("members");

   create_exception_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   -------------------------------
   -- create_exception_Result_Ü --
   -------------------------------

   function create_exception_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (create_exception_Result_Ü);
   begin
      return (Name => create_exception_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.ExceptionDef.Helper.TC_ExceptionDef),
      Arg_Modes => 0);
   end create_exception_Result_Ü;

   ----------------------
   -- create_exception --
   ----------------------

   function create_exception
     (Self : Ref;
      id : CORBA.RepositoryId;
      name : CORBA.Identifier;
      version : CORBA.Repository_Root.VersionSpec;
      members : CORBA.Repository_Root.StructMemberSeq)
     return CORBA.Repository_Root.ExceptionDef_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.ExceptionDef_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (id)'Unrestricted_Access);
      Arg_Any_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_RepositoryId,
            Arg_CC_id_Ü'Unchecked_Access);
      Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (name)'Unrestricted_Access);
      Arg_Any_name_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_Identifier,
            Arg_CC_name_Ü'Unchecked_Access);
      Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (version)'Unrestricted_Access);
      Arg_Any_version_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_VersionSpec,
            Arg_CC_version_Ü'Unchecked_Access);
      Arg_CC_members_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Helper.Internals.Wrap
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_StructMember.Sequence
              (members)'Unrestricted_Access);
      Arg_Any_members_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_StructMemberSeq,
            Arg_CC_members_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        create_exception_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_exception_Arg_Name_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_id_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_exception_Arg_Name_name_Ü,
         PolyORB.Any.Any
           (Arg_Any_name_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_exception_Arg_Name_version_Ü,
         PolyORB.Any.Any
           (Arg_Any_version_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_exception_Arg_Name_members_Ü,
         PolyORB.Any.Any
           (Arg_Any_members_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "create_exception",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end create_exception;

   create_native_Arg_Name_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("id");

   create_native_Arg_Name_name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("name");

   create_native_Arg_Name_version_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("version");

   create_native_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   ----------------------------
   -- create_native_Result_Ü --
   ----------------------------

   function create_native_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (create_native_Result_Ü);
   begin
      return (Name => create_native_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.NativeDef.Helper.TC_NativeDef),
      Arg_Modes => 0);
   end create_native_Result_Ü;

   -------------------
   -- create_native --
   -------------------

   function create_native
     (Self : Ref;
      id : CORBA.RepositoryId;
      name : CORBA.Identifier;
      version : CORBA.Repository_Root.VersionSpec)
     return CORBA.Repository_Root.NativeDef_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.NativeDef_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (id)'Unrestricted_Access);
      Arg_Any_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_RepositoryId,
            Arg_CC_id_Ü'Unchecked_Access);
      Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (name)'Unrestricted_Access);
      Arg_Any_name_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_Identifier,
            Arg_CC_name_Ü'Unchecked_Access);
      Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (version)'Unrestricted_Access);
      Arg_Any_version_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_VersionSpec,
            Arg_CC_version_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        create_native_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_native_Arg_Name_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_id_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_native_Arg_Name_name_Ü,
         PolyORB.Any.Any
           (Arg_Any_name_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_native_Arg_Name_version_Ü,
         PolyORB.Any.Any
           (Arg_Any_version_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "create_native",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end create_native;

   create_abstract_interface_Arg_Name_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("id");

   create_abstract_interface_Arg_Name_name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("name");

   create_abstract_interface_Arg_Name_version_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("version");

   create_abstract_interface_Arg_Name_base_interfaces_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("base_interfaces");

   create_abstract_interface_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   ----------------------------------------
   -- create_abstract_interface_Result_Ü --
   ----------------------------------------

   function create_abstract_interface_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (create_abstract_interface_Result_Ü);
   begin
      return (Name => create_abstract_interface_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.AbstractInterfaceDef.Helper.TC_AbstractInterfaceDef),
      Arg_Modes => 0);
   end create_abstract_interface_Result_Ü;

   -------------------------------
   -- create_abstract_interface --
   -------------------------------

   function create_abstract_interface
     (Self : Ref;
      id : CORBA.RepositoryId;
      name : CORBA.Identifier;
      version : CORBA.Repository_Root.VersionSpec;
      base_interfaces : CORBA.Repository_Root.AbstractInterfaceDefSeq)
     return CORBA.Repository_Root.AbstractInterfaceDef_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.AbstractInterfaceDef_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (id)'Unrestricted_Access);
      Arg_Any_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_RepositoryId,
            Arg_CC_id_Ü'Unchecked_Access);
      Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (name)'Unrestricted_Access);
      Arg_Any_name_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_Identifier,
            Arg_CC_name_Ü'Unchecked_Access);
      Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (version)'Unrestricted_Access);
      Arg_Any_version_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_VersionSpec,
            Arg_CC_version_Ü'Unchecked_Access);
      Arg_CC_base_interfaces_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Helper.Internals.Wrap
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward.Sequence
              (base_interfaces)'Unrestricted_Access);
      Arg_Any_base_interfaces_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_AbstractInterfaceDefSeq,
            Arg_CC_base_interfaces_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        create_abstract_interface_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_abstract_interface_Arg_Name_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_id_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_abstract_interface_Arg_Name_name_Ü,
         PolyORB.Any.Any
           (Arg_Any_name_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_abstract_interface_Arg_Name_version_Ü,
         PolyORB.Any.Any
           (Arg_Any_version_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_abstract_interface_Arg_Name_base_interfaces_Ü,
         PolyORB.Any.Any
           (Arg_Any_base_interfaces_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "create_abstract_interface",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end create_abstract_interface;

   create_local_interface_Arg_Name_id_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("id");

   create_local_interface_Arg_Name_name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("name");

   create_local_interface_Arg_Name_version_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("version");

   create_local_interface_Arg_Name_base_interfaces_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("base_interfaces");

   create_local_interface_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   -------------------------------------
   -- create_local_interface_Result_Ü --
   -------------------------------------

   function create_local_interface_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (create_local_interface_Result_Ü);
   begin
      return (Name => create_local_interface_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.LocalInterfaceDef.Helper.TC_LocalInterfaceDef),
      Arg_Modes => 0);
   end create_local_interface_Result_Ü;

   ----------------------------
   -- create_local_interface --
   ----------------------------

   function create_local_interface
     (Self : Ref;
      id : CORBA.RepositoryId;
      name : CORBA.Identifier;
      version : CORBA.Repository_Root.VersionSpec;
      base_interfaces : CORBA.Repository_Root.InterfaceDefSeq)
     return CORBA.Repository_Root.LocalInterfaceDef_Forward.Ref
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.LocalInterfaceDef_Forward.Ref;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Object.Helper.Wrap
           (CORBA.Object.Ref
              (Result_Ü)'Unrestricted_Access);
      Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (id)'Unrestricted_Access);
      Arg_Any_id_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_RepositoryId,
            Arg_CC_id_Ü'Unchecked_Access);
      Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (name)'Unrestricted_Access);
      Arg_Any_name_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Helper.TC_Identifier,
            Arg_CC_name_Ü'Unchecked_Access);
      Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Wrap
           (CORBA.String
              (version)'Unrestricted_Access);
      Arg_Any_version_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_VersionSpec,
            Arg_CC_version_Ü'Unchecked_Access);
      Arg_CC_base_interfaces_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Helper.Internals.Wrap
           (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_InterfaceDef_Forward.Sequence
              (base_interfaces)'Unrestricted_Access);
      Arg_Any_base_interfaces_Ü : constant CORBA.Any :=
        CORBA.Internals.Get_Wrapper_Any
           (CORBA.Repository_Root.Helper.TC_InterfaceDefSeq,
            Arg_CC_base_interfaces_Ü'Unchecked_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        create_local_interface_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Fill the Argument list
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_local_interface_Arg_Name_id_Ü,
         PolyORB.Any.Any
           (Arg_Any_id_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_local_interface_Arg_Name_name_Ü,
         PolyORB.Any.Any
           (Arg_Any_name_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_local_interface_Arg_Name_version_Ü,
         PolyORB.Any.Any
           (Arg_Any_version_Ü),
         PolyORB.Any.ARG_IN);
      PolyORB.Any.NVList.Add_Item
        (Argument_List_Ü,
         create_local_interface_Arg_Name_base_interfaces_Ü,
         PolyORB.Any.Any
           (Arg_Any_base_interfaces_Ü),
         PolyORB.Any.ARG_IN);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "create_local_interface",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end create_local_interface;

   get_def_kind_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   ---------------------------
   -- get_def_kind_Result_Ü --
   ---------------------------

   function get_def_kind_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (get_def_kind_Result_Ü);
   begin
      return (Name => get_def_kind_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.Repository_Root.Helper.TC_DefinitionKind),
      Arg_Modes => 0);
   end get_def_kind_Result_Ü;

   ------------------
   -- get_def_kind --
   ------------------

   function get_def_kind
     (Self : Ref)
     return CORBA.Repository_Root.DefinitionKind
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Result_Ü : CORBA.Repository_Root.DefinitionKind;
      pragma Warnings (Off, Result_Ü);
      pragma Suppress (Validity_Check, Result_Ü);
      Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
        CORBA.Repository_Root.Helper.Internals.Wrap
           (Result_Ü'Unrestricted_Access);
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        get_def_kind_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Setting the result value
      PolyORB.Any.Set_Value
        (PolyORB.Any.Get_Container
           (Result_Nv_Ü.Argument).all,
         Arg_CC_Result_Ü_Ü'Unrestricted_Access);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "_get_def_kind",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
      --  Return value
      return Result_Ü;
   end get_def_kind;

   destroy_Result_Name_Ü : constant PolyORB.Types.Identifier :=
     PolyORB.Types.To_PolyORB_String
        ("Result");

   ----------------------
   -- destroy_Result_Ü --
   ----------------------

   function destroy_Result_Ü return PolyORB.Any.NamedValue is
      pragma Inline (destroy_Result_Ü);
   begin
      return (Name => destroy_Result_Name_Ü,
      Argument => CORBA.Internals.Get_Empty_Any
        (CORBA.TC_Void),
      Arg_Modes => 0);
   end destroy_Result_Ü;

   -------------
   -- destroy --
   -------------

   procedure destroy
     (Self : Ref)
   is
      Argument_List_Ü : PolyORB.Any.NVList.Ref;
      Request_Ü : aliased PolyORB.Requests.Request;
      Result_Nv_Ü : PolyORB.Any.NamedValue :=
        destroy_Result_Ü;
   begin
      if CORBA.Object.Is_Nil
        (CORBA.Object.Ref
           (Self))
      then
         CORBA.Raise_Inv_Objref
           (CORBA.Default_Sys_Member);
      end if;
      --  Create the Argument list
      PolyORB.Any.NVList.Create
        (Argument_List_Ü);
      --  Creating the request
      PolyORB.Requests.Setup_Request
        (Req => Request_Ü,
         Target => CORBA.Object.Internals.To_PolyORB_Ref
           (CORBA.Object.Ref
              (Self)),
         Operation => "destroy",
         Arg_List => Argument_List_Ü,
         Result => Result_Nv_Ü);
      --  Invoking the request (synchronously or asynchronously)
      PolyORB.CORBA_P.Interceptors_Hooks.Client_Invoke
        (Request_Ü'Access,
         PolyORB.Requests.Flags
           (0));
      --  Raise exception, if needed
      PolyORB.CORBA_P.Exceptions.Request_Raise_Occurrence
        (Request_Ü);
   end destroy;

   ----------
   -- Is_A --
   ----------

   function Is_A
     (Self : Ref;
      Logical_Type_Id : PolyORB.Std.String)
     return CORBA.Boolean
   is
   begin
      return (False
         or else (Is_A
           (Logical_Type_Id)
            or else CORBA.Object.Is_A
              (CORBA.Object.Ref
                 (Self),
               Logical_Type_Id)));
   end Is_A;

   ----------
   -- Is_A --
   ----------

   function Is_A
     (Logical_Type_Id : PolyORB.Std.String)
     return CORBA.Boolean
   is
   begin
      return (((CORBA.Is_Equivalent
        (Logical_Type_Id,
         CORBA.Repository_Root.StructDef.Repository_Id)
         or else CORBA.Is_Equivalent
           (Logical_Type_Id,
            "IDL:omg.org/CORBA/Object:1.0"))
         or else (((CORBA.Is_Equivalent
           (Logical_Type_Id,
            CORBA.Repository_Root.TypedefDef.Repository_Id)
            or else (((CORBA.Is_Equivalent
              (Logical_Type_Id,
               CORBA.Repository_Root.Contained.Repository_Id)
               or else CORBA.Is_Equivalent
                 (Logical_Type_Id,
                  CORBA.Repository_Root.IRObject.Repository_Id))
               or else CORBA.Is_Equivalent
                 (Logical_Type_Id,
                  CORBA.Repository_Root.IDLType.Repository_Id))
               or else CORBA.Is_Equivalent
                 (Logical_Type_Id,
                  CORBA.Repository_Root.IRObject.Repository_Id)))
            or else CORBA.Is_Equivalent
              (Logical_Type_Id,
               CORBA.Repository_Root.Container.Repository_Id))
            or else CORBA.Is_Equivalent
              (Logical_Type_Id,
               CORBA.Repository_Root.IRObject.Repository_Id)))
         or else False);
   end Is_A;

end CORBA.Repository_Root.StructDef;
