# Stubs for "IDLInterchange"
#
# This file was automatically generated with ILU (version 2.0alpha8) tools
# at Mon Aug 26 10:00:27 1996 by `'
# running "/usr/local/ilu20a8/bin/python-stubber" of Mon Aug 26 09:58:20 1996
# on "/coho/0/hassan/dldev/src/DLInterchange/IDLInterchange.isl" of Mon Aug 12 12:35:13 1996,
# and "/coho/0/hassan/dldev/src/DLInterchange/CosPropertyService.isl" of Mon Aug 12 12:34:40 1996,
# and "/usr/local/ilu20a8/interfaces/ilu.isl" of Tue Jul 30 16:05:50 1996.
#
# ILU is Copyright 1991-1996 Xerox Corporation, All Rights Reserved.
# ILU information:  ftp://ftp.parc.xerox.com/pub/ilu/ilu.html.

_imported_modules = {};
import CosPropertyService; _imported_modules['CosPropertyService'] = CosPropertyService; del CosPropertyService;
import iluRt

InvalidRequest = 'ilu:IDLInterchange.InvalidRequest'
InvalidQuery = 'ilu:IDLInterchange.InvalidQuery'
InvalidAuthenication = 'ilu:IDLInterchange.InvalidAuthenication'
InvalidPayment = 'ilu:IDLInterchange.InvalidPayment'
UnableToCompleteRequest = 'ilu:IDLInterchange.UnableToCompleteRequest'
InvalidProperties = 'ilu:IDLInterchange.InvalidProperties'
InvalidMoreCookie = 'ilu:IDLInterchange.InvalidMoreCookie'
InvalidCookies = 'ilu:IDLInterchange.InvalidCookies'
InvalidMessageID = 'ilu:IDLInterchange.InvalidMessageID'
MultipleExceptions = 'ilu:IDLInterchange.MultipleExceptions'

class CItem(_imported_modules['CosPropertyService'].PropertySet):
    _IluClass = iluRt.FormClassRecord(\
	'IDLInterchange.CItem',\
	'',\
	'ilu:okOe0dyEDgYFqOkWTWu6fEm-B2K',\
	None,\
	iluRt.FALSE,\
	iluRt.TRUE,\
	None,\
	(\
	    ('GetAccessCapability', 1, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('AddAccessOptions', 2, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('RemoveAccessOptions', 3, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('RequestItemProperties', 4, iluRt.FALSE, iluRt.TRUE, ()),\
	    ('SetItemProperties', 5, iluRt.FALSE, iluRt.TRUE, ()),\
	    ('GetStatus', 6, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('CompletedRequest', 7, iluRt.FALSE, iluRt.TRUE, ()),\
	    ('RaiseException', 8, iluRt.FALSE, iluRt.TRUE, ()),\
	    ('CancelRequest', 9, iluRt.FALSE, iluRt.FALSE, (InvalidMessageID,)),\
	),\
	(_imported_modules['CosPropertyService'].PropertySet._IluClass,)\
	)

    def GetAccessCapability(_self):
	_result = None
	_call = iluRt.BeginCall(_self, CItem._IluClass, 1)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CItem))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CItem)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, CItem._IluClass, _ecode)
	    _result = _Input_TAccessCapability(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def AddAccessOptions(_self, pOptions):
	_call = iluRt.BeginCall(_self, CItem._IluClass, 2)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CItem)\
	      + _SizeOf_TAccessCapability(_call, pOptions))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CItem)
	    _Output_TAccessCapability(_call, pOptions)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, CItem._IluClass, _ecode)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)

    def RemoveAccessOptions(_self, pOptions):
	_call = iluRt.BeginCall(_self, CItem._IluClass, 3)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CItem)\
	      + _SizeOf_TAccessCapability(_call, pOptions))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CItem)
	    _Output_TAccessCapability(_call, pOptions)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, CItem._IluClass, _ecode)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)

    def RequestItemProperties(_self, pMessageID, pPropertyNames, pResultTarget):
	_call = iluRt.BeginCall(_self, CItem._IluClass, 4)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CItem)\
	      + _imported_modules['CosPropertyService']._SizeOf_Any(_call, pMessageID)\
	      + _imported_modules['CosPropertyService']._SizeOf_PropertyNames(_call, pPropertyNames)\
	      + iluRt.SizeOfObjectID(_call, pResultTarget, iluRt.FALSE, CItem))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CItem)
	    _imported_modules['CosPropertyService']._Output_Any(_call, pMessageID)
	    _imported_modules['CosPropertyService']._Output_PropertyNames(_call, pPropertyNames)
	    iluRt.OutputObjectID(_call, pResultTarget, iluRt.FALSE, CItem)
	    iluRt.FinishRequest(_call)
	finally:
	    iluRt.FinishCall(_call)

    def SetItemProperties(_self, pMessageID, pItem):
	_call = iluRt.BeginCall(_self, CItem._IluClass, 5)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CItem)\
	      + _imported_modules['CosPropertyService']._SizeOf_Any(_call, pMessageID)\
	      + _imported_modules['CosPropertyService']._SizeOf_Properties(_call, pItem))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CItem)
	    _imported_modules['CosPropertyService']._Output_Any(_call, pMessageID)
	    _imported_modules['CosPropertyService']._Output_Properties(_call, pItem)
	    iluRt.FinishRequest(_call)
	finally:
	    iluRt.FinishCall(_call)

    def GetStatus(_self, pMessageID):
	_result = None
	_call = iluRt.BeginCall(_self, CItem._IluClass, 6)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CItem)\
	      + _imported_modules['CosPropertyService']._SizeOf_Any(_call, pMessageID))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CItem)
	    _imported_modules['CosPropertyService']._Output_Any(_call, pMessageID)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, CItem._IluClass, _ecode)
	    _result = iluRt.InputEnum(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def CompletedRequest(_self, pMessageID):
	_call = iluRt.BeginCall(_self, CItem._IluClass, 7)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CItem)\
	      + _imported_modules['CosPropertyService']._SizeOf_Any(_call, pMessageID))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CItem)
	    _imported_modules['CosPropertyService']._Output_Any(_call, pMessageID)
	    iluRt.FinishRequest(_call)
	finally:
	    iluRt.FinishCall(_call)

    def RaiseException(_self, pMessageID, pException):
	_call = iluRt.BeginCall(_self, CItem._IluClass, 8)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CItem)\
	      + _imported_modules['CosPropertyService']._SizeOf_Any(_call, pMessageID)\
	      + _SizeOf_TException(_call, pException))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CItem)
	    _imported_modules['CosPropertyService']._Output_Any(_call, pMessageID)
	    _Output_TException(_call, pException)
	    iluRt.FinishRequest(_call)
	finally:
	    iluRt.FinishCall(_call)

    def CancelRequest(_self, pMessageID):
	_call = iluRt.BeginCall(_self, CItem._IluClass, 9)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CItem)\
	      + _imported_modules['CosPropertyService']._SizeOf_Any(_call, pMessageID))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CItem)
	    _imported_modules['CosPropertyService']._Output_Any(_call, pMessageID)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, CItem._IluClass, _ecode)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)

iluRt.RegisterClass(CItem)

