%{
#pragma include_defs orb/orbit.h
%}
#pragma inhibit push

#pragma prefix "omg.org"

module CORBA {
	typedef unsigned short ServiceType;
	typedef unsigned long ServiceOption;
	typedef unsigned long ServiceDetailType;

	const ServiceType Security = 1;

	struct ServiceDetail {
		ServiceDetailType service_detail_type;
		sequence<octet> service_detail;
	};

	struct ServiceInformation {
		sequence<ServiceOption> service_options;
		sequence<ServiceDetail> service_details;
	};

	typedef string Identifier;
	typedef string ScopedName;
	typedef string RepositoryId;

	enum TCKind {
		tk_null, tk_void,
		tk_short, tk_long, tk_ushort, tk_ulong,
		tk_float, tk_double, tk_boolean, tk_char,
		tk_octet, tk_any, tk_TypeCode, tk_Principal, tk_objref,
		tk_struct, tk_union, tk_enum, tk_string,
		tk_sequence, tk_array, tk_alias, tk_except,
		tk_longlong, tk_ulonglong, tk_longdouble,
		tk_wchar, tk_wstring, tk_fixed
	};

	interface TypeCode {
		exception Bounds{};
		exception BadKind{};

		// for all TypeCode kinds
		boolean equal(in TypeCode tc);
		TCKind kind();

		// for tk_objref, tk_struct, tk_union, tk_enum, tk_alias and tk_except
		RepositoryId id() raises(BadKind);

		// for tk_objref, tk_struct, tk_union, tk_enum, tk_alias and tk_except
		Identifier name() raises(BadKind);

		// for tk_struct, tk_union, tk_enum and tk_except
		unsigned long member_count() raises(BadKind);
		Identifier member_name(in unsigned long index) raises(BadKind, Bounds);

		// for tk_struct, tk_union and tk_except
		TypeCode member_type(in unsigned long index) raises(BadKind, Bounds);

		// for tk_union
		any member_label(in unsigned long index) raises(BadKind, Bounds);
		TypeCode discriminator_type() raises(BadKind);
		long default_index() raises(BadKind);

		// for tk_string, tk_sequence and tk_array
		unsigned long length() raises(BadKind);

		// for tk_sequence, tk_array and tk_alias
		TypeCode content_type() raises(BadKind);

		// for tk_fixed
		unsigned short fixed_digits() raises(BadKind);
		short fixed_scale() raises(BadKind);

		// deprecated interface
		long param_count();
		any parameter(in long index) raises(Bounds);
	};

	typedef unsigned long Flags;
	typedef unsigned long Status;

	struct NamedValue {
		Identifier name;
		any argument;
		long len;
		Flags arg_modes;
	};

	interface Request {
		Status add_arg(in Identifier name,
			in TypeCode arg_type,
			in void *value,
			in long len,
			in Flags arg_flags);
		Status invoke(in Flags invoke_flags);
		Status delete();
		Status send(in Flags invoke_flags);
		Status get_response(in Flags response_flags)
			raises(WrongTransaction);
	};

	enum DefinitionKind {
		dk_none, dk_all,
		dk_Attribute, dk_Constant, dk_Exception, dk_Interface,
		dk_Module, dk_Operation, dk_Typedef,
		dk_Alias, dk_Struct, dk_Union, dk_Enum,
		dk_Primitive, dk_String, dk_Sequence, dk_Array,
		dk_Repository,
		dk_Wstring, dk_Fixed
	};

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

	typedef string VersionSpec;

	interface Contained;
	interface Repository;
	interface Container;

	interface Contained: IRObject {
		// read/write interface

		attribute RepositoryId id;
		attribute Identifier name;
		attribute VersionSpec version;

		// read interface

		readonly attribute Container defined_in;
		readonly attribute ScopedName absolute_name;
		readonly attribute Repository containing_repository;

		struct Description {
			DefinitionKind kind;
			any Value;
		};

		Description describe();

		// write interface

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

	interface ModuleDef;
	interface ConstantDef;
	interface IDLType;
	interface StructDef;
	interface UnionDef;
	interface EnumDef;
	interface AliasDef;
	interface InterfaceDef;
	interface ExceptionDef;
	interface WstringDef;
	typedef sequence<InterfaceDef> InterfaceDefSeq;

