// Common Object Request Broker Architecture (CORBA), v2.4.2 February 2001
// Common Object Request Broker Architecture (CORBA), v2.6 December 2001
//
// Include this file in your IDL if you need standard definition(s).

/* List of CORBA pseudo objects

   TypeCode       (transferable, not a keyword)
   Principal      (transferable, not a keyword)
   any            (transferable, keyword)
   _Context       (transferable, collides with context keyword)
   exception      (transferable, keyword)
   ORB
   ValueBase      (transferable, keyword)
   Request
   NVList
   NamedValue
   ServerRequest
   
   List of CORBA native types
   OpaqueValue
   AbstractBase
   ValueFactory
   PortableServer::Servant
   PortableServer::Cookie
*/

#if !defined(CORBA_IDL)
#define CORBA_IDL

#pragma prefix "omg.org"

#pragma vbClsPrefix c
#pragma vbModPrefix m

/* Abstract Interface Semantics
   See CORBA v2.6   December 2001  6-2
*/
module CORBA
{
	native AbstractBase;
};

/* Language Specific Value Factory Requirements
   See CORBA v2.6   December 2001  5-10
*/
module CORBA
{
	native ValueFactory;
};

/* ::CORBA::TypeCode
   See CORBA v2.4.2 February 2001 10-51
       CORBA v2.6   December 2001  4-52
*/
module CORBA
{
	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,
		tk_value, tk_value_box,
		tk_native,
		tk_abstract_interface,
		tk_local_interface
	};
	typedef short ValueModifier;
	const ValueModifier VM_NONE= 0;
	const ValueModifier VM_CUSTOM= 1;
	const ValueModifier VM_ABSTRACT= 2;
	const ValueModifier VM_TRUNCATABLE= 3;
	
	interface TypeCode;	// pseudo object, see also <TypeCode.idl>
};

/* Current Object
   See CORBA v2.6   December 2001  4-33
*/
module CORBA{
	// base interface for the Current object
	interface Current {};
};

/* Policy Object
   See CORBA v2.6   December 2001  4-33
*/
module CORBA
{
	typedef short PolicyErrorCode;
	const PolicyErrorCode BAD_POLICY = 0;
	const PolicyErrorCode UNSUPPORTED_POLICY = 1;
	const PolicyErrorCode BAD_POLICY_TYPE = 2;
	const PolicyErrorCode BAD_POLICY_VALUE = 3;
	const PolicyErrorCode UNSUPPORTED_POLICY_VALUE = 4;

	exception PolicyError
	{	PolicyErrorCode reason;
	};

	typedef unsigned long PolicyType;
	
	// Basic IDL definition
	interface Policy
	{
		readonly attribute PolicyType policy_type;
		Policy copy();
		void destroy();
	};
	typedef sequence <Policy> PolicyList;
#pragma vbClsPrefix c_
	typedef sequence <PolicyType> PolicyTypeSeq;
#pragma vbClsPrefix c
};

/* Standard Value Box Definitions
   See CORBA v2.6   December 2001  5-9
*/
module CORBA
{
	valuetype StringValue string;
	valuetype WStringValue wstring;
};

/* Java IIOP/RMI mapping
*/
#pragma prefix ""
#pragma vbClsPrefix c_
module java
{	module lang
	{	typedef any _Object;
	};
};

#pragma prefix "omg.org"
#pragma vbClsPrefix c
module org
{	module omg
	{	module boxedRMI
		{
#pragma vbClsPrefix c_
			valuetype seq1_boolean sequence<boolean>;
			#pragma ID seq1_boolean "RMI:[Z:0000000000000000"
			valuetype seq1_octet sequence<octet>;
			#pragma ID seq1_octet "RMI:[B:0000000000000000"
			valuetype seq1_long sequence<long>;
			#pragma ID seq1_long "RMI:[I:0000000000000000"
			module java
			{	module lang
				{
					valuetype seq1_Object sequence< ::java::lang::_Object >;
					#pragma ID seq1_Object "RMI:[Ljava.lang.Object;:0000000000000000"
#pragma vbClsPrefix c
					valuetype seq1_String sequence<::CORBA::WStringValue>;
					#pragma ID seq1_String "RMI:[Ljava.lang.String;:0000000000000000"
				};
			};
		};
	};
};