class CCollection(CItem):
    _IluClass = iluRt.FormClassRecord(\
	'IDLInterchange.CCollection',\
	'',\
	'ilu:hKbRO7bZQWrHKFqRbIJBOsQKsXD',\
	None,\
	iluRt.FALSE,\
	iluRt.TRUE,\
	None,\
	(\
	    ('GetTotalItems', 1, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('SetTotalItems', 2, iluRt.FALSE, iluRt.TRUE, ()),\
	    ('GetItems', 3, iluRt.FALSE, iluRt.FALSE, (InvalidRequest, InvalidProperties, InvalidAuthenication, InvalidPayment, InvalidMoreCookie, MultipleExceptions)),\
	    ('RequestItems', 4, iluRt.FALSE, iluRt.TRUE, ()),\
	    ('AddItems', 5, iluRt.FALSE, iluRt.TRUE, ()),\
	    ('GetItemsProperties', 6, iluRt.FALSE, iluRt.FALSE, (InvalidRequest, InvalidAuthenication, InvalidPayment, InvalidCookies, InvalidProperties, MultipleExceptions)),\
	    ('RequestItemsProperties', 7, iluRt.FALSE, iluRt.TRUE, ()),\
	    ('SetItemsProperties', 8, iluRt.FALSE, iluRt.TRUE, ()),\
	    ('GetItemsPropertyNames', 9, iluRt.FALSE, iluRt.FALSE, (InvalidRequest, InvalidCookies, InvalidAuthenication, InvalidPayment, MultipleExceptions)),\
	    ('RequestItemsPropertyNames', 10, iluRt.FALSE, iluRt.TRUE, ()),\
	    ('SetItemsPropertyNames', 11, iluRt.FALSE, iluRt.TRUE, ()),\
	    ('RaiseExceptions', 12, iluRt.FALSE, iluRt.TRUE, ()),\
	    ('RemoveItems', 13, iluRt.FALSE, iluRt.FALSE, (InvalidRequest, InvalidAuthenication, MultipleExceptions)),\
	),\
	(CItem._IluClass,)\
	)

    def GetTotalItems(_self):
	_result = None
	_call = iluRt.BeginCall(_self, CCollection._IluClass, 1)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CCollection))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CCollection)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, CCollection._IluClass, _ecode)
	    _result = iluRt.InputInteger(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def SetTotalItems(_self, pTotalSize):
	_call = iluRt.BeginCall(_self, CCollection._IluClass, 2)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CCollection)\
	      + iluRt.SizeOfInteger(_call, pTotalSize))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CCollection)
	    iluRt.OutputInteger(_call, pTotalSize)
	    iluRt.FinishRequest(_call)
	finally:
	    iluRt.FinishCall(_call)

    def GetItems(_self, pPropertyNames, pMoreCookie, pNumberOfItems):
	_result = None
	_call = iluRt.BeginCall(_self, CCollection._IluClass, 3)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CCollection)\
	      + _imported_modules['CosPropertyService']._SizeOf_PropertyNames(_call, pPropertyNames)\
	      + _imported_modules['CosPropertyService']._SizeOf_Any(_call, pMoreCookie)\
	      + iluRt.SizeOfInteger(_call, pNumberOfItems))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CCollection)
	    _imported_modules['CosPropertyService']._Output_PropertyNames(_call, pPropertyNames)
	    _imported_modules['CosPropertyService']._Output_Any(_call, pMoreCookie)
	    iluRt.OutputInteger(_call, pNumberOfItems)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, CCollection._IluClass, _ecode)
	    _result = _Input_TItemsACState(_call),\
	      _Input_TAccessCapability(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def RequestItems(_self, pMessageID, pPropertyNames, pMoreCookie, pNumberItems, pResultTarget):
	_call = iluRt.BeginCall(_self, CCollection._IluClass, 4)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CCollection)\
	      + _imported_modules['CosPropertyService']._SizeOf_Any(_call, pMessageID)\
	      + _imported_modules['CosPropertyService']._SizeOf_PropertyNames(_call, pPropertyNames)\
	      + _imported_modules['CosPropertyService']._SizeOf_Any(_call, pMoreCookie)\
	      + iluRt.SizeOfInteger(_call, pNumberItems)\
	      + iluRt.SizeOfObjectID(_call, pResultTarget, iluRt.FALSE, CCollection))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CCollection)
	    _imported_modules['CosPropertyService']._Output_Any(_call, pMessageID)
	    _imported_modules['CosPropertyService']._Output_PropertyNames(_call, pPropertyNames)
	    _imported_modules['CosPropertyService']._Output_Any(_call, pMoreCookie)
	    iluRt.OutputInteger(_call, pNumberItems)
	    iluRt.OutputObjectID(_call, pResultTarget, iluRt.FALSE, CCollection)
	    iluRt.FinishRequest(_call)
	finally:
	    iluRt.FinishCall(_call)

    def AddItems(_self, pMessageID, pItems, pNewMoreCookie):
	_call = iluRt.BeginCall(_self, CCollection._IluClass, 5)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CCollection)\
	      + _imported_modules['CosPropertyService']._SizeOf_Any(_call, pMessageID)\
	      + _SizeOf_TItemsACState(_call, pItems)\
	      + _SizeOf_TAccessCapability(_call, pNewMoreCookie))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CCollection)
	    _imported_modules['CosPropertyService']._Output_Any(_call, pMessageID)
	    _Output_TItemsACState(_call, pItems)
	    _Output_TAccessCapability(_call, pNewMoreCookie)
	    iluRt.FinishRequest(_call)
	finally:
	    iluRt.FinishCall(_call)

    def GetItemsProperties(_self, pPropertyNames, pServerCookies):
	_result = None
	_call = iluRt.BeginCall(_self, CCollection._IluClass, 6)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CCollection)\
	      + _imported_modules['CosPropertyService']._SizeOf_PropertyNames(_call, pPropertyNames)\
	      + _SizeOf_TCookies(_call, pServerCookies))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CCollection)
	    _imported_modules['CosPropertyService']._Output_PropertyNames(_call, pPropertyNames)
	    _Output_TCookies(_call, pServerCookies)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, CCollection._IluClass, _ecode)
	    _result = _Input_TItemsState(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def RequestItemsProperties(_self, pMessageID, pPropertyNames, pServerCookies, pClientCookies, pResultTarget):
	_call = iluRt.BeginCall(_self, CCollection._IluClass, 7)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CCollection)\
	      + _imported_modules['CosPropertyService']._SizeOf_Any(_call, pMessageID)\
	      + _imported_modules['CosPropertyService']._SizeOf_PropertyNames(_call, pPropertyNames)\
	      + _SizeOf_TCookies(_call, pServerCookies)\
	      + _SizeOf_TCookies(_call, pClientCookies)\
	      + iluRt.SizeOfObjectID(_call, pResultTarget, iluRt.FALSE, CCollection))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CCollection)
	    _imported_modules['CosPropertyService']._Output_Any(_call, pMessageID)
	    _imported_modules['CosPropertyService']._Output_PropertyNames(_call, pPropertyNames)
	    _Output_TCookies(_call, pServerCookies)
	    _Output_TCookies(_call, pClientCookies)
	    iluRt.OutputObjectID(_call, pResultTarget, iluRt.FALSE, CCollection)
	    iluRt.FinishRequest(_call)
	finally:
	    iluRt.FinishCall(_call)

    def SetItemsProperties(_self, pMessageID, pItems):
	_call = iluRt.BeginCall(_self, CCollection._IluClass, 8)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CCollection)\
	      + _imported_modules['CosPropertyService']._SizeOf_Any(_call, pMessageID)\
	      + _SizeOf_TItemsCookieState(_call, pItems))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CCollection)
	    _imported_modules['CosPropertyService']._Output_Any(_call, pMessageID)
	    _Output_TItemsCookieState(_call, pItems)
	    iluRt.FinishRequest(_call)
	finally:
	    iluRt.FinishCall(_call)

    def GetItemsPropertyNames(_self, pCookies):
	_result = None
	_call = iluRt.BeginCall(_self, CCollection._IluClass, 9)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CCollection)\
	      + _SizeOf_TCookies(_call, pCookies))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CCollection)
	    _Output_TCookies(_call, pCookies)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, CCollection._IluClass, _ecode)
	    _result = _Input_PropertyNamesList(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def RequestItemsPropertyNames(_self, pMessageID, pCookies, pResultTarget):
	_call = iluRt.BeginCall(_self, CCollection._IluClass, 10)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CCollection)\
	      + _imported_modules['CosPropertyService']._SizeOf_Any(_call, pMessageID)\
	      + _SizeOf_TCookies(_call, pCookies)\
	      + iluRt.SizeOfObjectID(_call, pResultTarget, iluRt.FALSE, CCollection))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CCollection)
	    _imported_modules['CosPropertyService']._Output_Any(_call, pMessageID)
	    _Output_TCookies(_call, pCookies)
	    iluRt.OutputObjectID(_call, pResultTarget, iluRt.FALSE, CCollection)
	    iluRt.FinishRequest(_call)
	finally:
	    iluRt.FinishCall(_call)

    def SetItemsPropertyNames(_self, pMessageID, pNamesList):
	_call = iluRt.BeginCall(_self, CCollection._IluClass, 11)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CCollection)\
	      + _imported_modules['CosPropertyService']._SizeOf_Any(_call, pMessageID)\
	      + _SizeOf_PropertyNamesList(_call, pNamesList))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CCollection)
	    _imported_modules['CosPropertyService']._Output_Any(_call, pMessageID)
	    _Output_PropertyNamesList(_call, pNamesList)
	    iluRt.FinishRequest(_call)
	finally:
	    iluRt.FinishCall(_call)

    def RaiseExceptions(_self, pMessageID, pExceptions):
	_call = iluRt.BeginCall(_self, CCollection._IluClass, 12)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CCollection)\
	      + _imported_modules['CosPropertyService']._SizeOf_Any(_call, pMessageID)\
	      + _SizeOf_TExceptions(_call, pExceptions))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CCollection)
	    _imported_modules['CosPropertyService']._Output_Any(_call, pMessageID)
	    _Output_TExceptions(_call, pExceptions)
	    iluRt.FinishRequest(_call)
	finally:
	    iluRt.FinishCall(_call)

    def RemoveItems(_self, pCookies):
	_call = iluRt.BeginCall(_self, CCollection._IluClass, 13)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CCollection)\
	      + _SizeOf_TCookies(_call, pCookies))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CCollection)
	    _Output_TCookies(_call, pCookies)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, CCollection._IluClass, _ecode)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)