	typedef sequence<Contained> ContainedSeq;
	struct StructMember {
		Identifier name;
		TypeCode type;
		IDLType type_def;
	};

	typedef sequence<StructMember> StructMemberSeq;

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

	typedef sequence<UnionMember> UnionMemberSeq;

	typedef sequence<Identifier> EnumMemberSeq;

	interface Container: IRObject {
		// read interface

		Contained lookup(in ScopedName search_name);

		ContainedSeq contents(in DefinitionKind limit_type,
			in boolean exclude_inherited);
		ContainedSeq lookup_name(in Identifier search_name,
			in long levels_to_search,
			in DefinitionKind limit_type,
			in boolean exclude_inherited);

		struct Description {
			Contained contained_object;
			DefinitionKind kind;
			any value;
		};

		typedef sequence<Description> DescriptionSeq;

		DescriptionSeq describe_contents(in DefinitionKind limit_type,
			in boolean exclude_inherited,
			in long max_returned_objs);

		// write interface

		ModuleDef create_module(in RepositoryId id,
			in Identifier name,
			in VersionSpec version);

		ConstantDef create_constant(in RepositoryId id,
			in Identifier name,
			in VersionSpec version,
			in IDLType type,
			in any value);

		StructDef create_struct(in RepositoryId id,
			in Identifier name,
			in VersionSpec version,
			in StructMemberSeq members);

		UnionDef create_union(in RepositoryId id,
			in Identifier name,
			in VersionSpec version,
			in IDLType discriminator_type,
			in UnionMemberSeq members);

		EnumDef create_enum(in RepositoryId id,
			in Identifier name,
			in VersionSpec version,
			in EnumMemberSeq members);

		AliasDef create_alias(in RepositoryId id,
			in Identifier name,
			in VersionSpec version,
			in IDLType original_type);

		InterfaceDef create_interface(in RepositoryId id,
			in Identifier name,
			in VersionSpec version,
			in InterfaceDefSeq base_interfaces);

		ExceptionDef create_exception(in RepositoryId id,
			in Identifier name,
			in VersionSpec version,
			in StructMemberSeq members);
	};

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

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

	enum PrimitiveKind {
		pk_null, pk_void, pk_short, pk_long, pk_ushort, pk_ulong,
		pk_float, pk_double, pk_boolean, pk_char, pk_octet,
		pk_any, pk_TypeCode, pk_Principal, pk_string, pk_objref,
		pk_longlong, pk_ulonglong, pk_longdouble, pk_wchar, pk_wstring
	};

	interface Repository: Container {
		// read interface

		Contained lookup_id(in RepositoryId search_id);
		PrimitiveDef get_primitive(in PrimitiveKind kind);

		// write interface

		StringDef create_string(in unsigned long bound);
		WstringDef create_wstring(in unsigned long bound);

		SequenceDef create_sequence(in unsigned long bound, 
			in IDLType element_type);
		ArrayDef create_array(in unsigned long length,
			in IDLType element_type);
		FixedDef create_fixed(in unsigned short digits,
			in short scale);
	};

	interface ModuleDef: Container, Contained {
	};

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

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

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

	interface TypedefDef: Contained, IDLType {
	};

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

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

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

	interface EnumDef: TypedefDef {
		attribute EnumMemberSeq members;
	};

	interface AliasDef: TypedefDef {
		attribute IDLType original_type_def;
	};

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

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

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

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

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

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

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

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

	enum AttributeMode {ATTR_NORMAL, ATTR_READONLY};

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

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

	enum OperationMode {OP_NORMAL, OP_ONEWAY};

	enum ParameterMode {PARAM_IN, PARAM_OUT, PARAM_INOUT};

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

	typedef sequence<ParameterDescription> ParDescriptionSeq;

	typedef Identifier ContextIdentifier;
	typedef sequence<ContextIdentifier> ContextIdSeq;
	typedef sequence<ExceptionDef> ExceptionDefSeq;
	typedef sequence<ExceptionDescription> ExcDescriptionSeq;

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

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

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

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

		//read interface
		boolean is_a(in RepositoryId interface_id);

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

		FullInterfaceDescription describe_interface();

		// write interface