/* ValueType Semantics, Marshaling Streams
   See CORBA v2.6   December 2001  5-12
*/
module CORBA
{
#pragma vbClsPrefix c_
	typedef sequence<any> AnySeq;
	typedef sequence<boolean> BooleanSeq;
	typedef sequence<char> CharSeq;
	typedef sequence<wchar> WCharSeq;
	typedef sequence<octet> OctetSeq;
	typedef sequence<short> ShortSeq;
	typedef sequence<unsigned short> UShortSeq;
	typedef sequence<long> LongSeq;
	typedef sequence<unsigned long> ULongSeq;
	typedef sequence<long long> LongLongSeq;
	typedef sequence<unsigned long long> ULongLongSeq;
	typedef sequence<float> FloatSeq;
	typedef sequence<double> DoubleSeq;
	typedef sequence<long double> LongDoubleSeq;
	typedef sequence<string> StringSeq;
	typedef sequence<wstring> WStringSeq;
#pragma vbClsPrefix c
	
	exception BadFixedValue
	{	unsigned long offset;
	};
	
	abstract valuetype DataOutputStream
	{
		void write_any(in any value);
		void write_boolean(in boolean value);
		void write_char(in char value);
		void write_wchar(in wchar value);
		void write_octet(in octet value);
		void write_short(in short value);
		void write_ushort(in unsigned short value);
		void write_long(in long value);
		void write_ulong(in unsigned long value);
		void write_longlong(in long long value);
		void write_ulonglong(in unsigned long long value);
		void write_float(in float value);
		void write_double(in double value);
		void write_longdouble(in long double value);
		void write_string(in string value);
		void write_wstring(in wstring value);
		void write_Object(in Object value);
		void write_Abstract(in AbstractBase value);
		void write_Value(in ValueBase value);
		void write_TypeCode(in TypeCode value);
		void write_any_array(in AnySeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void write_boolean_array(in BooleanSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void write_char_array(in CharSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void write_wchar_array(in WCharSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void write_octet_array(in OctetSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void write_short_array(in ShortSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void write_ushort_array(in UShortSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void write_long_array(in LongSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void write_ulong_array(in ULongSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void write_ulonglong_array(in ULongLongSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void write_longlong_array(in LongLongSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void write_float_array(in FloatSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void write_double_array(in DoubleSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void write_long_double_array(in LongDoubleSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void write_fixed(in any fixed_value)
			raises(BadFixedValue);
		void write_fixed_array(in AnySeq seq,
			in unsigned long offset,
			in unsigned long length)
			raises(BadFixedValue);
	};
	
	abstract valuetype DataInputStream
	{
		any read_any();
		boolean read_boolean();
		char read_char();
		wchar read_wchar();
		octet read_octet();
		short read_short();
		unsigned short read_ushort();
		long read_long();
		unsigned long read_ulong();
		long long read_longlong();
		unsigned long long read_ulonglong();
		float read_float();
		double read_double();
		long double read_longdouble();
		string read_string();
		wstring read_wstring();
		Object read_Object();
		AbstractBase read_Abstract();
		ValueBase read_Value();
		TypeCode read_TypeCode();
		void read_any_array(inout AnySeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void read_boolean_array(inout BooleanSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void read_char_array(inout CharSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void read_wchar_array(inout WCharSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void read_octet_array(inout OctetSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void read_short_array(inout ShortSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void read_ushort_array(inout UShortSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void read_long_array(inout LongSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void read_ulong_array(inout ULongSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void read_ulonglong_array(inout ULongLongSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void read_longlong_array(inout LongLongSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void read_float_array(inout FloatSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void read_double_array(inout DoubleSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		void read_long_double_array(inout DoubleSeq seq,
			in unsigned long offset,
			in unsigned long length
		);
		any read_fixed(in unsigned short digits,
			in short scale)
			raises(BadFixedValue);
		void read_fixed_array(inout AnySeq seq,
			in unsigned long offset,
			in unsigned long length,
			in unsigned short digits,
			in short scale)
			raises(BadFixedValue);
	};
};

/* Implementation of Custom Marshaling
   See CORBA v2.6   December 2001  5-11
*/
module CORBA
{
	abstract valuetype CustomMarshal
	{
		void marshal(in DataOutputStream os);
		void unmarshal(in DataInputStream is);
	};
};

/* OMGIDL for Interface Repository
   See CORBA v2.6   December 2001 10-51 (10.7)
*/
module CORBA
{
	typedef string Identifier;
	typedef string ScopedName;
	typedef string RepositoryId;
	
	enum DefinitionKind
	{	dk_none, dk_all,
		dk_Attribute, dk_Constant, dk_Exception, dk_Interface,
		dk_Module, dk_Operation, dk_Typedef,
		dk_Alias, dk_Struct, dk_Union, dk_Enum,
		dk_Primitive, dk_String, dk_Sequence, dk_Array,
		dk_Repository,
		dk_Wstring, dk_Fixed,
		dk_Value, dk_ValueBox, dk_ValueMember,
		dk_Native,
		dk_AbstractInterface,
		dk_LocalInterface
	};
	
	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 NativeDef;
	typedef sequence <InterfaceDef> InterfaceDefSeq;
	interface ValueDef;
	typedef sequence <ValueDef> ValueDefSeq;
	interface ValueBoxDef;
	interface AbstractInterfaceDef;
	typedef sequence <AbstractInterfaceDef> AbstractInterfaceDefSeq;
	interface LocalInterfaceDef;
	typedef sequence <LocalInterfaceDef> LocalInterfaceDefSeq;
	typedef sequence <Contained> ContainedSeq;
	struct StructMember
	{	Identifier name;
		TypeCode type;
		IDLType type_def;
	};
	typedef sequence <StructMember> StructMemberSeq;
	struct Initializer
	{	StructMemberSeq members;
		Identifier name;
	};
	typedef sequence <Initializer> InitializerSeq;
	struct UnionMember
	{	Identifier name;
		any label;
		TypeCode type;
		IDLType type_def;
	};
	typedef sequence <UnionMember> UnionMemberSeq;
#pragma vbClsPrefix c_
	typedef sequence <Identifier> EnumMemberSeq;
#pragma vbClsPrefix c
	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);
		ValueDef create_value(
			in RepositoryId id, in Identifier name, in VersionSpec version,
			in boolean is_custom,
			in boolean is_abstract,
			in ValueDef base_value,
			in boolean is_truncatable,
			in ValueDefSeq abstract_base_values,
			in InterfaceDefSeq supported_interfaces,
			in InitializerSeq initializers);
		ValueBoxDef create_value_box(
			in RepositoryId id, in Identifier name, in VersionSpec version,
			in IDLType original_type_def);
		ExceptionDef create_exception(
			in RepositoryId id, in Identifier name, in VersionSpec version,
			in StructMemberSeq members);
		NativeDef create_native(
			in RepositoryId id, in Identifier name, in VersionSpec version);
		AbstractInterfaceDef create_abstract_interface(
			in RepositoryId id, in Identifier name, in VersionSpec version,
			in AbstractInterfaceDefSeq base_interfaces);
		LocalInterfaceDef create_local_interface(
			in RepositoryId id, in Identifier name, in VersionSpec version,
			in InterfaceDefSeq base_interfaces);
	};
	
	interface IDLType : IRObject
	{
		readonly attribute TypeCode type;
	};
	
	interface PrimitiveDef;
	interface StringDef;
	interface SequenceDef;
	interface ArrayDef;
	interface WstringDef;
	interface FixedDef;
	
	enum PrimitiveKind
	{	pk_null, pk_void, pk_short, pk_long, pk_ushort, pk_ulong,
		pk_float, pk_double, pk_boolean, pk_char, pk_octet,
		pk_any, pk_TypeCode, pk_Principal, pk_string, pk_objref,
		pk_longlong, pk_ulonglong, pk_longdouble,
		pk_wchar, pk_wstring, pk_value_base
	};
	
	interface Repository : Container
	{
		// read interface
		Contained lookup_id(in RepositoryId search_id);
		TypeCode get_canonical_typecode(in TypeCode tc);
		PrimitiveDef get_primitive(in PrimitiveKind kind);
		
		// write interface
		StringDef create_string(in unsigned long bound);
		WstringDef create_wstring(in unsigned long bound);
		SequenceDef create_sequence(in unsigned long bound,
			in IDLType element_type);
		ArrayDef create_array(in unsigned long length,
			in IDLType element_type);
		FixedDef create_fixed(in unsigned short digits, in short scale);
	};
	
	interface 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 NativeDef : TypedefDef {};
	
	interface PrimitiveDef: IDLType
	{	readonly attribute PrimitiveKind kind;
	};
	
	interface StringDef : IDLType
	{	attribute unsigned long bound;
	};
	
	interface WstringDef : IDLType
	{	attribute unsigned long bound;
	};
	
	interface FixedDef : IDLType
	{	attribute unsigned short digits;
		attribute short scale;
	};
	
	interface SequenceDef : IDLType
	{	attribute unsigned long bound;
		readonly attribute 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;
#pragma vbClsPrefix c_
	typedef sequence <ContextIdentifier> ContextIdSeq;
#pragma vbClsPrefix c
	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;
	};
	
#pragma vbClsPrefix c_
	typedef sequence <RepositoryId> RepositoryIdSeq;
#pragma vbClsPrefix c
	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 short Visibility;
	
	const Visibility PRIVATE_MEMBER = 0;
	const Visibility PUBLIC_MEMBER = 1;
	struct ValueMember
	{	Identifier name;
		RepositoryId id;
		RepositoryId defined_in;
		VersionSpec version;
		TypeCode type;
		IDLType type_def;
		Visibility access;
	};
	
	typedef sequence <ValueMember> ValueMemberSeq;
	interface ValueMemberDef : Contained
	{	readonly attribute TypeCode type;
		attribute IDLType type_def;
		attribute Visibility access;
	};
	
	interface ValueDef : Container, Contained, IDLType
	{
		// read/write interface
		attribute InterfaceDefSeq supported_interfaces;
		attribute InitializerSeq initializers;
		attribute ValueDef base_value;
		attribute ValueDefSeq abstract_base_values;
		attribute boolean is_abstract;
		attribute boolean is_custom;
		attribute boolean is_truncatable;

		// read interface
		boolean is_a(in RepositoryId id);
		struct FullValueDescription
		{	Identifier name;
			RepositoryId id;
			boolean is_abstract;
			boolean is_custom;
			RepositoryId defined_in;
			VersionSpec version;
			OpDescriptionSeq operations;
			AttrDescriptionSeq attributes;
			ValueMemberSeq members;
			InitializerSeq initializers;
			RepositoryIdSeq supported_interfaces;
			RepositoryIdSeq abstract_base_values;
			boolean is_truncatable;
			RepositoryId base_value;
			TypeCode type;
		};
		FullValueDescription describe_value();
		ValueMemberDef create_value_member(
			in RepositoryId id,
			in Identifier name,
			in VersionSpec version,
			in IDLType type,
			in Visibility access);
		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 ValueDescription
	{	Identifier name;
		RepositoryId id;
		boolean is_abstract;
		boolean is_custom;
		RepositoryId defined_in;
		VersionSpec version;
		RepositoryIdSeq supported_interfaces;
		RepositoryIdSeq abstract_base_values;
		boolean is_truncatable;
		RepositoryId base_value;
	};
	
	interface ValueBoxDef : TypedefDef
	{	attribute IDLType original_type_def;
	};
	
	interface AbstractInterfaceDef : InterfaceDef {};
	interface LocalInterfaceDef : InterfaceDef {};
};

/* ::CORBA::ORB
   See CORBA v2.6   December 2001  4-2 (4)
*/
module CORBA
{
	interface NVList;	// pseudo object
	interface _Context;	// pseudo object

	interface Request;	// pseudo object
	typedef sequence <Request> RequestSeq;

	typedef unsigned short ServiceType;
	typedef unsigned long ServiceOption;
	typedef unsigned long ServiceDetailType;
	
	const ServiceType Security = 1;
	
	struct ServiceDetail
	{	ServiceDetailType service_detail_type;
#pragma vbClsPrefix c_
		sequence <octet> service_detail;
#pragma vbClsPrefix c
	};
	struct ServiceInformation
	{
#pragma vbClsPrefix c_
		sequence <ServiceOption> service_options;
#pragma vbClsPrefix c
		sequence <ServiceDetail> service_details;
	};

	typedef string ORBid;
	
	interface ORB
	{
		typedef string ObjectId;
#pragma vbClsPrefix c_
		typedef sequence <ObjectId> ObjectIdList;
#pragma vbClsPrefix c
		exception InvalidName {};
		
		ORBid id();
		
		string object_to_string(in Object obj);

		Object string_to_object(in string str);

		// Dynamic Invocation related operations
		void create_list(in long count, out NVList new_list);
		void create_operation_list(in OperationDef oper,
			out NVList new_list);
		void get_default_context(out _Context ctx);
		void send_multiple_requests_oneway(in RequestSeq req);
		void send_multiple_requests_deferred(in RequestSeq req);
		boolean poll_next_response();
		void get_next_response(out Request req);

		// Service information operations
		boolean get_service_information(in ServiceType service_type,
			out ServiceInformation service_information);
		ObjectIdList list_initial_services();

		// Initial reference operation
		Object resolve_initial_references(in ObjectId identifier)
			raises(InvalidName);
		
		// Type code creation operations
		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 element_type);
		TypeCode create_recursive_sequence_tc(	// deprecated
			in unsigned long bound, in unsigned long offset);
		TypeCode create_array_tc(in unsigned long length,
			in TypeCode element_type);
		TypeCode create_value_tc(
			in RepositoryId id, in Identifier name,
			in ValueModifier type_modifier,
			in TypeCode concrete_base,
			in ValueMemberSeq members);
		TypeCode create_value_box_tc(
			in RepositoryId id, in Identifier name,
			in TypeCode boxed_type);
		TypeCode create_native_tc(
			in RepositoryId id, in Identifier name);
		TypeCode create_recursive_tc(
			in RepositoryId id);
		TypeCode create_abstract_interface_tc(
			in RepositoryId id, in Identifier name);
		TypeCode create_local_interface_tc(
			in RepositoryId id, in Identifier name);

		// Thread related operations
		boolean work_pending();
		void perform_work();
		void run();
		void shutdown(in boolean wait_for_completion);
		void destroy();
		
		// Policy related operations
		Policy create_policy(in PolicyType type,
			in any val) raises (PolicyError);

		// Dynamic Any related operations deprecated and removed
		// from primary list of ORB operations

		// Value factory operations
		// ??? factory is a keyword
		ValueFactory register_value_factory(in RepositoryId id,
			in ValueFactory _factory);
		void unregister_value_factory(in RepositoryId id);
		ValueFactory lookup_value_factory(in RepositoryId id);
		
		void register_initial_reference(in ObjectId id, in Object obj)
			raises(InvalidName);
	};
};


// Map long IDL names to short Visual Basic names
//
// Cannot map module CORBA to Orb because CORBA::ORB is maped to Orb
#pragma vbName CORBA CB
#pragma vbName CORBA::TypeCode OrbTypeCode
#pragma vbName CORBA::ValueFactory OrbValueFactory
#pragma vbName CORBA::ORB Orb
#pragma vbName CORBA::NVList OrbNVList
#pragma vbName CORBA::_Context OrbContext
#pragma vbName CORBA::Request OrbRequest
//#pragma vbName CORBA::IRObject OrbIRObject

#endif // CORBA_IDL
