pragma Style_Checks ("NM32766");

---------------------------------------------------
--  This file has been generated automatically from
--  /work/a/ports/net/polyorb/work/polyorb-2.9.0/idls/CORBA_IDL/orb.idl
--  by IAC (IDL to Ada Compiler) 2.9.0 (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 CORBA;
pragma Elaborate_All (CORBA);
with CORBA.Repository_Root.AbstractInterfaceDef.Impl;
with CORBA.Repository_Root.Helper;
with CORBA.Repository_Root;
with PolyORB.Any;
with CORBA.ServerRequest;
with CORBA.NVList;
with CORBA.Helper;
with CORBA.Repository_Root.InterfaceDef;
with CORBA.Repository_Root.InterfaceDef.Helper;
with CORBA.Repository_Root.IDLType;
with CORBA.Object.Helper;
with CORBA.Object;
with CORBA.Repository_Root.IDLType.Helper;
with CORBA.Repository_Root.AttributeDef;
with CORBA.Repository_Root.AttributeDef.Helper;
with CORBA.Repository_Root.OperationDef;
with CORBA.Repository_Root.OperationDef.Helper;
with CORBA.Repository_Root.Contained;
with CORBA.Repository_Root.Contained.Helper;
with CORBA.Repository_Root.Container;
with CORBA.Repository_Root.Container.Helper;
with CORBA.Repository_Root.ModuleDef.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.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.Repository.Helper;
with PolyORB.CORBA_P.IR_Hooks;
with PolyORB.CORBA_P.Domain_Management;
with CORBA_Repository_Root_AbstractInterfaceDef_Hash;
with PolyORB.Std;
with PortableServer;
with CORBA.ORB;
with PolyORB.CORBA_P.Exceptions;
with PolyORB.Qos.Exception_Informations;
with PolyORB.Utils.Strings;
with PolyORB.Utils.Strings.Lists;
with PolyORB.Initialization;

package body CORBA.Repository_Root.AbstractInterfaceDef.Skel is

   set_base_interfaces_Arg_Name_To_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("To");

   set_is_abstract_Arg_Name_To_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("To");

   is_a_Arg_Name_interface_id_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("interface_id");

   create_attribute_Arg_Name_id_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("id");

   create_attribute_Arg_Name_name_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("name");

   create_attribute_Arg_Name_version_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("version");

   create_attribute_Arg_Name_IDL_type_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("IDL_type");

   create_attribute_Arg_Name_mode_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("mode");

   create_operation_Arg_Name_id_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("id");

   create_operation_Arg_Name_name_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("name");

   create_operation_Arg_Name_version_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("version");

   create_operation_Arg_Name_result_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("result");

   create_operation_Arg_Name_mode_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("mode");

   create_operation_Arg_Name_params_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("params");

   create_operation_Arg_Name_exceptions_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("exceptions");

   create_operation_Arg_Name_contexts_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("contexts");

   lookup_Arg_Name_search_name_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("search_name");

   contents_Arg_Name_limit_type_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("limit_type");

   contents_Arg_Name_exclude_inherited_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("exclude_inherited");

   lookup_name_Arg_Name_search_name_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("search_name");

   lookup_name_Arg_Name_levels_to_search_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("levels_to_search");

   lookup_name_Arg_Name_limit_type_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("limit_type");

   lookup_name_Arg_Name_exclude_inherited_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("exclude_inherited");

   describe_contents_Arg_Name_limit_type_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("limit_type");

   describe_contents_Arg_Name_exclude_inherited_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("exclude_inherited");

   describe_contents_Arg_Name_max_returned_objs_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("max_returned_objs");

   create_module_Arg_Name_id_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("id");

   create_module_Arg_Name_name_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("name");

   create_module_Arg_Name_version_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("version");

   create_constant_Arg_Name_id_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("id");

   create_constant_Arg_Name_name_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("name");

   create_constant_Arg_Name_version_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("version");

   create_constant_Arg_Name_IDL_type_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("IDL_type");

   create_constant_Arg_Name_value_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("value");

   create_struct_Arg_Name_id_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("id");

   create_struct_Arg_Name_name_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("name");

   create_struct_Arg_Name_version_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("version");

   create_struct_Arg_Name_members_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("members");

   create_union_Arg_Name_id_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("id");

   create_union_Arg_Name_name_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("name");

   create_union_Arg_Name_version_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("version");

   create_union_Arg_Name_discriminator_type_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("discriminator_type");

   create_union_Arg_Name_members_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("members");

   create_enum_Arg_Name_id_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("id");

   create_enum_Arg_Name_name_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("name");

   create_enum_Arg_Name_version_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("version");

   create_enum_Arg_Name_members_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("members");

   create_alias_Arg_Name_id_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("id");

   create_alias_Arg_Name_name_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("name");

   create_alias_Arg_Name_version_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("version");

   create_alias_Arg_Name_original_type_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("original_type");

   create_interface_Arg_Name_id_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("id");

   create_interface_Arg_Name_name_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("name");

   create_interface_Arg_Name_version_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("version");

   create_interface_Arg_Name_base_interfaces_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("base_interfaces");

   create_interface_Arg_Name_is_abstract_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("is_abstract");

   create_value_Arg_Name_id_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("id");

   create_value_Arg_Name_name_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("name");

   create_value_Arg_Name_version_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("version");

   create_value_Arg_Name_is_custom_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("is_custom");

   create_value_Arg_Name_is_abstract_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("is_abstract");

   create_value_Arg_Name_base_value_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("base_value");

   create_value_Arg_Name_is_truncatable_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("is_truncatable");

   create_value_Arg_Name_abstract_base_values_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("abstract_base_values");

   create_value_Arg_Name_supported_interfaces_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("supported_interfaces");

   create_value_Arg_Name_initializers_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("initializers");

   create_value_box_Arg_Name_id_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("id");

   create_value_box_Arg_Name_name_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("name");

   create_value_box_Arg_Name_version_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("version");

   create_value_box_Arg_Name_original_type_def_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("original_type_def");

   create_exception_Arg_Name_id_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("id");

   create_exception_Arg_Name_name_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("name");

   create_exception_Arg_Name_version_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("version");

   create_exception_Arg_Name_members_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("members");

   create_native_Arg_Name_id_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("id");

   create_native_Arg_Name_name_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("name");

   create_native_Arg_Name_version_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("version");

   create_abstract_interface_Arg_Name_id_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("id");

   create_abstract_interface_Arg_Name_name_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("name");

   create_abstract_interface_Arg_Name_version_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("version");

   create_abstract_interface_Arg_Name_base_interfaces_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("base_interfaces");

   create_local_interface_Arg_Name_id_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("id");

   create_local_interface_Arg_Name_name_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("name");

   create_local_interface_Arg_Name_version_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("version");

   create_local_interface_Arg_Name_base_interfaces_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("base_interfaces");

   set_id_Arg_Name_To_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("To");

   set_name_Arg_Name_To_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("To");

   set_version_Arg_Name_To_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("To");

   move_Arg_Name_new_container_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("new_container");

   move_Arg_Name_new_name_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("new_name");

   move_Arg_Name_new_version_Ü : constant CORBA.Identifier :=
     CORBA.To_CORBA_String
        ("new_version");

   N_Operations : constant PolyORB.Std.Natural :=
     44;

   type String_Ptr is
     access PolyORB.Std.String;

   Invoke_Db : array (0 .. (N_Operations
      - 1)) of String_Ptr :=
     (others => null);

   procedure Register_Procedure
     (Operation_Name : PolyORB.Std.String);

   ------------------------
   -- Register_Procedure --
   ------------------------

   procedure Register_Procedure
     (Operation_Name : PolyORB.Std.String)
   is
      Index_Ü : PolyORB.Std.Natural;
      Invoke_Name_Access : String_Ptr;
   begin
      Index_Ü :=
        CORBA_Repository_Root_AbstractInterfaceDef_Hash.Hash
           (Operation_Name);
      if (Invoke_Db
        (Index_Ü)
         /= null)
      then
         raise Program_Error;
      end if;
      Invoke_Name_Access :=
        new PolyORB.Std.String'
           (Operation_Name);
      Invoke_Db
        (Index_Ü) :=
        Invoke_Name_Access;
   end Register_Procedure;

   procedure Invoke
     (Self : PortableServer.Servant;
      Request : CORBA.ServerRequest.Object_Ptr);

   ------------
   -- Invoke --
   ------------

   procedure Invoke
     (Self : PortableServer.Servant;
      Request : CORBA.ServerRequest.Object_Ptr)
   is
      Operation_Ü : constant PolyORB.Std.String :=
        CORBA.To_Standard_String
           (CORBA.ServerRequest.Operation
              (Request.all));
      Argument_List_Ü : CORBA.NVList.Ref;
      Index_Ü : PolyORB.Std.Natural;
      Invoke_Name_Access : String_Ptr;

      procedure Invoke_Uget_base_interfaces;

      ---------------------------------
      -- Invoke_Uget_base_interfaces --
      ---------------------------------

      procedure Invoke_Uget_base_interfaces is
         Result_Ü : CORBA.Repository_Root.InterfaceDefSeq;
         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_InterfaceDef_Forward.Sequence
                 (Result_Ü)'Unrestricted_Access);
         Arg_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.Helper.TC_InterfaceDefSeq,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.get_base_interfaces
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uget_base_interfaces;

      procedure Invoke_Uset_base_interfaces;

      ---------------------------------
      -- Invoke_Uset_base_interfaces --
      ---------------------------------

      procedure Invoke_Uset_base_interfaces is
         Argument_To_Ü : CORBA.Repository_Root.InterfaceDefSeq;
         pragma Warnings (Off, Argument_To_Ü);
         pragma Suppress (Validity_Check, Argument_To_Ü);
         Arg_CC_To_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.Helper.Internals.Wrap
              (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_InterfaceDef_Forward.Sequence
                 (Argument_To_Ü)'Unrestricted_Access);
         Arg_Any_To_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.Helper.TC_InterfaceDefSeq,
               Arg_CC_To_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            set_base_interfaces_Arg_Name_To_Ü,
            Arg_Any_To_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         CORBA.Repository_Root.AbstractInterfaceDef.Impl.set_base_interfaces
           (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
              (Self.all)'Access,
            Argument_To_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uset_base_interfaces;

      procedure Invoke_Uget_is_abstract;

      -----------------------------
      -- Invoke_Uget_is_abstract --
      -----------------------------

      procedure Invoke_Uget_is_abstract is
         Result_Ü : CORBA.Boolean;
         pragma Warnings (Off, Result_Ü);
         pragma Suppress (Validity_Check, Result_Ü);
         Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (Result_Ü'Unrestricted_Access);
         Arg_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.TC_Boolean,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.get_is_abstract
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uget_is_abstract;

      procedure Invoke_Uset_is_abstract;

      -----------------------------
      -- Invoke_Uset_is_abstract --
      -----------------------------

      procedure Invoke_Uset_is_abstract is
         Argument_To_Ü : CORBA.Boolean;
         pragma Warnings (Off, Argument_To_Ü);
         pragma Suppress (Validity_Check, Argument_To_Ü);
         Arg_CC_To_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (Argument_To_Ü'Unrestricted_Access);
         Arg_Any_To_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.TC_Boolean,
               Arg_CC_To_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            set_is_abstract_Arg_Name_To_Ü,
            Arg_Any_To_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         CORBA.Repository_Root.AbstractInterfaceDef.Impl.set_is_abstract
           (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
              (Self.all)'Access,
            Argument_To_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uset_is_abstract;

      procedure Invoke_is_a;

      -----------------
      -- Invoke_is_a --
      -----------------

      procedure Invoke_is_a is
         Argument_interface_id_Ü : CORBA.RepositoryId;
         pragma Warnings (Off, Argument_interface_id_Ü);
         pragma Suppress (Validity_Check, Argument_interface_id_Ü);
         Arg_CC_interface_id_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_interface_id_Ü)'Unrestricted_Access);
         Arg_Any_interface_id_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_RepositoryId,
               Arg_CC_interface_id_Ü'Unchecked_Access);
         Result_Ü : CORBA.Boolean;
         pragma Warnings (Off, Result_Ü);
         pragma Suppress (Validity_Check, Result_Ü);
         Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (Result_Ü'Unrestricted_Access);
         Arg_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.TC_Boolean,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            is_a_Arg_Name_interface_id_Ü,
            Arg_Any_interface_id_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.is_a
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_interface_id_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_is_a;

      procedure Invoke_describe_interface;

      -------------------------------
      -- Invoke_describe_interface --
      -------------------------------

      procedure Invoke_describe_interface is
         Result_Ü : CORBA.Repository_Root.InterfaceDef.FullInterfaceDescription;
         pragma Warnings (Off, Result_Ü);
         pragma Suppress (Validity_Check, Result_Ü);
         Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.InterfaceDef.Helper.Internals.Wrap
              (Result_Ü'Unrestricted_Access);
         Arg_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.InterfaceDef.Helper.TC_FullInterfaceDescription,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.describe_interface
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_describe_interface;

      procedure Invoke_create_attribute;

      -----------------------------
      -- Invoke_create_attribute --
      -----------------------------

      procedure Invoke_create_attribute is
         Argument_id_Ü : CORBA.RepositoryId;
         pragma Warnings (Off, Argument_id_Ü);
         pragma Suppress (Validity_Check, Argument_id_Ü);
         Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_id_Ü)'Unrestricted_Access);
         Arg_Any_id_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_RepositoryId,
               Arg_CC_id_Ü'Unchecked_Access);
         Argument_name_Ü : CORBA.Identifier;
         pragma Warnings (Off, Argument_name_Ü);
         pragma Suppress (Validity_Check, Argument_name_Ü);
         Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_name_Ü)'Unrestricted_Access);
         Arg_Any_name_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_Identifier,
               Arg_CC_name_Ü'Unchecked_Access);
         Argument_version_Ü : CORBA.Repository_Root.VersionSpec;
         pragma Warnings (Off, Argument_version_Ü);
         pragma Suppress (Validity_Check, Argument_version_Ü);
         Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_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);
         Argument_IDL_type_Ü : CORBA.Repository_Root.IDLType.Ref;
         pragma Warnings (Off, Argument_IDL_type_Ü);
         pragma Suppress (Validity_Check, Argument_IDL_type_Ü);
         Arg_CC_IDL_type_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Object.Helper.Wrap
              (CORBA.Object.Ref
                 (Argument_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);
         Argument_mode_Ü : CORBA.Repository_Root.AttributeMode;
         pragma Warnings (Off, Argument_mode_Ü);
         pragma Suppress (Validity_Check, Argument_mode_Ü);
         Arg_CC_mode_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.Helper.Internals.Wrap
              (Argument_mode_Ü'Unrestricted_Access);
         Arg_Any_mode_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.Helper.TC_AttributeMode,
               Arg_CC_mode_Ü'Unchecked_Access);
         Result_Ü : CORBA.Repository_Root.AttributeDef.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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.AttributeDef.Helper.TC_AttributeDef,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_attribute_Arg_Name_id_Ü,
            Arg_Any_id_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_attribute_Arg_Name_name_Ü,
            Arg_Any_name_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_attribute_Arg_Name_version_Ü,
            Arg_Any_version_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_attribute_Arg_Name_IDL_type_Ü,
            Arg_Any_IDL_type_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_attribute_Arg_Name_mode_Ü,
            Arg_Any_mode_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.create_attribute
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_id_Ü,
               Argument_name_Ü,
               Argument_version_Ü,
               Argument_IDL_type_Ü,
               Argument_mode_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_create_attribute;

      procedure Invoke_create_operation;

      -----------------------------
      -- Invoke_create_operation --
      -----------------------------

      procedure Invoke_create_operation is
         Argument_id_Ü : CORBA.RepositoryId;
         pragma Warnings (Off, Argument_id_Ü);
         pragma Suppress (Validity_Check, Argument_id_Ü);
         Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_id_Ü)'Unrestricted_Access);
         Arg_Any_id_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_RepositoryId,
               Arg_CC_id_Ü'Unchecked_Access);
         Argument_name_Ü : CORBA.Identifier;
         pragma Warnings (Off, Argument_name_Ü);
         pragma Suppress (Validity_Check, Argument_name_Ü);
         Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_name_Ü)'Unrestricted_Access);
         Arg_Any_name_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_Identifier,
               Arg_CC_name_Ü'Unchecked_Access);
         Argument_version_Ü : CORBA.Repository_Root.VersionSpec;
         pragma Warnings (Off, Argument_version_Ü);
         pragma Suppress (Validity_Check, Argument_version_Ü);
         Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_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);
         Argument_result_Ü : CORBA.Repository_Root.IDLType.Ref;
         pragma Warnings (Off, Argument_result_Ü);
         pragma Suppress (Validity_Check, Argument_result_Ü);
         Arg_CC_result_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Object.Helper.Wrap
              (CORBA.Object.Ref
                 (Argument_result_Ü)'Unrestricted_Access);
         Arg_Any_result_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.IDLType.Helper.TC_IDLType,
               Arg_CC_result_Ü'Unchecked_Access);
         Argument_mode_Ü : CORBA.Repository_Root.OperationMode;
         pragma Warnings (Off, Argument_mode_Ü);
         pragma Suppress (Validity_Check, Argument_mode_Ü);
         Arg_CC_mode_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.Helper.Internals.Wrap
              (Argument_mode_Ü'Unrestricted_Access);
         Arg_Any_mode_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.Helper.TC_OperationMode,
               Arg_CC_mode_Ü'Unchecked_Access);
         Argument_params_Ü : CORBA.Repository_Root.ParDescriptionSeq;
         pragma Warnings (Off, Argument_params_Ü);
         pragma Suppress (Validity_Check, Argument_params_Ü);
         Arg_CC_params_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.Helper.Internals.Wrap
              (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ParameterDescription.Sequence
                 (Argument_params_Ü)'Unrestricted_Access);
         Arg_Any_params_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.Helper.TC_ParDescriptionSeq,
               Arg_CC_params_Ü'Unchecked_Access);
         Argument_exceptions_Ü : CORBA.Repository_Root.ExceptionDefSeq;
         pragma Warnings (Off, Argument_exceptions_Ü);
         pragma Suppress (Validity_Check, Argument_exceptions_Ü);
         Arg_CC_exceptions_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.Helper.Internals.Wrap
              (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ExceptionDef_Forward.Sequence
                 (Argument_exceptions_Ü)'Unrestricted_Access);
         Arg_Any_exceptions_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.Helper.TC_ExceptionDefSeq,
               Arg_CC_exceptions_Ü'Unchecked_Access);
         Argument_contexts_Ü : CORBA.Repository_Root.ContextIdSeq;
         pragma Warnings (Off, Argument_contexts_Ü);
         pragma Suppress (Validity_Check, Argument_contexts_Ü);
         Arg_CC_contexts_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.Helper.Internals.Wrap
              (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_ContextIdentifier.Sequence
                 (Argument_contexts_Ü)'Unrestricted_Access);
         Arg_Any_contexts_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.Helper.TC_ContextIdSeq,
               Arg_CC_contexts_Ü'Unchecked_Access);
         Result_Ü : CORBA.Repository_Root.OperationDef.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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.OperationDef.Helper.TC_OperationDef,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_operation_Arg_Name_id_Ü,
            Arg_Any_id_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_operation_Arg_Name_name_Ü,
            Arg_Any_name_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_operation_Arg_Name_version_Ü,
            Arg_Any_version_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_operation_Arg_Name_result_Ü,
            Arg_Any_result_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_operation_Arg_Name_mode_Ü,
            Arg_Any_mode_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_operation_Arg_Name_params_Ü,
            Arg_Any_params_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_operation_Arg_Name_exceptions_Ü,
            Arg_Any_exceptions_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_operation_Arg_Name_contexts_Ü,
            Arg_Any_contexts_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.create_operation
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_id_Ü,
               Argument_name_Ü,
               Argument_version_Ü,
               Argument_result_Ü,
               Argument_mode_Ü,
               Argument_params_Ü,
               Argument_exceptions_Ü,
               Argument_contexts_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_create_operation;

      procedure Invoke_lookup;

      -------------------
      -- Invoke_lookup --
      -------------------

      procedure Invoke_lookup is
         Argument_search_name_Ü : CORBA.ScopedName;
         pragma Warnings (Off, Argument_search_name_Ü);
         pragma Suppress (Validity_Check, Argument_search_name_Ü);
         Arg_CC_search_name_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_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);
         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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.Contained.Helper.TC_Contained,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            lookup_Arg_Name_search_name_Ü,
            Arg_Any_search_name_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.lookup
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_search_name_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_lookup;

      procedure Invoke_contents;

      ---------------------
      -- Invoke_contents --
      ---------------------

      procedure Invoke_contents is
         Argument_limit_type_Ü : CORBA.Repository_Root.DefinitionKind;
         pragma Warnings (Off, Argument_limit_type_Ü);
         pragma Suppress (Validity_Check, Argument_limit_type_Ü);
         Arg_CC_limit_type_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.Helper.Internals.Wrap
              (Argument_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);
         Argument_exclude_inherited_Ü : CORBA.Boolean;
         pragma Warnings (Off, Argument_exclude_inherited_Ü);
         pragma Suppress (Validity_Check, Argument_exclude_inherited_Ü);
         Arg_CC_exclude_inherited_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (Argument_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);
         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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.Helper.TC_ContainedSeq,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            contents_Arg_Name_limit_type_Ü,
            Arg_Any_limit_type_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            contents_Arg_Name_exclude_inherited_Ü,
            Arg_Any_exclude_inherited_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.contents
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_limit_type_Ü,
               Argument_exclude_inherited_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_contents;

      procedure Invoke_lookup_name;

      ------------------------
      -- Invoke_lookup_name --
      ------------------------

      procedure Invoke_lookup_name is
         Argument_search_name_Ü : CORBA.Identifier;
         pragma Warnings (Off, Argument_search_name_Ü);
         pragma Suppress (Validity_Check, Argument_search_name_Ü);
         Arg_CC_search_name_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_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);
         Argument_levels_to_search_Ü : CORBA.Long;
         pragma Warnings (Off, Argument_levels_to_search_Ü);
         pragma Suppress (Validity_Check, Argument_levels_to_search_Ü);
         Arg_CC_levels_to_search_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (Argument_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);
         Argument_limit_type_Ü : CORBA.Repository_Root.DefinitionKind;
         pragma Warnings (Off, Argument_limit_type_Ü);
         pragma Suppress (Validity_Check, Argument_limit_type_Ü);
         Arg_CC_limit_type_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.Helper.Internals.Wrap
              (Argument_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);
         Argument_exclude_inherited_Ü : CORBA.Boolean;
         pragma Warnings (Off, Argument_exclude_inherited_Ü);
         pragma Suppress (Validity_Check, Argument_exclude_inherited_Ü);
         Arg_CC_exclude_inherited_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (Argument_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);
         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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.Helper.TC_ContainedSeq,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            lookup_name_Arg_Name_search_name_Ü,
            Arg_Any_search_name_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            lookup_name_Arg_Name_levels_to_search_Ü,
            Arg_Any_levels_to_search_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            lookup_name_Arg_Name_limit_type_Ü,
            Arg_Any_limit_type_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            lookup_name_Arg_Name_exclude_inherited_Ü,
            Arg_Any_exclude_inherited_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.lookup_name
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_search_name_Ü,
               Argument_levels_to_search_Ü,
               Argument_limit_type_Ü,
               Argument_exclude_inherited_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_lookup_name;

      procedure Invoke_describe_contents;

      ------------------------------
      -- Invoke_describe_contents --
      ------------------------------

      procedure Invoke_describe_contents is
         Argument_limit_type_Ü : CORBA.Repository_Root.DefinitionKind;
         pragma Warnings (Off, Argument_limit_type_Ü);
         pragma Suppress (Validity_Check, Argument_limit_type_Ü);
         Arg_CC_limit_type_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.Helper.Internals.Wrap
              (Argument_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);
         Argument_exclude_inherited_Ü : CORBA.Boolean;
         pragma Warnings (Off, Argument_exclude_inherited_Ü);
         pragma Suppress (Validity_Check, Argument_exclude_inherited_Ü);
         Arg_CC_exclude_inherited_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (Argument_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);
         Argument_max_returned_objs_Ü : CORBA.Long;
         pragma Warnings (Off, Argument_max_returned_objs_Ü);
         pragma Suppress (Validity_Check, Argument_max_returned_objs_Ü);
         Arg_CC_max_returned_objs_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (Argument_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);
         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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.Container.Helper.TC_DescriptionSeq,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            describe_contents_Arg_Name_limit_type_Ü,
            Arg_Any_limit_type_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            describe_contents_Arg_Name_exclude_inherited_Ü,
            Arg_Any_exclude_inherited_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            describe_contents_Arg_Name_max_returned_objs_Ü,
            Arg_Any_max_returned_objs_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.describe_contents
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_limit_type_Ü,
               Argument_exclude_inherited_Ü,
               Argument_max_returned_objs_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_describe_contents;

      procedure Invoke_create_module;

      --------------------------
      -- Invoke_create_module --
      --------------------------

      procedure Invoke_create_module is
         Argument_id_Ü : CORBA.RepositoryId;
         pragma Warnings (Off, Argument_id_Ü);
         pragma Suppress (Validity_Check, Argument_id_Ü);
         Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_id_Ü)'Unrestricted_Access);
         Arg_Any_id_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_RepositoryId,
               Arg_CC_id_Ü'Unchecked_Access);
         Argument_name_Ü : CORBA.Identifier;
         pragma Warnings (Off, Argument_name_Ü);
         pragma Suppress (Validity_Check, Argument_name_Ü);
         Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_name_Ü)'Unrestricted_Access);
         Arg_Any_name_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_Identifier,
               Arg_CC_name_Ü'Unchecked_Access);
         Argument_version_Ü : CORBA.Repository_Root.VersionSpec;
         pragma Warnings (Off, Argument_version_Ü);
         pragma Suppress (Validity_Check, Argument_version_Ü);
         Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_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);
         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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.ModuleDef.Helper.TC_ModuleDef,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_module_Arg_Name_id_Ü,
            Arg_Any_id_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_module_Arg_Name_name_Ü,
            Arg_Any_name_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_module_Arg_Name_version_Ü,
            Arg_Any_version_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.create_module
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_id_Ü,
               Argument_name_Ü,
               Argument_version_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_create_module;

      procedure Invoke_create_constant;

      ----------------------------
      -- Invoke_create_constant --
      ----------------------------

      procedure Invoke_create_constant is
         Argument_id_Ü : CORBA.RepositoryId;
         pragma Warnings (Off, Argument_id_Ü);
         pragma Suppress (Validity_Check, Argument_id_Ü);
         Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_id_Ü)'Unrestricted_Access);
         Arg_Any_id_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_RepositoryId,
               Arg_CC_id_Ü'Unchecked_Access);
         Argument_name_Ü : CORBA.Identifier;
         pragma Warnings (Off, Argument_name_Ü);
         pragma Suppress (Validity_Check, Argument_name_Ü);
         Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_name_Ü)'Unrestricted_Access);
         Arg_Any_name_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_Identifier,
               Arg_CC_name_Ü'Unchecked_Access);
         Argument_version_Ü : CORBA.Repository_Root.VersionSpec;
         pragma Warnings (Off, Argument_version_Ü);
         pragma Suppress (Validity_Check, Argument_version_Ü);
         Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_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);
         Argument_IDL_type_Ü : CORBA.Repository_Root.IDLType_Forward.Ref;
         pragma Warnings (Off, Argument_IDL_type_Ü);
         pragma Suppress (Validity_Check, Argument_IDL_type_Ü);
         Arg_CC_IDL_type_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Object.Helper.Wrap
              (CORBA.Object.Ref
                 (Argument_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);
         Argument_value_Ü : CORBA.Any;
         pragma Warnings (Off, Argument_value_Ü);
         pragma Suppress (Validity_Check, Argument_value_Ü);
         Arg_CC_value_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (Argument_value_Ü'Unrestricted_Access);
         Arg_Any_value_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.TC_Any,
               Arg_CC_value_Ü'Unchecked_Access);
         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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.ConstantDef.Helper.TC_ConstantDef,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_constant_Arg_Name_id_Ü,
            Arg_Any_id_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_constant_Arg_Name_name_Ü,
            Arg_Any_name_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_constant_Arg_Name_version_Ü,
            Arg_Any_version_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_constant_Arg_Name_IDL_type_Ü,
            Arg_Any_IDL_type_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_constant_Arg_Name_value_Ü,
            Arg_Any_value_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.create_constant
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_id_Ü,
               Argument_name_Ü,
               Argument_version_Ü,
               Argument_IDL_type_Ü,
               Argument_value_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_create_constant;

      procedure Invoke_create_struct;

      --------------------------
      -- Invoke_create_struct --
      --------------------------

      procedure Invoke_create_struct is
         Argument_id_Ü : CORBA.RepositoryId;
         pragma Warnings (Off, Argument_id_Ü);
         pragma Suppress (Validity_Check, Argument_id_Ü);
         Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_id_Ü)'Unrestricted_Access);
         Arg_Any_id_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_RepositoryId,
               Arg_CC_id_Ü'Unchecked_Access);
         Argument_name_Ü : CORBA.Identifier;
         pragma Warnings (Off, Argument_name_Ü);
         pragma Suppress (Validity_Check, Argument_name_Ü);
         Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_name_Ü)'Unrestricted_Access);
         Arg_Any_name_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_Identifier,
               Arg_CC_name_Ü'Unchecked_Access);
         Argument_version_Ü : CORBA.Repository_Root.VersionSpec;
         pragma Warnings (Off, Argument_version_Ü);
         pragma Suppress (Validity_Check, Argument_version_Ü);
         Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_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);
         Argument_members_Ü : CORBA.Repository_Root.StructMemberSeq;
         pragma Warnings (Off, Argument_members_Ü);
         pragma Suppress (Validity_Check, Argument_members_Ü);
         Arg_CC_members_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.Helper.Internals.Wrap
              (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_StructMember.Sequence
                 (Argument_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);
         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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.StructDef.Helper.TC_StructDef,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_struct_Arg_Name_id_Ü,
            Arg_Any_id_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_struct_Arg_Name_name_Ü,
            Arg_Any_name_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_struct_Arg_Name_version_Ü,
            Arg_Any_version_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_struct_Arg_Name_members_Ü,
            Arg_Any_members_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.create_struct
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_id_Ü,
               Argument_name_Ü,
               Argument_version_Ü,
               Argument_members_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_create_struct;

      procedure Invoke_create_union;

      -------------------------
      -- Invoke_create_union --
      -------------------------

      procedure Invoke_create_union is
         Argument_id_Ü : CORBA.RepositoryId;
         pragma Warnings (Off, Argument_id_Ü);
         pragma Suppress (Validity_Check, Argument_id_Ü);
         Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_id_Ü)'Unrestricted_Access);
         Arg_Any_id_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_RepositoryId,
               Arg_CC_id_Ü'Unchecked_Access);
         Argument_name_Ü : CORBA.Identifier;
         pragma Warnings (Off, Argument_name_Ü);
         pragma Suppress (Validity_Check, Argument_name_Ü);
         Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_name_Ü)'Unrestricted_Access);
         Arg_Any_name_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_Identifier,
               Arg_CC_name_Ü'Unchecked_Access);
         Argument_version_Ü : CORBA.Repository_Root.VersionSpec;
         pragma Warnings (Off, Argument_version_Ü);
         pragma Suppress (Validity_Check, Argument_version_Ü);
         Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_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);
         Argument_discriminator_type_Ü : CORBA.Repository_Root.IDLType_Forward.Ref;
         pragma Warnings (Off, Argument_discriminator_type_Ü);
         pragma Suppress (Validity_Check, Argument_discriminator_type_Ü);
         Arg_CC_discriminator_type_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Object.Helper.Wrap
              (CORBA.Object.Ref
                 (Argument_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);
         Argument_members_Ü : CORBA.Repository_Root.UnionMemberSeq;
         pragma Warnings (Off, Argument_members_Ü);
         pragma Suppress (Validity_Check, Argument_members_Ü);
         Arg_CC_members_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.Helper.Internals.Wrap
              (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_UnionMember.Sequence
                 (Argument_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);
         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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.UnionDef.Helper.TC_UnionDef,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_union_Arg_Name_id_Ü,
            Arg_Any_id_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_union_Arg_Name_name_Ü,
            Arg_Any_name_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_union_Arg_Name_version_Ü,
            Arg_Any_version_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_union_Arg_Name_discriminator_type_Ü,
            Arg_Any_discriminator_type_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_union_Arg_Name_members_Ü,
            Arg_Any_members_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.create_union
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_id_Ü,
               Argument_name_Ü,
               Argument_version_Ü,
               Argument_discriminator_type_Ü,
               Argument_members_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_create_union;

      procedure Invoke_create_enum;

      ------------------------
      -- Invoke_create_enum --
      ------------------------

      procedure Invoke_create_enum is
         Argument_id_Ü : CORBA.RepositoryId;
         pragma Warnings (Off, Argument_id_Ü);
         pragma Suppress (Validity_Check, Argument_id_Ü);
         Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_id_Ü)'Unrestricted_Access);
         Arg_Any_id_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_RepositoryId,
               Arg_CC_id_Ü'Unchecked_Access);
         Argument_name_Ü : CORBA.Identifier;
         pragma Warnings (Off, Argument_name_Ü);
         pragma Suppress (Validity_Check, Argument_name_Ü);
         Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_name_Ü)'Unrestricted_Access);
         Arg_Any_name_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_Identifier,
               Arg_CC_name_Ü'Unchecked_Access);
         Argument_version_Ü : CORBA.Repository_Root.VersionSpec;
         pragma Warnings (Off, Argument_version_Ü);
         pragma Suppress (Validity_Check, Argument_version_Ü);
         Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_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);
         Argument_members_Ü : CORBA.Repository_Root.EnumMemberSeq;
         pragma Warnings (Off, Argument_members_Ü);
         pragma Suppress (Validity_Check, Argument_members_Ü);
         Arg_CC_members_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.Helper.Internals.Wrap
              (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Identifier.Sequence
                 (Argument_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);
         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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.EnumDef.Helper.TC_EnumDef,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_enum_Arg_Name_id_Ü,
            Arg_Any_id_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_enum_Arg_Name_name_Ü,
            Arg_Any_name_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_enum_Arg_Name_version_Ü,
            Arg_Any_version_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_enum_Arg_Name_members_Ü,
            Arg_Any_members_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.create_enum
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_id_Ü,
               Argument_name_Ü,
               Argument_version_Ü,
               Argument_members_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_create_enum;

      procedure Invoke_create_alias;

      -------------------------
      -- Invoke_create_alias --
      -------------------------

      procedure Invoke_create_alias is
         Argument_id_Ü : CORBA.RepositoryId;
         pragma Warnings (Off, Argument_id_Ü);
         pragma Suppress (Validity_Check, Argument_id_Ü);
         Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_id_Ü)'Unrestricted_Access);
         Arg_Any_id_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_RepositoryId,
               Arg_CC_id_Ü'Unchecked_Access);
         Argument_name_Ü : CORBA.Identifier;
         pragma Warnings (Off, Argument_name_Ü);
         pragma Suppress (Validity_Check, Argument_name_Ü);
         Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_name_Ü)'Unrestricted_Access);
         Arg_Any_name_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_Identifier,
               Arg_CC_name_Ü'Unchecked_Access);
         Argument_version_Ü : CORBA.Repository_Root.VersionSpec;
         pragma Warnings (Off, Argument_version_Ü);
         pragma Suppress (Validity_Check, Argument_version_Ü);
         Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_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);
         Argument_original_type_Ü : CORBA.Repository_Root.IDLType_Forward.Ref;
         pragma Warnings (Off, Argument_original_type_Ü);
         pragma Suppress (Validity_Check, Argument_original_type_Ü);
         Arg_CC_original_type_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Object.Helper.Wrap
              (CORBA.Object.Ref
                 (Argument_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);
         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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.AliasDef.Helper.TC_AliasDef,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_alias_Arg_Name_id_Ü,
            Arg_Any_id_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_alias_Arg_Name_name_Ü,
            Arg_Any_name_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_alias_Arg_Name_version_Ü,
            Arg_Any_version_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_alias_Arg_Name_original_type_Ü,
            Arg_Any_original_type_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.create_alias
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_id_Ü,
               Argument_name_Ü,
               Argument_version_Ü,
               Argument_original_type_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_create_alias;

      procedure Invoke_create_interface;

      -----------------------------
      -- Invoke_create_interface --
      -----------------------------

      procedure Invoke_create_interface is
         Argument_id_Ü : CORBA.RepositoryId;
         pragma Warnings (Off, Argument_id_Ü);
         pragma Suppress (Validity_Check, Argument_id_Ü);
         Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_id_Ü)'Unrestricted_Access);
         Arg_Any_id_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_RepositoryId,
               Arg_CC_id_Ü'Unchecked_Access);
         Argument_name_Ü : CORBA.Identifier;
         pragma Warnings (Off, Argument_name_Ü);
         pragma Suppress (Validity_Check, Argument_name_Ü);
         Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_name_Ü)'Unrestricted_Access);
         Arg_Any_name_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_Identifier,
               Arg_CC_name_Ü'Unchecked_Access);
         Argument_version_Ü : CORBA.Repository_Root.VersionSpec;
         pragma Warnings (Off, Argument_version_Ü);
         pragma Suppress (Validity_Check, Argument_version_Ü);
         Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_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);
         Argument_base_interfaces_Ü : CORBA.Repository_Root.InterfaceDefSeq;
         pragma Warnings (Off, Argument_base_interfaces_Ü);
         pragma Suppress (Validity_Check, Argument_base_interfaces_Ü);
         Arg_CC_base_interfaces_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.Helper.Internals.Wrap
              (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_InterfaceDef_Forward.Sequence
                 (Argument_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);
         Argument_is_abstract_Ü : CORBA.Boolean;
         pragma Warnings (Off, Argument_is_abstract_Ü);
         pragma Suppress (Validity_Check, Argument_is_abstract_Ü);
         Arg_CC_is_abstract_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (Argument_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);
         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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.InterfaceDef.Helper.TC_InterfaceDef,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_interface_Arg_Name_id_Ü,
            Arg_Any_id_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_interface_Arg_Name_name_Ü,
            Arg_Any_name_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_interface_Arg_Name_version_Ü,
            Arg_Any_version_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_interface_Arg_Name_base_interfaces_Ü,
            Arg_Any_base_interfaces_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_interface_Arg_Name_is_abstract_Ü,
            Arg_Any_is_abstract_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.create_interface
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_id_Ü,
               Argument_name_Ü,
               Argument_version_Ü,
               Argument_base_interfaces_Ü,
               Argument_is_abstract_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_create_interface;

      procedure Invoke_create_value;

      -------------------------
      -- Invoke_create_value --
      -------------------------

      procedure Invoke_create_value is
         Argument_id_Ü : CORBA.RepositoryId;
         pragma Warnings (Off, Argument_id_Ü);
         pragma Suppress (Validity_Check, Argument_id_Ü);
         Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_id_Ü)'Unrestricted_Access);
         Arg_Any_id_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_RepositoryId,
               Arg_CC_id_Ü'Unchecked_Access);
         Argument_name_Ü : CORBA.Identifier;
         pragma Warnings (Off, Argument_name_Ü);
         pragma Suppress (Validity_Check, Argument_name_Ü);
         Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_name_Ü)'Unrestricted_Access);
         Arg_Any_name_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_Identifier,
               Arg_CC_name_Ü'Unchecked_Access);
         Argument_version_Ü : CORBA.Repository_Root.VersionSpec;
         pragma Warnings (Off, Argument_version_Ü);
         pragma Suppress (Validity_Check, Argument_version_Ü);
         Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_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);
         Argument_is_custom_Ü : CORBA.Boolean;
         pragma Warnings (Off, Argument_is_custom_Ü);
         pragma Suppress (Validity_Check, Argument_is_custom_Ü);
         Arg_CC_is_custom_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (Argument_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);
         Argument_is_abstract_Ü : CORBA.Boolean;
         pragma Warnings (Off, Argument_is_abstract_Ü);
         pragma Suppress (Validity_Check, Argument_is_abstract_Ü);
         Arg_CC_is_abstract_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (Argument_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);
         Argument_base_value_Ü : CORBA.Repository_Root.ValueDef_Forward.Ref;
         pragma Warnings (Off, Argument_base_value_Ü);
         pragma Suppress (Validity_Check, Argument_base_value_Ü);
         Arg_CC_base_value_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Object.Helper.Wrap
              (CORBA.Object.Ref
                 (Argument_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);
         Argument_is_truncatable_Ü : CORBA.Boolean;
         pragma Warnings (Off, Argument_is_truncatable_Ü);
         pragma Suppress (Validity_Check, Argument_is_truncatable_Ü);
         Arg_CC_is_truncatable_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (Argument_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);
         Argument_abstract_base_values_Ü : CORBA.Repository_Root.ValueDefSeq;
         pragma Warnings (Off, Argument_abstract_base_values_Ü);
         pragma Suppress (Validity_Check, Argument_abstract_base_values_Ü);
         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
                 (Argument_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);
         Argument_supported_interfaces_Ü : CORBA.Repository_Root.InterfaceDefSeq;
         pragma Warnings (Off, Argument_supported_interfaces_Ü);
         pragma Suppress (Validity_Check, Argument_supported_interfaces_Ü);
         Arg_CC_supported_interfaces_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.Helper.Internals.Wrap
              (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_InterfaceDef_Forward.Sequence
                 (Argument_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);
         Argument_initializers_Ü : CORBA.Repository_Root.InitializerSeq;
         pragma Warnings (Off, Argument_initializers_Ü);
         pragma Suppress (Validity_Check, Argument_initializers_Ü);
         Arg_CC_initializers_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.Helper.Internals.Wrap
              (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_Initializer.Sequence
                 (Argument_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);
         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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.ValueDef.Helper.TC_ValueDef,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_value_Arg_Name_id_Ü,
            Arg_Any_id_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_value_Arg_Name_name_Ü,
            Arg_Any_name_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_value_Arg_Name_version_Ü,
            Arg_Any_version_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_value_Arg_Name_is_custom_Ü,
            Arg_Any_is_custom_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_value_Arg_Name_is_abstract_Ü,
            Arg_Any_is_abstract_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_value_Arg_Name_base_value_Ü,
            Arg_Any_base_value_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_value_Arg_Name_is_truncatable_Ü,
            Arg_Any_is_truncatable_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_value_Arg_Name_abstract_base_values_Ü,
            Arg_Any_abstract_base_values_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_value_Arg_Name_supported_interfaces_Ü,
            Arg_Any_supported_interfaces_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_value_Arg_Name_initializers_Ü,
            Arg_Any_initializers_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.create_value
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_id_Ü,
               Argument_name_Ü,
               Argument_version_Ü,
               Argument_is_custom_Ü,
               Argument_is_abstract_Ü,
               Argument_base_value_Ü,
               Argument_is_truncatable_Ü,
               Argument_abstract_base_values_Ü,
               Argument_supported_interfaces_Ü,
               Argument_initializers_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_create_value;

      procedure Invoke_create_value_box;

      -----------------------------
      -- Invoke_create_value_box --
      -----------------------------

      procedure Invoke_create_value_box is
         Argument_id_Ü : CORBA.RepositoryId;
         pragma Warnings (Off, Argument_id_Ü);
         pragma Suppress (Validity_Check, Argument_id_Ü);
         Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_id_Ü)'Unrestricted_Access);
         Arg_Any_id_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_RepositoryId,
               Arg_CC_id_Ü'Unchecked_Access);
         Argument_name_Ü : CORBA.Identifier;
         pragma Warnings (Off, Argument_name_Ü);
         pragma Suppress (Validity_Check, Argument_name_Ü);
         Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_name_Ü)'Unrestricted_Access);
         Arg_Any_name_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_Identifier,
               Arg_CC_name_Ü'Unchecked_Access);
         Argument_version_Ü : CORBA.Repository_Root.VersionSpec;
         pragma Warnings (Off, Argument_version_Ü);
         pragma Suppress (Validity_Check, Argument_version_Ü);
         Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_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);
         Argument_original_type_def_Ü : CORBA.Repository_Root.IDLType_Forward.Ref;
         pragma Warnings (Off, Argument_original_type_def_Ü);
         pragma Suppress (Validity_Check, Argument_original_type_def_Ü);
         Arg_CC_original_type_def_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Object.Helper.Wrap
              (CORBA.Object.Ref
                 (Argument_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);
         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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.ValueBoxDef.Helper.TC_ValueBoxDef,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_value_box_Arg_Name_id_Ü,
            Arg_Any_id_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_value_box_Arg_Name_name_Ü,
            Arg_Any_name_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_value_box_Arg_Name_version_Ü,
            Arg_Any_version_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_value_box_Arg_Name_original_type_def_Ü,
            Arg_Any_original_type_def_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.create_value_box
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_id_Ü,
               Argument_name_Ü,
               Argument_version_Ü,
               Argument_original_type_def_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_create_value_box;

      procedure Invoke_create_exception;

      -----------------------------
      -- Invoke_create_exception --
      -----------------------------

      procedure Invoke_create_exception is
         Argument_id_Ü : CORBA.RepositoryId;
         pragma Warnings (Off, Argument_id_Ü);
         pragma Suppress (Validity_Check, Argument_id_Ü);
         Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_id_Ü)'Unrestricted_Access);
         Arg_Any_id_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_RepositoryId,
               Arg_CC_id_Ü'Unchecked_Access);
         Argument_name_Ü : CORBA.Identifier;
         pragma Warnings (Off, Argument_name_Ü);
         pragma Suppress (Validity_Check, Argument_name_Ü);
         Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_name_Ü)'Unrestricted_Access);
         Arg_Any_name_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_Identifier,
               Arg_CC_name_Ü'Unchecked_Access);
         Argument_version_Ü : CORBA.Repository_Root.VersionSpec;
         pragma Warnings (Off, Argument_version_Ü);
         pragma Suppress (Validity_Check, Argument_version_Ü);
         Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_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);
         Argument_members_Ü : CORBA.Repository_Root.StructMemberSeq;
         pragma Warnings (Off, Argument_members_Ü);
         pragma Suppress (Validity_Check, Argument_members_Ü);
         Arg_CC_members_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.Helper.Internals.Wrap
              (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_StructMember.Sequence
                 (Argument_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);
         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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.ExceptionDef.Helper.TC_ExceptionDef,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_exception_Arg_Name_id_Ü,
            Arg_Any_id_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_exception_Arg_Name_name_Ü,
            Arg_Any_name_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_exception_Arg_Name_version_Ü,
            Arg_Any_version_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_exception_Arg_Name_members_Ü,
            Arg_Any_members_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.create_exception
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_id_Ü,
               Argument_name_Ü,
               Argument_version_Ü,
               Argument_members_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_create_exception;

      procedure Invoke_create_native;

      --------------------------
      -- Invoke_create_native --
      --------------------------

      procedure Invoke_create_native is
         Argument_id_Ü : CORBA.RepositoryId;
         pragma Warnings (Off, Argument_id_Ü);
         pragma Suppress (Validity_Check, Argument_id_Ü);
         Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_id_Ü)'Unrestricted_Access);
         Arg_Any_id_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_RepositoryId,
               Arg_CC_id_Ü'Unchecked_Access);
         Argument_name_Ü : CORBA.Identifier;
         pragma Warnings (Off, Argument_name_Ü);
         pragma Suppress (Validity_Check, Argument_name_Ü);
         Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_name_Ü)'Unrestricted_Access);
         Arg_Any_name_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_Identifier,
               Arg_CC_name_Ü'Unchecked_Access);
         Argument_version_Ü : CORBA.Repository_Root.VersionSpec;
         pragma Warnings (Off, Argument_version_Ü);
         pragma Suppress (Validity_Check, Argument_version_Ü);
         Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_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);
         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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.NativeDef.Helper.TC_NativeDef,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_native_Arg_Name_id_Ü,
            Arg_Any_id_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_native_Arg_Name_name_Ü,
            Arg_Any_name_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_native_Arg_Name_version_Ü,
            Arg_Any_version_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.create_native
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_id_Ü,
               Argument_name_Ü,
               Argument_version_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_create_native;

      procedure Invoke_create_abstract_interface;

      --------------------------------------
      -- Invoke_create_abstract_interface --
      --------------------------------------

      procedure Invoke_create_abstract_interface is
         Argument_id_Ü : CORBA.RepositoryId;
         pragma Warnings (Off, Argument_id_Ü);
         pragma Suppress (Validity_Check, Argument_id_Ü);
         Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_id_Ü)'Unrestricted_Access);
         Arg_Any_id_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_RepositoryId,
               Arg_CC_id_Ü'Unchecked_Access);
         Argument_name_Ü : CORBA.Identifier;
         pragma Warnings (Off, Argument_name_Ü);
         pragma Suppress (Validity_Check, Argument_name_Ü);
         Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_name_Ü)'Unrestricted_Access);
         Arg_Any_name_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_Identifier,
               Arg_CC_name_Ü'Unchecked_Access);
         Argument_version_Ü : CORBA.Repository_Root.VersionSpec;
         pragma Warnings (Off, Argument_version_Ü);
         pragma Suppress (Validity_Check, Argument_version_Ü);
         Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_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);
         Argument_base_interfaces_Ü : CORBA.Repository_Root.AbstractInterfaceDefSeq;
         pragma Warnings (Off, Argument_base_interfaces_Ü);
         pragma Suppress (Validity_Check, Argument_base_interfaces_Ü);
         Arg_CC_base_interfaces_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.Helper.Internals.Wrap
              (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_AbstractInterfaceDef_Forward.Sequence
                 (Argument_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);
         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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.AbstractInterfaceDef.Helper.TC_AbstractInterfaceDef,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_abstract_interface_Arg_Name_id_Ü,
            Arg_Any_id_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_abstract_interface_Arg_Name_name_Ü,
            Arg_Any_name_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_abstract_interface_Arg_Name_version_Ü,
            Arg_Any_version_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_abstract_interface_Arg_Name_base_interfaces_Ü,
            Arg_Any_base_interfaces_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.create_abstract_interface
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_id_Ü,
               Argument_name_Ü,
               Argument_version_Ü,
               Argument_base_interfaces_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_create_abstract_interface;

      procedure Invoke_create_local_interface;

      -----------------------------------
      -- Invoke_create_local_interface --
      -----------------------------------

      procedure Invoke_create_local_interface is
         Argument_id_Ü : CORBA.RepositoryId;
         pragma Warnings (Off, Argument_id_Ü);
         pragma Suppress (Validity_Check, Argument_id_Ü);
         Arg_CC_id_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_id_Ü)'Unrestricted_Access);
         Arg_Any_id_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_RepositoryId,
               Arg_CC_id_Ü'Unchecked_Access);
         Argument_name_Ü : CORBA.Identifier;
         pragma Warnings (Off, Argument_name_Ü);
         pragma Suppress (Validity_Check, Argument_name_Ü);
         Arg_CC_name_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_name_Ü)'Unrestricted_Access);
         Arg_Any_name_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_Identifier,
               Arg_CC_name_Ü'Unchecked_Access);
         Argument_version_Ü : CORBA.Repository_Root.VersionSpec;
         pragma Warnings (Off, Argument_version_Ü);
         pragma Suppress (Validity_Check, Argument_version_Ü);
         Arg_CC_version_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_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);
         Argument_base_interfaces_Ü : CORBA.Repository_Root.InterfaceDefSeq;
         pragma Warnings (Off, Argument_base_interfaces_Ü);
         pragma Suppress (Validity_Check, Argument_base_interfaces_Ü);
         Arg_CC_base_interfaces_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.Helper.Internals.Wrap
              (CORBA.Repository_Root.IDL_SEQUENCE_CORBA_InterfaceDef_Forward.Sequence
                 (Argument_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);
         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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.LocalInterfaceDef.Helper.TC_LocalInterfaceDef,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_local_interface_Arg_Name_id_Ü,
            Arg_Any_id_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_local_interface_Arg_Name_name_Ü,
            Arg_Any_name_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_local_interface_Arg_Name_version_Ü,
            Arg_Any_version_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            create_local_interface_Arg_Name_base_interfaces_Ü,
            Arg_Any_base_interfaces_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.create_local_interface
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access,
               Argument_id_Ü,
               Argument_name_Ü,
               Argument_version_Ü,
               Argument_base_interfaces_Ü);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_create_local_interface;

      procedure Invoke_Uget_def_kind;

      --------------------------
      -- Invoke_Uget_def_kind --
      --------------------------

      procedure Invoke_Uget_def_kind is
         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);
         Arg_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.Helper.TC_DefinitionKind,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.get_def_kind
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uget_def_kind;

      procedure Invoke_destroy;

      --------------------
      -- Invoke_destroy --
      --------------------

      procedure Invoke_destroy is
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         CORBA.Repository_Root.AbstractInterfaceDef.Impl.destroy
           (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
              (Self.all)'Access);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_destroy;

      procedure Invoke_Uget_id;

      --------------------
      -- Invoke_Uget_id --
      --------------------

      procedure Invoke_Uget_id is
         Result_Ü : CORBA.RepositoryId;
         pragma Warnings (Off, Result_Ü);
         pragma Suppress (Validity_Check, Result_Ü);
         Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Result_Ü)'Unrestricted_Access);
         Arg_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_RepositoryId,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.get_id
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uget_id;

      procedure Invoke_Uset_id;

      --------------------
      -- Invoke_Uset_id --
      --------------------

      procedure Invoke_Uset_id is
         Argument_To_Ü : CORBA.RepositoryId;
         pragma Warnings (Off, Argument_To_Ü);
         pragma Suppress (Validity_Check, Argument_To_Ü);
         Arg_CC_To_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_To_Ü)'Unrestricted_Access);
         Arg_Any_To_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_RepositoryId,
               Arg_CC_To_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            set_id_Arg_Name_To_Ü,
            Arg_Any_To_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         CORBA.Repository_Root.AbstractInterfaceDef.Impl.set_id
           (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
              (Self.all)'Access,
            Argument_To_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uset_id;

      procedure Invoke_Uget_name;

      ----------------------
      -- Invoke_Uget_name --
      ----------------------

      procedure Invoke_Uget_name is
         Result_Ü : CORBA.Identifier;
         pragma Warnings (Off, Result_Ü);
         pragma Suppress (Validity_Check, Result_Ü);
         Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Result_Ü)'Unrestricted_Access);
         Arg_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_Identifier,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.get_name
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uget_name;

      procedure Invoke_Uset_name;

      ----------------------
      -- Invoke_Uset_name --
      ----------------------

      procedure Invoke_Uset_name is
         Argument_To_Ü : CORBA.Identifier;
         pragma Warnings (Off, Argument_To_Ü);
         pragma Suppress (Validity_Check, Argument_To_Ü);
         Arg_CC_To_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_To_Ü)'Unrestricted_Access);
         Arg_Any_To_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_Identifier,
               Arg_CC_To_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            set_name_Arg_Name_To_Ü,
            Arg_Any_To_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         CORBA.Repository_Root.AbstractInterfaceDef.Impl.set_name
           (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
              (Self.all)'Access,
            Argument_To_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uset_name;

      procedure Invoke_Uget_version;

      -------------------------
      -- Invoke_Uget_version --
      -------------------------

      procedure Invoke_Uget_version is
         Result_Ü : CORBA.Repository_Root.VersionSpec;
         pragma Warnings (Off, Result_Ü);
         pragma Suppress (Validity_Check, Result_Ü);
         Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Result_Ü)'Unrestricted_Access);
         Arg_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.Helper.TC_VersionSpec,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.get_version
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uget_version;

      procedure Invoke_Uset_version;

      -------------------------
      -- Invoke_Uset_version --
      -------------------------

      procedure Invoke_Uset_version is
         Argument_To_Ü : CORBA.Repository_Root.VersionSpec;
         pragma Warnings (Off, Argument_To_Ü);
         pragma Suppress (Validity_Check, Argument_To_Ü);
         Arg_CC_To_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_To_Ü)'Unrestricted_Access);
         Arg_Any_To_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.Helper.TC_VersionSpec,
               Arg_CC_To_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            set_version_Arg_Name_To_Ü,
            Arg_Any_To_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         CORBA.Repository_Root.AbstractInterfaceDef.Impl.set_version
           (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
              (Self.all)'Access,
            Argument_To_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uset_version;

      procedure Invoke_Uget_defined_in;

      ----------------------------
      -- Invoke_Uget_defined_in --
      ----------------------------

      procedure Invoke_Uget_defined_in is
         Result_Ü : CORBA.Repository_Root.Container_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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.Container.Helper.TC_Container,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.get_defined_in
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uget_defined_in;

      procedure Invoke_Uget_absolute_name;

      -------------------------------
      -- Invoke_Uget_absolute_name --
      -------------------------------

      procedure Invoke_Uget_absolute_name is
         Result_Ü : CORBA.ScopedName;
         pragma Warnings (Off, Result_Ü);
         pragma Suppress (Validity_Check, Result_Ü);
         Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Result_Ü)'Unrestricted_Access);
         Arg_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_ScopedName,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.get_absolute_name
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uget_absolute_name;

      procedure Invoke_Uget_containing_repository;

      ---------------------------------------
      -- Invoke_Uget_containing_repository --
      ---------------------------------------

      procedure Invoke_Uget_containing_repository is
         Result_Ü : CORBA.Repository_Root.Repository_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_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.Repository.Helper.TC_Repository,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.get_containing_repository
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uget_containing_repository;

      procedure Invoke_describe;

      ---------------------
      -- Invoke_describe --
      ---------------------

      procedure Invoke_describe is
         Result_Ü : CORBA.Repository_Root.Contained.Description;
         pragma Warnings (Off, Result_Ü);
         pragma Suppress (Validity_Check, Result_Ü);
         Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Repository_Root.Contained.Helper.Internals.Wrap
              (Result_Ü'Unrestricted_Access);
         Arg_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.Contained.Helper.TC_Description,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.describe
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_describe;

      procedure Invoke_move;

      -----------------
      -- Invoke_move --
      -----------------

      procedure Invoke_move is
         Argument_new_container_Ü : CORBA.Repository_Root.Container_Forward.Ref;
         pragma Warnings (Off, Argument_new_container_Ü);
         pragma Suppress (Validity_Check, Argument_new_container_Ü);
         Arg_CC_new_container_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Object.Helper.Wrap
              (CORBA.Object.Ref
                 (Argument_new_container_Ü)'Unrestricted_Access);
         Arg_Any_new_container_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.Container.Helper.TC_Container,
               Arg_CC_new_container_Ü'Unchecked_Access);
         Argument_new_name_Ü : CORBA.Identifier;
         pragma Warnings (Off, Argument_new_name_Ü);
         pragma Suppress (Validity_Check, Argument_new_name_Ü);
         Arg_CC_new_name_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_new_name_Ü)'Unrestricted_Access);
         Arg_Any_new_name_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Helper.TC_Identifier,
               Arg_CC_new_name_Ü'Unchecked_Access);
         Argument_new_version_Ü : CORBA.Repository_Root.VersionSpec;
         pragma Warnings (Off, Argument_new_version_Ü);
         pragma Suppress (Validity_Check, Argument_new_version_Ü);
         Arg_CC_new_version_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (CORBA.String
                 (Argument_new_version_Ü)'Unrestricted_Access);
         Arg_Any_new_version_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.Repository_Root.Helper.TC_VersionSpec,
               Arg_CC_new_version_Ü'Unchecked_Access);
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            move_Arg_Name_new_container_Ü,
            Arg_Any_new_container_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            move_Arg_Name_new_name_Ü,
            Arg_Any_new_name_Ü,
            CORBA.ARG_IN);
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            move_Arg_Name_new_version_Ü,
            Arg_Any_new_version_Ü,
            CORBA.ARG_IN);
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         CORBA.Repository_Root.AbstractInterfaceDef.Impl.move
           (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
              (Self.all)'Access,
            Argument_new_container_Ü,
            Argument_new_name_Ü,
            Argument_new_version_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_move;

      procedure Invoke_Uget_type;

      ----------------------
      -- Invoke_Uget_type --
      ----------------------

      procedure Invoke_Uget_type is
         Result_Ü : CORBA.TypeCode.Object;
         pragma Warnings (Off, Result_Ü);
         pragma Suppress (Validity_Check, Result_Ü);
         Arg_CC_Result_Ü_Ü : aliased PolyORB.Any.Content'Class :=
           CORBA.Wrap
              (Result_Ü'Unrestricted_Access);
         Arg_Any_Result_Ü_Ü : constant CORBA.Any :=
           CORBA.Internals.Get_Wrapper_Any
              (CORBA.TC_TypeCode,
               Arg_CC_Result_Ü_Ü'Unchecked_Access);
      begin
         --  Processing request
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         --  Call Implementation
         Result_Ü :=
           CORBA.Repository_Root.AbstractInterfaceDef.Impl.get_type
              (CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class
                 (Self.all)'Access);
         --  Setting the result
         CORBA.ServerRequest.Set_Result
           (Request,
            Arg_Any_Result_Ü_Ü);
         CORBA.NVList.Internals.Clone_Out_Args
           (Argument_List_Ü);
      end Invoke_Uget_type;

      procedure Invoke_Uis_a;

      ------------------
      -- Invoke_Uis_a --
      ------------------

      procedure Invoke_Uis_a is
         Type_Id_Ü : CORBA.String;
         Arg_Name_Type_Id_Ü : constant CORBA.Identifier :=
           CORBA.To_CORBA_String
              ("Type_Id_Ü");
         Argument_Type_Id_Ü : constant CORBA.Any :=
           CORBA.To_Any
              (Type_Id_Ü);
         Result_Ü : CORBA.Boolean;
      begin
         CORBA.NVList.Add_Item
           (Argument_List_Ü,
            Arg_Name_Type_Id_Ü,
            Argument_Type_Id_Ü,
            CORBA.ARG_IN);
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         Type_Id_Ü :=
           CORBA.From_Any
              (Argument_Type_Id_Ü);
         Result_Ü :=
           Is_A
              (CORBA.To_Standard_String
                 (Type_Id_Ü));
         CORBA.ServerRequest.Set_Result
           (Request,
            CORBA.To_Any
              (Result_Ü));
      end Invoke_Uis_a;

      procedure Invoke_Uinterface;

      -----------------------
      -- Invoke_Uinterface --
      -----------------------

      procedure Invoke_Uinterface is
      begin
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         CORBA.ServerRequest.Set_Result
           (Request,
            CORBA.Object.Helper.To_Any
              (CORBA.Object.Ref
                 (PolyORB.CORBA_P.IR_Hooks.Get_Interface_Definition
                    (CORBA.To_CORBA_String
                       (Repository_Id)))));
      end Invoke_Uinterface;

      procedure Invoke_Udomain_managers;

      -----------------------------
      -- Invoke_Udomain_managers --
      -----------------------------

      procedure Invoke_Udomain_managers is
      begin
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         CORBA.ServerRequest.Set_Result
           (Request,
            PolyORB.CORBA_P.Domain_Management.Get_Domain_Managers
              (Self));
      end Invoke_Udomain_managers;

      procedure Invoke_Unon_existent;

      --------------------------
      -- Invoke_Unon_existent --
      --------------------------

      procedure Invoke_Unon_existent is
      begin
         CORBA.ServerRequest.Arguments
           (Request,
            Argument_List_Ü);
         CORBA.ServerRequest.Set_Result
           (Request,
            CORBA.To_Any
              (CORBA.Boolean'
                 (False)));
      end Invoke_Unon_existent;

      procedure Dispatch;

      --------------
      -- Dispatch --
      --------------

      procedure Dispatch is
      begin
         case Index_Ü is
            when 0 =>
               Invoke_Uget_base_interfaces;
            when 1 =>
               Invoke_Uset_base_interfaces;
            when 2 =>
               Invoke_Uget_is_abstract;
            when 3 =>
               Invoke_Uset_is_abstract;
            when 4 =>
               Invoke_is_a;
            when 5 =>
               Invoke_describe_interface;
            when 6 =>
               Invoke_create_attribute;
            when 7 =>
               Invoke_create_operation;
            when 8 =>
               Invoke_lookup;
            when 9 =>
               Invoke_contents;
            when 10 =>
               Invoke_lookup_name;
            when 11 =>
               Invoke_describe_contents;
            when 12 =>
               Invoke_create_module;
            when 13 =>
               Invoke_create_constant;
            when 14 =>
               Invoke_create_struct;
            when 15 =>
               Invoke_create_union;
            when 16 =>
               Invoke_create_enum;
            when 17 =>
               Invoke_create_alias;
            when 18 =>
               Invoke_create_interface;
            when 19 =>
               Invoke_create_value;
            when 20 =>
               Invoke_create_value_box;
            when 21 =>
               Invoke_create_exception;
            when 22 =>
               Invoke_create_native;
            when 23 =>
               Invoke_create_abstract_interface;
            when 24 =>
               Invoke_create_local_interface;
            when 25 =>
               Invoke_Uget_def_kind;
            when 26 =>
               Invoke_destroy;
            when 27 =>
               Invoke_Uget_id;
            when 28 =>
               Invoke_Uset_id;
            when 29 =>
               Invoke_Uget_name;
            when 30 =>
               Invoke_Uset_name;
            when 31 =>
               Invoke_Uget_version;
            when 32 =>
               Invoke_Uset_version;
            when 33 =>
               Invoke_Uget_defined_in;
            when 34 =>
               Invoke_Uget_absolute_name;
            when 35 =>
               Invoke_Uget_containing_repository;
            when 36 =>
               Invoke_describe;
            when 37 =>
               Invoke_move;
            when 38 =>
               Invoke_Uget_type;
            when 40 =>
               Invoke_Uinterface;
            when 41 =>
               Invoke_Udomain_managers;
            when 42
               | 43 =>
               Invoke_Unon_existent;
            when 39 =>
               Invoke_Uis_a;
            pragma Warnings (Off);
            when others =>
               raise Program_Error;
            pragma Warnings (On);

         end case;
      end Dispatch;

   begin
      CORBA.ORB.Create_List
        (0,
         Argument_List_Ü);
      Index_Ü :=
        CORBA_Repository_Root_AbstractInterfaceDef_Hash.Hash
           (Operation_Ü);
      Invoke_Name_Access :=
        Invoke_Db
           (Index_Ü);
      begin
         if (Operation_Ü
            = Invoke_Name_Access.all)
         then
            Dispatch;
         else
            CORBA.Raise_Bad_Operation
              (CORBA.Default_Sys_Member);
         end if;
      exception
         when E : others =>
            CORBA.ServerRequest.Set_Exception
              (Request,
               PolyORB.CORBA_P.Exceptions.System_Exception_To_Any
                 (E));
            PolyORB.Qos.Exception_Informations.Set_Exception_Information
              (Request.all,
               E);
      end;
   end Invoke;

   function Servant_Is_A
     (Obj : PortableServer.Servant)
     return Boolean;

   ------------------
   -- Servant_Is_A --
   ------------------

   function Servant_Is_A
     (Obj : PortableServer.Servant)
     return Boolean
   is
   begin
      return (Obj.all
         in CORBA.Repository_Root.AbstractInterfaceDef.Impl.Object'Class);
   end Servant_Is_A;

   -----------------------------
   -- Deferred_Initialization --
   -----------------------------

   procedure Deferred_Initialization is
   begin
      PortableServer.Internals.Register_Skeleton
        (CORBA.Repository_Root.AbstractInterfaceDef.Repository_Id,
         Servant_Is_A'Access,
         Is_A'Access,
         Invoke'Access);
      Register_Procedure
        ("_get_base_interfaces");
      Register_Procedure
        ("_set_base_interfaces");
      Register_Procedure
        ("_get_is_abstract");
      Register_Procedure
        ("_set_is_abstract");
      Register_Procedure
        ("is_a");
      Register_Procedure
        ("describe_interface");
      Register_Procedure
        ("create_attribute");
      Register_Procedure
        ("create_operation");
      Register_Procedure
        ("lookup");
      Register_Procedure
        ("contents");
      Register_Procedure
        ("lookup_name");
      Register_Procedure
        ("describe_contents");
      Register_Procedure
        ("create_module");
      Register_Procedure
        ("create_constant");
      Register_Procedure
        ("create_struct");
      Register_Procedure
        ("create_union");
      Register_Procedure
        ("create_enum");
      Register_Procedure
        ("create_alias");
      Register_Procedure
        ("create_interface");
      Register_Procedure
        ("create_value");
      Register_Procedure
        ("create_value_box");
      Register_Procedure
        ("create_exception");
      Register_Procedure
        ("create_native");
      Register_Procedure
        ("create_abstract_interface");
      Register_Procedure
        ("create_local_interface");
      Register_Procedure
        ("_get_def_kind");
      Register_Procedure
        ("destroy");
      Register_Procedure
        ("_get_id");
      Register_Procedure
        ("_set_id");
      Register_Procedure
        ("_get_name");
      Register_Procedure
        ("_set_name");
      Register_Procedure
        ("_get_version");
      Register_Procedure
        ("_set_version");
      Register_Procedure
        ("_get_defined_in");
      Register_Procedure
        ("_get_absolute_name");
      Register_Procedure
        ("_get_containing_repository");
      Register_Procedure
        ("describe");
      Register_Procedure
        ("move");
      Register_Procedure
        ("_get_type");
      Register_Procedure
        ("_is_a");
      Register_Procedure
        ("_interface");
      Register_Procedure
        ("_domain_managers");
      Register_Procedure
        ("_non_existent");
      Register_Procedure
        ("_not_existent");
   end Deferred_Initialization;

begin
   declare
      use PolyORB.Utils.Strings;
      use PolyORB.Utils.Strings.Lists;
   begin
      PolyORB.Initialization.Register_Module
        (PolyORB.Initialization.Module_Info'
           (Name => +"CORBA.Repository_Root.AbstractInterfaceDef.Skel",
            Conflicts => PolyORB.Utils.Strings.Lists.Empty,
            Depends => PolyORB.Utils.Strings.Lists.Empty
               & "CORBA.Repository_Root.InterfaceDef.Skel?",
            Provides => PolyORB.Utils.Strings.Lists.Empty,
            Implicit => False,
            Init => Deferred_Initialization'Access,
            Shutdown => null));
   end;
end CORBA.Repository_Root.AbstractInterfaceDef.Skel;