		AttributeDef create_attribute(in RepositoryId id,
			in Identifier name,
			in VersionSpec version,
			in IDLType type,
			in AttributeMode mode);
		OperationDef create_operation(in RepositoryId id,
			in Identifier name,
			in VersionSpec version,
			in IDLType result,
			in OperationMode mode,
			in ParDescriptionSeq params,
			in ExceptionDefSeq exceptions,
			in ContextIdSeq contexts);
	};

	struct InterfaceDescription {
		Identifier name;
		RepositoryId id;
		RepositoryId defined_in;
		VersionSpec version;
		RepositoryIdSeq base_interfaces;
	};

	typedef unsigned long PolicyType;

	interface Policy {
		readonly attribute PolicyType policy_type;
		Policy copy();
		void destroy();
	};

	typedef sequence<Policy> PolicyList;

	interface DomainManager {
		Policy get_domain_policy(in PolicyType policy_type);
	};

	const PolicyType SecConstruction = 11;

	interface ConstructionPolicy: Policy {
		void make_domain_manager(in CORBA::InterfaceDef object_type, in boolean constr_policy);
	};

	typedef sequence<DomainManager> DomainManagerList;

	interface ImplementationDef {
		enum ActivationMode {
			ActivateShared,
			ActivateUnshared,
			ActivatePerMethod,
			ActivatePersistent,
			ActivateLibrary
		};

		typedef sequence<string> RepoIdList;

		attribute ActivationMode mode;
		attribute RepoIdList repoids;
		readonly attribute string name;
		attribute string command;
		readonly attribute string tostring;
	};

	typedef string Context;
	typedef sequence<NamedValue> NVList;

	interface Object {

		// deprecated as of v2.2
		ImplementationDef get_implementation();
		InterfaceDef get_interface();
		boolean is_nil();
		Object duplicate();
		void release();
		boolean is_a(in string logical_type_id);
		boolean non_existent();
		boolean is_equivalent(in Object other_object);
		unsigned long hash(in unsigned long maximum);

		Status create_request(in Context ctx, in Identifier operation, in NVList arg_list, inout NamedValue result, out Request request, in Flags req_flags);
		Policy get_policy(in PolicyType policy_type);
		DomainManagersList get_domain_managers();
	};

	interface Current {
	};

	interface ORB {
		typedef string ObjectId;
		typedef sequence<ObjectId> ObjectIdList;

		exception InvalidName{};

		ObjectIdList list_initial_services();

		Object resolve_initial_references(in ObjectId identifier)
			raises(InvalidName);

		string object_to_string(in Object obj);
		Object string_to_object(in string str);

		Status create_list(in long count, out NVList new_list);
		Status create_operation_list(in OperationDef oper, out NVList new_list);
		Status get_default_context(out Context ctx);
		boolean get_service_information(in ServiceType service_type, out ServiceInformation service_information);

		// deprecated as of v2.2
		Current get_current();

		boolean work_pending();
		void perform_work();
		void shutdown(in boolean wait_for_completion);
		void run();

		TypeCode create_struct_tc(in RepositoryId id,
			in Identifier name,
			in StructMemberSeq members);
		TypeCode create_union_tc(in RepositoryId id,
			in Identifier name,
			in TypeCode discriminator_type,
			in UnionMemberSeq members);
		TypeCode create_enum_tc(in RepositoryId id,
			in Identifier name,
			in EnumMemberSeq members);
		TypeCode create_alias_tc(in RepositoryId id,
			in Identifier name,
			in TypeCode original_type);
		TypeCode create_exception_tc(in RepositoryId id,
			in Identifier name,
			in StructMemberSeq members);
		TypeCode create_interface_tc(in RepositoryId id,
			in Identifier name);
		TypeCode create_string_tc(in unsigned long bound);
		TypeCode create_wstring_tc(in unsigned long bound);
		TypeCode create_fixed_tc(in unsigned short digits,
			in short scale);
		TypeCode create_sequence_tc(in unsigned long bound,
			in TypeCode elementtype);
		TypeCode create_recursive_sequence_tc(in unsigned long bound,
			in unsigned long offset);
		TypeCode create_array_tc(in unsigned long length,
			in TypeCode element_type);
	};

	typedef string ORBid;
	typedef sequence<string>arg_list;
	ORB ORB_init(inout arg_list argv, in ORBid orb_identifier);
};

#pragma inhibit pop