iluRt.RegisterClass(CCollection)

class CConstrainCollection(CCollection):
    _IluClass = iluRt.FormClassRecord(\
	'IDLInterchange.CConstrainCollection',\
	'',\
	'ilu:i1Lrqq7+zj+A8Fyxz1+ab50rRn1',\
	None,\
	iluRt.FALSE,\
	iluRt.TRUE,\
	None,\
	(\
	    ('Constrain', 1, iluRt.FALSE, iluRt.FALSE, (InvalidRequest, InvalidQuery, InvalidAuthenication, InvalidPayment, MultipleExceptions)),\
	    ('RequestConstrain', 2, iluRt.FALSE, iluRt.TRUE, ()),\
	),\
	(CCollection._IluClass,)\
	)

    def Constrain(_self, pQuerySummary, pServicePrefSummary):
	_result = None
	_call = iluRt.BeginCall(_self, CConstrainCollection._IluClass, 1)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CConstrainCollection)\
	      + _SizeOf_TQuerySummary(_call, pQuerySummary)\
	      + _SizeOf_TServicePrefSummary(_call, pServicePrefSummary))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CConstrainCollection)
	    _Output_TQuerySummary(_call, pQuerySummary)
	    _Output_TServicePrefSummary(_call, pServicePrefSummary)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, CConstrainCollection._IluClass, _ecode)
	    _result = _Input_TItemsACState(_call),\
	      iluRt.InputInteger(_call),\
	      _Input_TAccessCapability(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def RequestConstrain(_self, pMessageID, pQuerySummary, pServicePrefSummary, pResultTarget):
	_call = iluRt.BeginCall(_self, CConstrainCollection._IluClass, 2)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CConstrainCollection)\
	      + _imported_modules['CosPropertyService']._SizeOf_Any(_call, pMessageID)\
	      + _SizeOf_TQuerySummary(_call, pQuerySummary)\
	      + _SizeOf_TServicePrefSummary(_call, pServicePrefSummary)\
	      + iluRt.SizeOfObjectID(_call, pResultTarget, iluRt.FALSE, CCollection))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CConstrainCollection)
	    _imported_modules['CosPropertyService']._Output_Any(_call, pMessageID)
	    _Output_TQuerySummary(_call, pQuerySummary)
	    _Output_TServicePrefSummary(_call, pServicePrefSummary)
	    iluRt.OutputObjectID(_call, pResultTarget, iluRt.FALSE, CCollection)
	    iluRt.FinishRequest(_call)
	finally:
	    iluRt.FinishCall(_call)

iluRt.RegisterClass(CConstrainCollection)

class TQuerySummary (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.TQuerySummary'
    def __init__(self, _aQueryObject, _aQueryDescription, _aItemPropertyNames, _aMoreSummary):
        self.aQueryObject = _aQueryObject;
        self.aQueryDescription = _aQueryDescription;
        self.aItemPropertyNames = _aItemPropertyNames;
        self.aMoreSummary = _aMoreSummary;

    def __getinitargs__(self):
      return (self.aQueryObject, self.aQueryDescription, self.aItemPropertyNames, self.aMoreSummary, )

def _Input_TQuerySummary(_call):
    iluRt.InputRecord(_call)
    _value = TQuerySummary (None, None, None, None)
    _value.aQueryObject = iluRt.InputObjectID(_call, iluRt.FALSE, CQuery)
    _value.aQueryDescription = _Input_TQueryDescription(_call)
    _value.aItemPropertyNames = _imported_modules['CosPropertyService']._Input_PropertyNames(_call)
    _value.aMoreSummary = _imported_modules['CosPropertyService']._Input_Properties(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_TQuerySummary(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputObjectID(_call, _value['aQueryObject'], iluRt.FALSE, CQuery)
    _Output_TQueryDescription(_call, _value['aQueryDescription'])
    _imported_modules['CosPropertyService']._Output_PropertyNames(_call, _value['aItemPropertyNames'])
    _imported_modules['CosPropertyService']._Output_Properties(_call, _value['aMoreSummary'])
    iluRt.EndRecord(_call)

def _SizeOf_TQuerySummary(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfObjectID(_call, _value['aQueryObject'], iluRt.FALSE, CQuery)\
      + _SizeOf_TQueryDescription(_call, _value['aQueryDescription'])\
      + _imported_modules['CosPropertyService']._SizeOf_PropertyNames(_call, _value['aItemPropertyNames'])\
      + _imported_modules['CosPropertyService']._SizeOf_Properties(_call, _value['aMoreSummary'])
    iluRt.EndRecord(_call)
    return _size

class CQuery(_imported_modules['CosPropertyService'].PropertySet):
    _IluClass = iluRt.FormClassRecord(\
	'IDLInterchange.CQuery',\
	'',\
	'ilu:lVv2NFRp23Q+2cQKivu+F4DNLs1',\
	None,\
	iluRt.FALSE,\
	iluRt.TRUE,\
	None,\
	(\
	    ('GetSummary', 1, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('GetQueryDescription', 2, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('SetQueryDescription', 3, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('GetItemPropertyNames', 4, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('SetItemPropertyNames', 5, iluRt.FALSE, iluRt.FALSE, ()),\
	),\
	(_imported_modules['CosPropertyService'].PropertySet._IluClass,)\
	)

    def GetSummary(_self):
	_result = None
	_call = iluRt.BeginCall(_self, CQuery._IluClass, 1)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CQuery))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CQuery)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, CQuery._IluClass, _ecode)
	    _result = _Input_TQuerySummary(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def GetQueryDescription(_self):
	_result = None
	_call = iluRt.BeginCall(_self, CQuery._IluClass, 2)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CQuery))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CQuery)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, CQuery._IluClass, _ecode)
	    _result = _Input_TQueryDescription(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def SetQueryDescription(_self, pQueryDescription):
	_call = iluRt.BeginCall(_self, CQuery._IluClass, 3)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CQuery)\
	      + _SizeOf_TQueryDescription(_call, pQueryDescription))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CQuery)
	    _Output_TQueryDescription(_call, pQueryDescription)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, CQuery._IluClass, _ecode)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)

    def GetItemPropertyNames(_self):
	_result = None
	_call = iluRt.BeginCall(_self, CQuery._IluClass, 4)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CQuery))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CQuery)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, CQuery._IluClass, _ecode)
	    _result = _imported_modules['CosPropertyService']._Input_PropertyNames(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def SetItemPropertyNames(_self, pItemPropertyNames):
	_call = iluRt.BeginCall(_self, CQuery._IluClass, 5)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CQuery)\
	      + _imported_modules['CosPropertyService']._SizeOf_PropertyNames(_call, pItemPropertyNames))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CQuery)
	    _imported_modules['CosPropertyService']._Output_PropertyNames(_call, pItemPropertyNames)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, CQuery._IluClass, _ecode)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)

iluRt.RegisterClass(CQuery)

def _Input_TQueryDescription(_call):
    _d = iluRt.InputUnion(_call, 4)
    if _d == 0:
	_value = (_d, _Input_RPNQuery0(_call))
    elif _d == 1:
	_value = (_d, _Input_RPNQuery101(_call))
    else:
	raise TypeError
    iluRt.EndUnion(_call)
    return _value

def _Output_TQueryDescription(_call, _value):
    _d = _value[0]
    iluRt.OutputUnion(_call, _d, 4)
    if _d == 0:
	_Output_RPNQuery0(_call, _value[1])
    elif _d == 1:
	_Output_RPNQuery101(_call, _value[1])
    else:
	raise TypeError
    iluRt.EndUnion(_call)

def _SizeOf_TQueryDescription(_call, _value):
    _d = _value[0]
    _size = iluRt.SizeOfUnion(_call, _d, 4)
    if _d == 0:
	_size = _size + _SizeOf_RPNQuery0(_call, _value[1])
    elif _d == 1:
	_size = _size + _SizeOf_RPNQuery101(_call, _value[1])
    else:
	raise TypeError
    iluRt.EndUnion(_call)
    return _size

class QueryType:
    kQTYPE0 = 0;
    kQTYPE101 = 1;
    __image__ = {
          kQTYPE0 : 'kQTYPE0',
          kQTYPE101 : 'kQTYPE101'}

class RPNQuery0 (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.RPNQuery0'
    def __init__(self, _querytype, _query):
        self.querytype = _querytype;
        self.query = _query;

    def __getinitargs__(self):
      return (self.querytype, self.query, )

def _Input_RPNQuery0(_call):
    iluRt.InputRecord(_call)
    _value = RPNQuery0 (None, None)
    _value.querytype = iluRt.InputInteger(_call)
    _value.query = _imported_modules['CosPropertyService']._Input_Any(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_RPNQuery0(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputInteger(_call, _value['querytype'])
    _imported_modules['CosPropertyService']._Output_Any(_call, _value['query'])
    iluRt.EndRecord(_call)

def _SizeOf_RPNQuery0(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfInteger(_call, _value['querytype'])\
      + _imported_modules['CosPropertyService']._SizeOf_Any(_call, _value['query'])
    iluRt.EndRecord(_call)
    return _size

class RPNQuery101 (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.RPNQuery101'
    def __init__(self, _attributeSetId, _rpn):
        self.attributeSetId = _attributeSetId;
        self.rpn = _rpn;

    def __getinitargs__(self):
      return (self.attributeSetId, self.rpn, )

def _Input_RPNQuery101(_call):
    iluRt.InputRecord(_call)
    _value = RPNQuery101 (None, None)
    _value.attributeSetId = iluRt.InputCardinal(_call)
    _value.rpn = _Input_RPNStructure(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_RPNQuery101(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputCardinal(_call, _value['attributeSetId'])
    _Output_RPNStructure(_call, _value['rpn'])
    iluRt.EndRecord(_call)

def _SizeOf_RPNQuery101(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfCardinal(_call, _value['attributeSetId'])\
      + _SizeOf_RPNStructure(_call, _value['rpn'])
    iluRt.EndRecord(_call)
    return _size

class RPNStructure_RPNNode (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.RPNStructure-RPNNode'
    def __init__(self, _op, _operands):
        self.op = _op;
        self.operands = _operands;

    def __getinitargs__(self):
      return (self.op, self.operands, )

def _Input_RPNStructure_RPNNode(_call):
    iluRt.InputRecord(_call)
    _value = RPNStructure_RPNNode (None, None)
    _value.op = _Input_RPNOperator(_call)
    _value.operands = _Input_AnonType_1_(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_RPNStructure_RPNNode(_call, _value):
    iluRt.OutputRecord(_call)
    _Output_RPNOperator(_call, _value['op'])
    _Output_AnonType_1_(_call, _value['operands'])
    iluRt.EndRecord(_call)

def _SizeOf_RPNStructure_RPNNode(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + _SizeOf_RPNOperator(_call, _value['op'])\
      + _SizeOf_AnonType_1_(_call, _value['operands'])
    iluRt.EndRecord(_call)
    return _size

def _Input_AnonType_1_(_call):
    _length = iluRt.InputSequence(_call, 0)
    _value = []
    for _i in range(0, _length):
        _value.append(_Input_RPNStructure(_call))
    iluRt.EndSequence(_call)
    return _value

def _Output_AnonType_1_(_call, _value):
    iluRt.OutputSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _Output_RPNStructure(_call, _value[_i])
    iluRt.EndSequence(_call)

def _SizeOf_AnonType_1_(_call, _value):
    _size = iluRt.SizeOfSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _size = _size + _SizeOf_RPNStructure(_call, _value[_i])
    iluRt.EndSequence(_call)
    return _size

def _Input_RPNStructure(_call):
    _d = iluRt.InputUnion(_call, 4)
    if _d == 1:
	_value = (_d, _Input_RPNOperand(_call))
    elif _d == 0:
	_value = (_d, _Input_RPNStructure_RPNNode(_call))
    else:
	raise TypeError
    iluRt.EndUnion(_call)
    return _value

def _Output_RPNStructure(_call, _value):
    _d = _value[0]
    iluRt.OutputUnion(_call, _d, 4)
    if _d == 1:
	_Output_RPNOperand(_call, _value[1])
    elif _d == 0:
	_Output_RPNStructure_RPNNode(_call, _value[1])
    else:
	raise TypeError
    iluRt.EndUnion(_call)

def _SizeOf_RPNStructure(_call, _value):
    _d = _value[0]
    _size = iluRt.SizeOfUnion(_call, _d, 4)
    if _d == 1:
	_size = _size + _SizeOf_RPNOperand(_call, _value[1])
    elif _d == 0:
	_size = _size + _SizeOf_RPNStructure_RPNNode(_call, _value[1])
    else:
	raise TypeError
    iluRt.EndUnion(_call)
    return _size

class RPNStructureKey:
    kRPNTREE = 0;
    kRPNLEAF = 1;
    __image__ = {
          kRPNTREE : 'kRPNTREE',
          kRPNLEAF : 'kRPNLEAF'}

def _Input_RPNOperand(_call):
    _d = iluRt.InputUnion(_call, 4)
    if _d == 0:
	_value = (_d, _Input_RPNTerm(_call))
    elif _d == 1:
	_value = (_d, iluRt.InputObjectID(_call, iluRt.FALSE, CCollection))
    elif _d == 2:
	_value = (_d, _Input_RPNAttributeList(_call))
    else:
	raise TypeError
    iluRt.EndUnion(_call)
    return _value

def _Output_RPNOperand(_call, _value):
    _d = _value[0]
    iluRt.OutputUnion(_call, _d, 4)
    if _d == 0:
	_Output_RPNTerm(_call, _value[1])
    elif _d == 1:
	iluRt.OutputObjectID(_call, _value[1], iluRt.FALSE, CCollection)
    elif _d == 2:
	_Output_RPNAttributeList(_call, _value[1])
    else:
	raise TypeError
    iluRt.EndUnion(_call)

def _SizeOf_RPNOperand(_call, _value):
    _d = _value[0]
    _size = iluRt.SizeOfUnion(_call, _d, 4)
    if _d == 0:
	_size = _size + _SizeOf_RPNTerm(_call, _value[1])
    elif _d == 1:
	_size = _size + iluRt.SizeOfObjectID(_call, _value[1], iluRt.FALSE, CCollection)
    elif _d == 2:
	_size = _size + _SizeOf_RPNAttributeList(_call, _value[1])
    else:
	raise TypeError
    iluRt.EndUnion(_call)
    return _size

class RPNOperandKey:
    kRPNTERM = 0;
    kRPNCOLLECTION = 1;
    kRPNATTRIBUTE = 2;
    __image__ = {
          kRPNTERM : 'kRPNTERM',
          kRPNCOLLECTION : 'kRPNCOLLECTION',
          kRPNATTRIBUTE : 'kRPNATTRIBUTE'}

class RPNTerm (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.RPNTerm'
    def __init__(self, _term, _attributes):
        self.term = _term;
        self.attributes = _attributes;

    def __getinitargs__(self):
      return (self.term, self.attributes, )

def _Input_RPNTerm(_call):
    iluRt.InputRecord(_call)
    _value = RPNTerm (None, None)
    _value.term = _Input_RPNTermValue(_call)
    _value.attributes = _Input_RPNAttributeList(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_RPNTerm(_call, _value):
    iluRt.OutputRecord(_call)
    _Output_RPNTermValue(_call, _value['term'])
    _Output_RPNAttributeList(_call, _value['attributes'])
    iluRt.EndRecord(_call)

def _SizeOf_RPNTerm(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + _SizeOf_RPNTermValue(_call, _value['term'])\
      + _SizeOf_RPNAttributeList(_call, _value['attributes'])
    iluRt.EndRecord(_call)
    return _size

def _Input_RPNTermValue(_call):
    _d = iluRt.InputUnion(_call, 4)
    if _d == 0:
	_value = (_d, iluRt.InputString(_call, 0))
    elif _d == 1:
	_value = (_d, iluRt.InputInteger(_call))
    elif _d == 2:
	_value = (_d, iluRt.InputReal(_call))
    else:
	raise TypeError
    iluRt.EndUnion(_call)
    return _value

def _Output_RPNTermValue(_call, _value):
    _d = _value[0]
    iluRt.OutputUnion(_call, _d, 4)
    if _d == 0:
	iluRt.OutputString(_call, _value[1], 0)
    elif _d == 1:
	iluRt.OutputInteger(_call, _value[1])
    elif _d == 2:
	iluRt.OutputReal(_call, _value[1])
    else:
	raise TypeError
    iluRt.EndUnion(_call)

def _SizeOf_RPNTermValue(_call, _value):
    _d = _value[0]
    _size = iluRt.SizeOfUnion(_call, _d, 4)
    if _d == 0:
	_size = _size + iluRt.SizeOfString(_call, _value[1], 0)
    elif _d == 1:
	_size = _size + iluRt.SizeOfInteger(_call, _value[1])
    elif _d == 2:
	_size = _size + iluRt.SizeOfReal(_call, _value[1])
    else:
	raise TypeError
    iluRt.EndUnion(_call)
    return _size

class RPNTermValueKey:
    kRPN_STRING = 0;
    kRPN_NUMERIC = 1;
    kRPN_REAL = 2;
    __image__ = {
          kRPN_STRING : 'kRPN_STRING',
          kRPN_NUMERIC : 'kRPN_NUMERIC',
          kRPN_REAL : 'kRPN_REAL'}

def _Input_RPNOperator(_call):
    _d = iluRt.InputUnion(_call, 4)
    if _d == 0:
	_value = (_d, iluRt.InputEnum(_call))
    elif _d == 1:
	_value = (_d, _Input_RPNProximityOperator(_call))
    elif _d == 2:
	_value = (_d, iluRt.InputEnum(_call))
    else:
	raise TypeError
    iluRt.EndUnion(_call)
    return _value

def _Output_RPNOperator(_call, _value):
    _d = _value[0]
    iluRt.OutputUnion(_call, _d, 4)
    if _d == 0:
	iluRt.OutputEnum(_call, _value[1])
    elif _d == 1:
	_Output_RPNProximityOperator(_call, _value[1])
    elif _d == 2:
	iluRt.OutputEnum(_call, _value[1])
    else:
	raise TypeError
    iluRt.EndUnion(_call)

def _SizeOf_RPNOperator(_call, _value):
    _d = _value[0]
    _size = iluRt.SizeOfUnion(_call, _d, 4)
    if _d == 0:
	_size = _size + iluRt.SizeOfEnum(_call, _value[1])
    elif _d == 1:
	_size = _size + _SizeOf_RPNProximityOperator(_call, _value[1])
    elif _d == 2:
	_size = _size + iluRt.SizeOfEnum(_call, _value[1])
    else:
	raise TypeError
    iluRt.EndUnion(_call)
    return _size

class RPNOperatorKey:
    kRPN_BOOLEAN = 0;
    kRPN_PROXIMITY = 1;
    kRPN_RELATION = 2;
    __image__ = {
          kRPN_BOOLEAN : 'kRPN_BOOLEAN',
          kRPN_PROXIMITY : 'kRPN_PROXIMITY',
          kRPN_RELATION : 'kRPN_RELATION'}

class RPNBooleanOperator:
    kRPN_AND = 0;
    kRPN_OR = 1;
    kRPN_NOT = 2;
    __image__ = {
          kRPN_AND : 'kRPN_AND',
          kRPN_OR : 'kRPN_OR',
          kRPN_NOT : 'kRPN_NOT'}

class RPNRelationOperator:
    kRPN_LESSTHAN = 0;
    kRPN_LESSTHANOREQUAL = 1;
    kRPN_EQUAL = 2;
    kRPN_GREATERTHANOREQUAL = 3;
    kRPN_GREATERTHAN = 4;
    kRPN_NOTEQUAL = 5;
    kRPN_PHONETIC = 6;
    kRPN_STEM = 7;
    kRPN_RELEVANCE = 8;
    kRPN_ALWAYSMATCHES = 9;
    kRPN_CONTAINS = 10;
    __image__ = {
          kRPN_LESSTHAN : 'kRPN_LESSTHAN',
          kRPN_LESSTHANOREQUAL : 'kRPN_LESSTHANOREQUAL',
          kRPN_EQUAL : 'kRPN_EQUAL',
          kRPN_GREATERTHANOREQUAL : 'kRPN_GREATERTHANOREQUAL',
          kRPN_GREATERTHAN : 'kRPN_GREATERTHAN',
          kRPN_NOTEQUAL : 'kRPN_NOTEQUAL',
          kRPN_PHONETIC : 'kRPN_PHONETIC',
          kRPN_STEM : 'kRPN_STEM',
          kRPN_RELEVANCE : 'kRPN_RELEVANCE',
          kRPN_ALWAYSMATCHES : 'kRPN_ALWAYSMATCHES',
          kRPN_CONTAINS : 'kRPN_CONTAINS'}

def _Input_RPNAttributeList(_call):
    _length = iluRt.InputSequence(_call, 0)
    _value = []
    for _i in range(0, _length):
        _value.append(_Input_RPNAttributeElement(_call))
    iluRt.EndSequence(_call)
    return _value

def _Output_RPNAttributeList(_call, _value):
    iluRt.OutputSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _Output_RPNAttributeElement(_call, _value[_i])
    iluRt.EndSequence(_call)

def _SizeOf_RPNAttributeList(_call, _value):
    _size = iluRt.SizeOfSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _size = _size + _SizeOf_RPNAttributeElement(_call, _value[_i])
    iluRt.EndSequence(_call)
    return _size

class RPNAttributeElement (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.RPNAttributeElement'
    def __init__(self, _aAttributeSet, _aType, _aValue):
        self.aAttributeSet = _aAttributeSet;
        self.aType = _aType;
        self.aValue = _aValue;

    def __getinitargs__(self):
      return (self.aAttributeSet, self.aType, self.aValue, )

def _Input_RPNAttributeElement(_call):
    iluRt.InputRecord(_call)
    _value = RPNAttributeElement (None, None, None)
    _value.aAttributeSet = iluRt.InputCardinal(_call)
    _value.aType = iluRt.InputCardinal(_call)
    _value.aValue = iluRt.InputCardinal(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_RPNAttributeElement(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputCardinal(_call, _value['aAttributeSet'])
    iluRt.OutputCardinal(_call, _value['aType'])
    iluRt.OutputCardinal(_call, _value['aValue'])
    iluRt.EndRecord(_call)

def _SizeOf_RPNAttributeElement(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfCardinal(_call, _value['aAttributeSet'])\
      + iluRt.SizeOfCardinal(_call, _value['aType'])\
      + iluRt.SizeOfCardinal(_call, _value['aValue'])
    iluRt.EndRecord(_call)
    return _size

class RPNProximityOperator (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.RPNProximityOperator'
    def __init__(self, _exclusion, _distance, _ordered, _relationType, _unitcode):
        self.exclusion = _exclusion;
        self.distance = _distance;
        self.ordered = _ordered;
        self.relationType = _relationType;
        self.unitcode = _unitcode;

    def __getinitargs__(self):
      return (self.exclusion, self.distance, self.ordered, self.relationType, self.unitcode, )

def _Input_RPNProximityOperator(_call):
    iluRt.InputRecord(_call)
    _value = RPNProximityOperator (None, None, None, None, None)
    _value.exclusion = iluRt.InputBoolean(_call)
    _value.distance = iluRt.InputShortInteger(_call)
    _value.ordered = iluRt.InputBoolean(_call)
    _value.relationType = iluRt.InputEnum(_call)
    _value.unitcode = iluRt.InputEnum(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_RPNProximityOperator(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputBoolean(_call, _value['exclusion'])
    iluRt.OutputShortInteger(_call, _value['distance'])
    iluRt.OutputBoolean(_call, _value['ordered'])
    iluRt.OutputEnum(_call, _value['relationType'])
    iluRt.OutputEnum(_call, _value['unitcode'])
    iluRt.EndRecord(_call)

def _SizeOf_RPNProximityOperator(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfBoolean(_call, _value['exclusion'])\
      + iluRt.SizeOfShortInteger(_call, _value['distance'])\
      + iluRt.SizeOfBoolean(_call, _value['ordered'])\
      + iluRt.SizeOfEnum(_call, _value['relationType'])\
      + iluRt.SizeOfEnum(_call, _value['unitcode'])
    iluRt.EndRecord(_call)
    return _size

class RPNProximityUnitCode:
    kRPN_CHARACTER = 0;
    kRPN_WORD = 1;
    kRPN_SENTENCE = 2;
    kRPN_PARAGRAPH = 3;
    kRPN_SECTION = 4;
    kRPN_CHAPTER = 5;
    kRPN_DOCUMENT = 6;
    kRPN_ELEMENT = 7;
    kELEMENT = 8;
    kRPN_SUBELEMENT = 9;
    kRPN_ELEMENTTYPE = 10;
    kRPN_BYTE = 11;
    __image__ = {
          kRPN_CHARACTER : 'kRPN_CHARACTER',
          kRPN_WORD : 'kRPN_WORD',
          kRPN_SENTENCE : 'kRPN_SENTENCE',
          kRPN_PARAGRAPH : 'kRPN_PARAGRAPH',
          kRPN_SECTION : 'kRPN_SECTION',
          kRPN_CHAPTER : 'kRPN_CHAPTER',
          kRPN_DOCUMENT : 'kRPN_DOCUMENT',
          kRPN_ELEMENT : 'kRPN_ELEMENT',
          kELEMENT : 'kELEMENT',
          kRPN_SUBELEMENT : 'kRPN_SUBELEMENT',
          kRPN_ELEMENTTYPE : 'kRPN_ELEMENTTYPE',
          kRPN_BYTE : 'kRPN_BYTE'}

class RPNNumericRelationType:
    kRPN_PROX_LESSTHAN = 0;
    kRPN_PROX_LESSTHANOREQUAL = 1;
    kRPN_PROX_EQUAL = 2;
    kRPN_PROX_GREATERTHANOREQUAL = 3;
    kRPN_PROX_GREATERTHAN = 4;
    kRPN_PROX_NOTEQUAL = 5;
    __image__ = {
          kRPN_PROX_LESSTHAN : 'kRPN_PROX_LESSTHAN',
          kRPN_PROX_LESSTHANOREQUAL : 'kRPN_PROX_LESSTHANOREQUAL',
          kRPN_PROX_EQUAL : 'kRPN_PROX_EQUAL',
          kRPN_PROX_GREATERTHANOREQUAL : 'kRPN_PROX_GREATERTHANOREQUAL',
          kRPN_PROX_GREATERTHAN : 'kRPN_PROX_GREATERTHAN',
          kRPN_PROX_NOTEQUAL : 'kRPN_PROX_NOTEQUAL'}

class TServicePrefSummary (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.TServicePrefSummary'
    def __init__(self, _aServicePreferences, _aNumberOfItems, _aMoreSummary):
        self.aServicePreferences = _aServicePreferences;
        self.aNumberOfItems = _aNumberOfItems;
        self.aMoreSummary = _aMoreSummary;

    def __getinitargs__(self):
      return (self.aServicePreferences, self.aNumberOfItems, self.aMoreSummary, )

def _Input_TServicePrefSummary(_call):
    iluRt.InputRecord(_call)
    _value = TServicePrefSummary (None, None, None)
    _value.aServicePreferences = iluRt.InputObjectID(_call, iluRt.FALSE, CServicePreferences)
    _value.aNumberOfItems = iluRt.InputInteger(_call)
    _value.aMoreSummary = _imported_modules['CosPropertyService']._Input_Properties(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_TServicePrefSummary(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputObjectID(_call, _value['aServicePreferences'], iluRt.FALSE, CServicePreferences)
    iluRt.OutputInteger(_call, _value['aNumberOfItems'])
    _imported_modules['CosPropertyService']._Output_Properties(_call, _value['aMoreSummary'])
    iluRt.EndRecord(_call)

def _SizeOf_TServicePrefSummary(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfObjectID(_call, _value['aServicePreferences'], iluRt.FALSE, CServicePreferences)\
      + iluRt.SizeOfInteger(_call, _value['aNumberOfItems'])\
      + _imported_modules['CosPropertyService']._SizeOf_Properties(_call, _value['aMoreSummary'])
    iluRt.EndRecord(_call)
    return _size

class CServicePreferences(_imported_modules['CosPropertyService'].PropertySet):
    _IluClass = iluRt.FormClassRecord(\
	'IDLInterchange.CServicePreferences',\
	'',\
	'ilu:gELOzGDfs-LA0Pe+SJx0nKr1+vo',\
	None,\
	iluRt.FALSE,\
	iluRt.TRUE,\
	None,\
	(\
	    ('GetSummary', 1, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('GetNumberOfItems', 2, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('SetNumberOfItems', 3, iluRt.FALSE, iluRt.FALSE, ()),\
	),\
	(_imported_modules['CosPropertyService'].PropertySet._IluClass,)\
	)

    def GetSummary(_self):
	_result = None
	_call = iluRt.BeginCall(_self, CServicePreferences._IluClass, 1)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CServicePreferences))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CServicePreferences)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, CServicePreferences._IluClass, _ecode)
	    _result = _Input_TServicePrefSummary(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def GetNumberOfItems(_self):
	_result = None
	_call = iluRt.BeginCall(_self, CServicePreferences._IluClass, 2)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CServicePreferences))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CServicePreferences)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, CServicePreferences._IluClass, _ecode)
	    _result = iluRt.InputInteger(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def SetNumberOfItems(_self, pNumberOfItems):
	_call = iluRt.BeginCall(_self, CServicePreferences._IluClass, 3)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, CServicePreferences)\
	      + iluRt.SizeOfInteger(_call, pNumberOfItems))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, CServicePreferences)
	    iluRt.OutputInteger(_call, pNumberOfItems)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, CServicePreferences._IluClass, _ecode)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)

iluRt.RegisterClass(CServicePreferences)

class R_MultipleExceptions (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.R-MultipleExceptions'
    def __init__(self, _aExceptions):
        self.aExceptions = _aExceptions;

    def __getinitargs__(self):
      return (self.aExceptions, )

def _Input_R_MultipleExceptions(_call):
    iluRt.InputRecord(_call)
    _value = R_MultipleExceptions (None)
    _value.aExceptions = _Input_TExceptions(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_R_MultipleExceptions(_call, _value):
    iluRt.OutputRecord(_call)
    _Output_TExceptions(_call, _value['aExceptions'])
    iluRt.EndRecord(_call)

def _SizeOf_R_MultipleExceptions(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + _SizeOf_TExceptions(_call, _value['aExceptions'])
    iluRt.EndRecord(_call)
    return _size

def _Input_TExceptions(_call):
    _length = iluRt.InputSequence(_call, 0)
    _value = []
    for _i in range(0, _length):
        _value.append(_Input_TException(_call))
    iluRt.EndSequence(_call)
    return _value

def _Output_TExceptions(_call, _value):
    iluRt.OutputSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _Output_TException(_call, _value[_i])
    iluRt.EndSequence(_call)

def _SizeOf_TExceptions(_call, _value):
    _size = iluRt.SizeOfSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _size = _size + _SizeOf_TException(_call, _value[_i])
    iluRt.EndSequence(_call)
    return _size

def _Input_TException(_call):
    _d = iluRt.InputUnion(_call, 4)
    if _d == 0:
	_value = (_d, iluRt.InputString(_call, 0))
    elif _d == 1:
	_value = (_d, iluRt.InputString(_call, 0))
    elif _d == 2:
	_value = (_d, iluRt.InputString(_call, 0))
    elif _d == 3:
	_value = (_d, iluRt.InputString(_call, 0))
    elif _d == 4:
	_value = (_d, _imported_modules['CosPropertyService']._Input_PropertyNames(_call))
    elif _d == 6:
	_value = (_d, _Input_TCookies(_call))
    elif _d == 7:
	_value = (_d, iluRt.InputString(_call, 0))
    elif _d == 8:
	_value = (_d, iluRt.InputString(_call, 0))
    else:
	_value = (_d, None)
    iluRt.EndUnion(_call)
    return _value

def _Output_TException(_call, _value):
    _d = _value[0]
    iluRt.OutputUnion(_call, _d, 4)
    if _d == 0:
	iluRt.OutputString(_call, _value[1], 0)
    elif _d == 1:
	iluRt.OutputString(_call, _value[1], 0)
    elif _d == 2:
	iluRt.OutputString(_call, _value[1], 0)
    elif _d == 3:
	iluRt.OutputString(_call, _value[1], 0)
    elif _d == 4:
	_imported_modules['CosPropertyService']._Output_PropertyNames(_call, _value[1])
    elif _d == 6:
	_Output_TCookies(_call, _value[1])
    elif _d == 7:
	iluRt.OutputString(_call, _value[1], 0)
    elif _d == 8:
	iluRt.OutputString(_call, _value[1], 0)
    else:
	pass
    iluRt.EndUnion(_call)

def _SizeOf_TException(_call, _value):
    _d = _value[0]
    _size = iluRt.SizeOfUnion(_call, _d, 4)
    if _d == 0:
	_size = _size + iluRt.SizeOfString(_call, _value[1], 0)
    elif _d == 1:
	_size = _size + iluRt.SizeOfString(_call, _value[1], 0)
    elif _d == 2:
	_size = _size + iluRt.SizeOfString(_call, _value[1], 0)
    elif _d == 3:
	_size = _size + iluRt.SizeOfString(_call, _value[1], 0)
    elif _d == 4:
	_size = _size + _imported_modules['CosPropertyService']._SizeOf_PropertyNames(_call, _value[1])
    elif _d == 6:
	_size = _size + _SizeOf_TCookies(_call, _value[1])
    elif _d == 7:
	_size = _size + iluRt.SizeOfString(_call, _value[1], 0)
    elif _d == 8:
	_size = _size + iluRt.SizeOfString(_call, _value[1], 0)
    else:
	pass
    iluRt.EndUnion(_call)
    return _size

class EExceptionReason:
    kInvalidRequest = 0;
    kInvalidQuery = 1;
    kInvalidAuthenication = 2;
    kInvalidPayment = 3;
    kInvalidProperties = 4;
    kInvalidMoreCookie = 5;
    kInvalidCookies = 6;
    kUnableToCompleteRequest = 7;
    kInvalidMessageID = 8;
    __image__ = {
          kInvalidRequest : 'kInvalidRequest',
          kInvalidQuery : 'kInvalidQuery',
          kInvalidAuthenication : 'kInvalidAuthenication',
          kInvalidPayment : 'kInvalidPayment',
          kInvalidProperties : 'kInvalidProperties',
          kInvalidMoreCookie : 'kInvalidMoreCookie',
          kInvalidCookies : 'kInvalidCookies',
          kUnableToCompleteRequest : 'kUnableToCompleteRequest',
          kInvalidMessageID : 'kInvalidMessageID'}

class R_InvalidMessageID (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.R-InvalidMessageID'
    def __init__(self, _aReason):
        self.aReason = _aReason;

    def __getinitargs__(self):
      return (self.aReason, )

def _Input_R_InvalidMessageID(_call):
    iluRt.InputRecord(_call)
    _value = R_InvalidMessageID (None)
    _value.aReason = iluRt.InputString(_call, 0)
    iluRt.EndRecord(_call)
    return _value

def _Output_R_InvalidMessageID(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputString(_call, _value['aReason'], 0)
    iluRt.EndRecord(_call)

def _SizeOf_R_InvalidMessageID(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfString(_call, _value['aReason'], 0)
    iluRt.EndRecord(_call)
    return _size

class R_InvalidCookies (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.R-InvalidCookies'
    def __init__(self, _aCookies):
        self.aCookies = _aCookies;

    def __getinitargs__(self):
      return (self.aCookies, )

def _Input_R_InvalidCookies(_call):
    iluRt.InputRecord(_call)
    _value = R_InvalidCookies (None)
    _value.aCookies = _Input_TCookies(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_R_InvalidCookies(_call, _value):
    iluRt.OutputRecord(_call)
    _Output_TCookies(_call, _value['aCookies'])
    iluRt.EndRecord(_call)

def _SizeOf_R_InvalidCookies(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + _SizeOf_TCookies(_call, _value['aCookies'])
    iluRt.EndRecord(_call)
    return _size

class R_InvalidProperties (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.R-InvalidProperties'
    def __init__(self, _aPropertyNames):
        self.aPropertyNames = _aPropertyNames;

    def __getinitargs__(self):
      return (self.aPropertyNames, )

def _Input_R_InvalidProperties(_call):
    iluRt.InputRecord(_call)
    _value = R_InvalidProperties (None)
    _value.aPropertyNames = _imported_modules['CosPropertyService']._Input_PropertyNames(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_R_InvalidProperties(_call, _value):
    iluRt.OutputRecord(_call)
    _imported_modules['CosPropertyService']._Output_PropertyNames(_call, _value['aPropertyNames'])
    iluRt.EndRecord(_call)

def _SizeOf_R_InvalidProperties(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + _imported_modules['CosPropertyService']._SizeOf_PropertyNames(_call, _value['aPropertyNames'])
    iluRt.EndRecord(_call)
    return _size

class R_UnableToCompleteRequest (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.R-UnableToCompleteRequest'
    def __init__(self, _aReason):
        self.aReason = _aReason;

    def __getinitargs__(self):
      return (self.aReason, )

def _Input_R_UnableToCompleteRequest(_call):
    iluRt.InputRecord(_call)
    _value = R_UnableToCompleteRequest (None)
    _value.aReason = iluRt.InputString(_call, 0)
    iluRt.EndRecord(_call)
    return _value

def _Output_R_UnableToCompleteRequest(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputString(_call, _value['aReason'], 0)
    iluRt.EndRecord(_call)

def _SizeOf_R_UnableToCompleteRequest(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfString(_call, _value['aReason'], 0)
    iluRt.EndRecord(_call)
    return _size

class R_InvalidPayment (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.R-InvalidPayment'
    def __init__(self, _aReason):
        self.aReason = _aReason;

    def __getinitargs__(self):
      return (self.aReason, )

def _Input_R_InvalidPayment(_call):
    iluRt.InputRecord(_call)
    _value = R_InvalidPayment (None)
    _value.aReason = iluRt.InputString(_call, 0)
    iluRt.EndRecord(_call)
    return _value

def _Output_R_InvalidPayment(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputString(_call, _value['aReason'], 0)
    iluRt.EndRecord(_call)

def _SizeOf_R_InvalidPayment(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfString(_call, _value['aReason'], 0)
    iluRt.EndRecord(_call)
    return _size

class R_InvalidAuthenication (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.R-InvalidAuthenication'
    def __init__(self, _aReason):
        self.aReason = _aReason;

    def __getinitargs__(self):
      return (self.aReason, )

def _Input_R_InvalidAuthenication(_call):
    iluRt.InputRecord(_call)
    _value = R_InvalidAuthenication (None)
    _value.aReason = iluRt.InputString(_call, 0)
    iluRt.EndRecord(_call)
    return _value

def _Output_R_InvalidAuthenication(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputString(_call, _value['aReason'], 0)
    iluRt.EndRecord(_call)

def _SizeOf_R_InvalidAuthenication(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfString(_call, _value['aReason'], 0)
    iluRt.EndRecord(_call)
    return _size

class R_InvalidQuery (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.R-InvalidQuery'
    def __init__(self, _aReason):
        self.aReason = _aReason;

    def __getinitargs__(self):
      return (self.aReason, )

def _Input_R_InvalidQuery(_call):
    iluRt.InputRecord(_call)
    _value = R_InvalidQuery (None)
    _value.aReason = iluRt.InputString(_call, 0)
    iluRt.EndRecord(_call)
    return _value

def _Output_R_InvalidQuery(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputString(_call, _value['aReason'], 0)
    iluRt.EndRecord(_call)

def _SizeOf_R_InvalidQuery(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfString(_call, _value['aReason'], 0)
    iluRt.EndRecord(_call)
    return _size

class R_InvalidRequest (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.R-InvalidRequest'
    def __init__(self, _aReason):
        self.aReason = _aReason;

    def __getinitargs__(self):
      return (self.aReason, )

def _Input_R_InvalidRequest(_call):
    iluRt.InputRecord(_call)
    _value = R_InvalidRequest (None)
    _value.aReason = iluRt.InputString(_call, 0)
    iluRt.EndRecord(_call)
    return _value

def _Output_R_InvalidRequest(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputString(_call, _value['aReason'], 0)
    iluRt.EndRecord(_call)

def _SizeOf_R_InvalidRequest(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfString(_call, _value['aReason'], 0)
    iluRt.EndRecord(_call)
    return _size

class TItemsACState (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.TItemsACState'
    def __init__(self, _aACs, _aState):
        self.aACs = _aACs;
        self.aState = _aState;

    def __getinitargs__(self):
      return (self.aACs, self.aState, )

def _Input_TItemsACState(_call):
    iluRt.InputRecord(_call)
    _value = TItemsACState (None, None)
    _value.aACs = _Input_TAccessCapabilities(_call)
    _value.aState = _Input_TItemsState(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_TItemsACState(_call, _value):
    iluRt.OutputRecord(_call)
    _Output_TAccessCapabilities(_call, _value['aACs'])
    _Output_TItemsState(_call, _value['aState'])
    iluRt.EndRecord(_call)

def _SizeOf_TItemsACState(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + _SizeOf_TAccessCapabilities(_call, _value['aACs'])\
      + _SizeOf_TItemsState(_call, _value['aState'])
    iluRt.EndRecord(_call)
    return _size

class TItemsCookieState (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.TItemsCookieState'
    def __init__(self, _aClientCookies, _aStates):
        self.aClientCookies = _aClientCookies;
        self.aStates = _aStates;

    def __getinitargs__(self):
      return (self.aClientCookies, self.aStates, )

def _Input_TItemsCookieState(_call):
    iluRt.InputRecord(_call)
    _value = TItemsCookieState (None, None)
    _value.aClientCookies = _Input_TCookies(_call)
    _value.aStates = _Input_TItemsState(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_TItemsCookieState(_call, _value):
    iluRt.OutputRecord(_call)
    _Output_TCookies(_call, _value['aClientCookies'])
    _Output_TItemsState(_call, _value['aStates'])
    iluRt.EndRecord(_call)

def _SizeOf_TItemsCookieState(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + _SizeOf_TCookies(_call, _value['aClientCookies'])\
      + _SizeOf_TItemsState(_call, _value['aStates'])
    iluRt.EndRecord(_call)
    return _size

class TItemsState (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.TItemsState'
    def __init__(self, _aNames, _anItemsState):
        self.aNames = _aNames;
        self.anItemsState = _anItemsState;

    def __getinitargs__(self):
      return (self.aNames, self.anItemsState, )

def _Input_TItemsState(_call):
    iluRt.InputRecord(_call)
    _value = TItemsState (None, None)
    _value.aNames = _imported_modules['CosPropertyService']._Input_PropertyNames(_call)
    _value.anItemsState = _Input_TPropertyValuesList(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_TItemsState(_call, _value):
    iluRt.OutputRecord(_call)
    _imported_modules['CosPropertyService']._Output_PropertyNames(_call, _value['aNames'])
    _Output_TPropertyValuesList(_call, _value['anItemsState'])
    iluRt.EndRecord(_call)

def _SizeOf_TItemsState(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + _imported_modules['CosPropertyService']._SizeOf_PropertyNames(_call, _value['aNames'])\
      + _SizeOf_TPropertyValuesList(_call, _value['anItemsState'])
    iluRt.EndRecord(_call)
    return _size

def _Input_PropertyNamesList(_call):
    _length = iluRt.InputSequence(_call, 0)
    _value = []
    for _i in range(0, _length):
        _value.append(_imported_modules['CosPropertyService']._Input_PropertyNames(_call))
    iluRt.EndSequence(_call)
    return _value

def _Output_PropertyNamesList(_call, _value):
    iluRt.OutputSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _imported_modules['CosPropertyService']._Output_PropertyNames(_call, _value[_i])
    iluRt.EndSequence(_call)

def _SizeOf_PropertyNamesList(_call, _value):
    _size = iluRt.SizeOfSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _size = _size + _imported_modules['CosPropertyService']._SizeOf_PropertyNames(_call, _value[_i])
    iluRt.EndSequence(_call)
    return _size

def _Input_TPropertyValuesList(_call):
    _length = iluRt.InputSequence(_call, 0)
    _value = []
    for _i in range(0, _length):
        _value.append(_Input_TPropertyValues(_call))
    iluRt.EndSequence(_call)
    return _value

def _Output_TPropertyValuesList(_call, _value):
    iluRt.OutputSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _Output_TPropertyValues(_call, _value[_i])
    iluRt.EndSequence(_call)

def _SizeOf_TPropertyValuesList(_call, _value):
    _size = iluRt.SizeOfSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _size = _size + _SizeOf_TPropertyValues(_call, _value[_i])
    iluRt.EndSequence(_call)
    return _size

def _Input_TPropertyValues(_call):
    _length = iluRt.InputSequence(_call, 0)
    _value = []
    for _i in range(0, _length):
        _value.append(_imported_modules['CosPropertyService']._Input_Any(_call))
    iluRt.EndSequence(_call)
    return _value

def _Output_TPropertyValues(_call, _value):
    iluRt.OutputSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _imported_modules['CosPropertyService']._Output_Any(_call, _value[_i])
    iluRt.EndSequence(_call)

def _SizeOf_TPropertyValues(_call, _value):
    _size = iluRt.SizeOfSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _size = _size + _imported_modules['CosPropertyService']._SizeOf_Any(_call, _value[_i])
    iluRt.EndSequence(_call)
    return _size

def _Input_TAccessCapabilities(_call):
    _length = iluRt.InputSequence(_call, 0)
    _value = []
    for _i in range(0, _length):
        _value.append(_Input_TAccessCapability(_call))
    iluRt.EndSequence(_call)
    return _value

def _Output_TAccessCapabilities(_call, _value):
    iluRt.OutputSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _Output_TAccessCapability(_call, _value[_i])
    iluRt.EndSequence(_call)

def _SizeOf_TAccessCapabilities(_call, _value):
    _size = iluRt.SizeOfSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _size = _size + _SizeOf_TAccessCapability(_call, _value[_i])
    iluRt.EndSequence(_call)
    return _size

def _Input_TAccessCapability(_call):
    _length = iluRt.InputSequence(_call, 0)
    _value = []
    for _i in range(0, _length):
        _value.append(_Input_TAccessOption(_call))
    iluRt.EndSequence(_call)
    return _value

def _Output_TAccessCapability(_call, _value):
    iluRt.OutputSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _Output_TAccessOption(_call, _value[_i])
    iluRt.EndSequence(_call)

def _SizeOf_TAccessCapability(_call, _value):
    _size = iluRt.SizeOfSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _size = _size + _SizeOf_TAccessOption(_call, _value[_i])
    iluRt.EndSequence(_call)
    return _size

class TAccessOption (iluRt.IluRecord):
    __ilu_type_name__ = 'IDLInterchange.TAccessOption'
    def __init__(self, _aTarget, _aCookie, _anItemClass, _aHints):
        self.aTarget = _aTarget;
        self.aCookie = _aCookie;
        self.anItemClass = _anItemClass;
        self.aHints = _aHints;

    def __getinitargs__(self):
      return (self.aTarget, self.aCookie, self.anItemClass, self.aHints, )

def _Input_TAccessOption(_call):
    iluRt.InputRecord(_call)
    _value = TAccessOption (None, None, None, None)
    _value.aTarget = iluRt.InputObjectID(_call, iluRt.FALSE, CItem)
    _value.aCookie = _imported_modules['CosPropertyService']._Input_Any(_call)
    _value.anItemClass = iluRt.InputString(_call, 0)
    _value.aHints = _imported_modules['CosPropertyService']._Input_Properties(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_TAccessOption(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputObjectID(_call, _value['aTarget'], iluRt.FALSE, CItem)
    _imported_modules['CosPropertyService']._Output_Any(_call, _value['aCookie'])
    iluRt.OutputString(_call, _value['anItemClass'], 0)
    _imported_modules['CosPropertyService']._Output_Properties(_call, _value['aHints'])
    iluRt.EndRecord(_call)

def _SizeOf_TAccessOption(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfObjectID(_call, _value['aTarget'], iluRt.FALSE, CItem)\
      + _imported_modules['CosPropertyService']._SizeOf_Any(_call, _value['aCookie'])\
      + iluRt.SizeOfString(_call, _value['anItemClass'], 0)\
      + _imported_modules['CosPropertyService']._SizeOf_Properties(_call, _value['aHints'])
    iluRt.EndRecord(_call)
    return _size

class EStatus:
    IN_PROGRESS = 0;
    UNKNOWN_MESSAGE_ID = 1;
    COMPLETED = 2;
    __image__ = {
          IN_PROGRESS : 'IN_PROGRESS',
          UNKNOWN_MESSAGE_ID : 'UNKNOWN_MESSAGE_ID',
          COMPLETED : 'COMPLETED'}

def _Input_TCookies(_call):
    _length = iluRt.InputSequence(_call, 0)
    _value = []
    for _i in range(0, _length):
        _value.append(_imported_modules['CosPropertyService']._Input_Any(_call))
    iluRt.EndSequence(_call)
    return _value

def _Output_TCookies(_call, _value):
    iluRt.OutputSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _imported_modules['CosPropertyService']._Output_Any(_call, _value[_i])
    iluRt.EndSequence(_call)

def _SizeOf_TCookies(_call, _value):
    _size = iluRt.SizeOfSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _size = _size + _imported_modules['CosPropertyService']._SizeOf_Any(_call, _value[_i])
    iluRt.EndSequence(_call)
    return _size

def _CatchException(_call, _IluClass, _ecode):
    _value = None
    _name = iluRt.ExceptionName(_call, _IluClass, _ecode)
    if _name == InvalidRequest:
	_name = InvalidRequest
	_value = _Input_R_InvalidRequest(_call)
    elif _name == InvalidQuery:
	_name = InvalidQuery
	_value = _Input_R_InvalidQuery(_call)
    elif _name == InvalidAuthenication:
	_name = InvalidAuthenication
	_value = _Input_R_InvalidAuthenication(_call)
    elif _name == InvalidPayment:
	_name = InvalidPayment
	_value = _Input_R_InvalidPayment(_call)
    elif _name == UnableToCompleteRequest:
	_name = UnableToCompleteRequest
	_value = _Input_R_UnableToCompleteRequest(_call)
    elif _name == InvalidProperties:
	_name = InvalidProperties
	_value = _Input_R_InvalidProperties(_call)
    elif _name == InvalidMoreCookie:
	_name = InvalidMoreCookie
    elif _name == InvalidCookies:
	_name = InvalidCookies
	_value = _Input_R_InvalidCookies(_call)
    elif _name == InvalidMessageID:
	_name = InvalidMessageID
	_value = _Input_R_InvalidMessageID(_call)
    elif _name == MultipleExceptions:
	_name = MultipleExceptions
	_value = _Input_R_MultipleExceptions(_call)
    raise _name, _value