#include "idl_types.h"

cpp_quote("#include <gen_ndr/ndr_misc.h>")

/*
   http://support.microsoft.com/default.aspx?scid=KB;en-us;q159298
   Any UUID starting with:
   A4 - store
   F5 - directory
 */

[
  uuid("99e64010-b032-11d0-97a4-00c04fd6551d"),
  pointer_default(unique),
  version(3.0)
] interface exchange_store_admin3
{
	void ec_store_admin3_dummy();
}


[
  uuid("89742ace-a9ed-11cf-9c0c-08002be7ae86"),
  pointer_default(unique),
  version(2.0)
] interface exchange_store_admin2
{
	void ec_store_admin2_dummy();
}

[
  uuid("a4f1db00-ca47-1067-b31e-00dd010662da"),
  pointer_default(unique),
  version(1.0)
] interface exchange_store_admin1
{
	void ec_store_admin1_dummy();
}


[
  uuid("1544f5e0-613c-11d1-93df-00c04fd7bd09"),
  endpoint("ncacn_np:[\\pipe\\lsass]","ncacn_np:[\\pipe\\protected_storage]","ncacn_ip_tcp:[]"),
  pointer_default(unique),
  version(1.0),
  helpstring("Exchange 2003 Directory Request For Response")
] interface exchange_ds_rfr
{

#include "mapitags_enum.h"
#include "mapicodes_enum.h"

	/*****************/
	/* Function 0x00 */
	MAPISTATUS RfrGetNewDSA(
		[in]                                    uint32  ulFlags,
		[in,string,charset(DOS)]                uint8   *pUserDN,
		[in,out,unique,string,charset(DOS)]     uint8   **ppszUnused,
		[in,out,unique,string,charset(DOS)]     uint8   **ppszServer
		);
	
	/*****************/
	/* Function 0x01 */
	MAPISTATUS RfrGetFQDNFromLegacyDN(
		[in]							uint32	ulFlags,
		[in,range(10,1024)]					uint32	cbMailboxServerDN,
		[in,string,charset(DOS),size_is(cbMailboxServerDN)]	uint8	*szMailboxServerDN,
		[out,ref,string,charset(DOS)]				uint8	**ppszServerFQDN
		);
}

[
  uuid("f930c514-1215-11d3-99a5-00a0c9b61b04"),
  helpstring("System Attendant Cluster Interface"),
  pointer_default(unique),
  version(1.0)
] interface exchange_sysatt_cluster
{
	void sysatt_cluster_dummy();
}

/*
[83d72bf0-0d89-11ce-b13f-00aa003bac6c] MS Exchange
System Attendant Private Interface
*/

[
  uuid("469d6ec0-0d87-11ce-b13f-00aa003bac6c"),
  pointer_default(unique),
  helpstring("Exchange 5.5 System Attendant Request for Response")
] interface exchange_system_attendant
{
	void sysatt_dummy();
}

[
  uuid("9e8ee830-4559-11ce-979b-00aa005ffebe"),
  pointer_default(unique),
  version(2.0),
  helpstring("Exchange 5.5 MTA")
] interface exchange_mta
{
	/*****************/
	/* Function 0x00 */
	void MtaBind();

	/*****************/
	/* Function 0x01 */
	void MtaBindAck();
}

[
  uuid("f5cc59b4-4264-101a-8c59-08002b2f8426"),
  pointer_default(unique),
  version(21.0),
  helpstring("Exchange 5.5 DRS")
] interface exchange_drs
{
	/*****************/
	/* Function 0x00 */
	void ds_abandon();

	/*****************/
	/* Function 0x01 */
	void ds_add_entry();

	void ds_bind();
	void ds_compare();
	void ds_list();
	void ds_modify_entry();
	void ds_modify_rdn();
	void ds_read();
	void ds_receive_result();
	void ds_remove_entry();
	void ds_search();
	void ds_unbind();
	void ds_wait();
	void dra_replica_add();
	void dra_replica_delete();
	void dra_replica_synchronize();
	void dra_reference_update();
	void dra_authorize_replica();
	void dra_unauthorize_replica();
	void dra_adopt();
	void dra_set_status();
	void dra_modify_entry();
	void dra_delete_subref();
}

[
  uuid("f5cc5a7c-4264-101a-8c59-08002b2f8426"),
  version(21.0),
  pointer_default(unique),
  helpstring("Exchange 5.5 XDS")
] interface exchange_xds
{
	void xds_dummy();
}

[
  uuid("38a94e72-a9bc-11d2-8faf-00c04fa378ff"),
  pointer_default(unique),
  version(1.0)
] interface exchange_mta_qadmin
{
	void exchange_mta_qadmin();
}


[
  uuid("0e4a0156-dd5d-11d2-8c2f-00c04fb6bcde"),
  pointer_default(unique),
  version(1.0)
] interface exchange_store_information
{
	void exchange_store_information_dummy();
}

[
  uuid("f5cc5a18-4264-101a-8c59-08002b2f8426"),
  endpoint("ncacn_np:[\\pipe\\lsass]","ncacn_np:[\\pipe\\protected_storage]","ncacn_ip_tcp:[]"),
  pointer_default(unique),
  version(56.0),
  helpstring("Exchange 5.5 Name Service Provider")
] interface exchange_nsp
{

#define	PT_UNSPECIFIED	0x0000
#define	PT_NULL		0x0001
#define	PT_I2		0x0002
#define	PT_LONG		0x0003
#define	PT_R4		0x0004
#define	PT_DOUBLE	0x0005
#define	PT_CURRENCY	0x0006
#define	PT_APPTIME	0x0007
#define	PT_ERROR	0x000a /* means the given attr contains no value */
#define	PT_BOOLEAN	0x000b
#define	PT_OBJECT	0x000d
#define	PT_I8		0x0014
#define	PT_STRING8	0x001e
#define	PT_UNICODE	0x001f
#define	PT_SYSTIME	0x0040
#define	PT_CLSID       	0x0048
#define	PT_SVREID	0x00fb
#define	PT_SRESTRICT	0x00fd
#define	PT_ACTIONS	0x00fe
#define	PT_BINARY	0x0102
/* Multi-valued properties */
#define	PT_MV_I2       	0x1002
#define	PT_MV_LONG     	0x1003
#define	PT_MV_R4       	0x1004
#define	PT_MV_DOUBLE   	0x1005
#define	PT_MV_CURRENCY 	0x1006
#define	PT_MV_APPTIME  	0x1007
#define	PT_MV_I8       	0x1014
#define	PT_MV_STRING8	0x101e
#define	PT_MV_TSTRING	0x101e
#define	PT_MV_UNICODE	0x101f
#define	PT_MV_SYSTIME	0x1040
#define	PT_MV_CLSID	0x1048
#define	PT_MV_BINARY	0x1102

	typedef [v1_enum] enum {
		SortTypeDisplayName		= 0x00000000,
		SortTypePhoneticDisplayName	= 0x00000003,
		SortTypeDisplayName_RO		= 0x000003E8,
		SortTypeDisplayName_W		= 0x000003E9
	} TableSortOrders;

	typedef [flag(NDR_NOALIGN)] struct {
		TableSortOrders	SortType;
		uint32		ContainerID;
		uint32		CurrentRec;
		uint32		Delta;
		uint32		NumPos;
		uint32		TotalRecs;
		uint32		CodePage;
		uint32		TemplateLocale;
		uint32		SortLocale;
	} STAT;

	typedef struct {
		uint8 ab[16];
	} FlatUID_r;

	typedef struct {
		FlatUID_r	*lpguid;
		uint32		ulReserved;
		uint32		lID;
	} PropertyName_r;

	typedef struct {
		[range(0,100000)] uint32		cNames;
		[size_is(cNames)] PropertyName_r	aNames[];
	} PropertyNameSet_r;

	typedef struct {
		[range(0,100000)] uint32			cValues;
		[string,size_is(cValues),charset(DOS)] uint8	**lppszA;
	} StringArray_r;

	typedef struct {
		[range(0,100000)] uint32		       	Count;
		[string,size_is(Count),charset(DOS)] uint8     	*Strings[];
	} StringsArray_r;

	typedef struct {
		[range(0,100000)] uint32			cValues;
		[string,size_is(cValues),charset(UTF16)] uint16	**lppszW;
	} WStringArray_r;

	typedef struct {
		[range(0,100000)] uint32		       	Count;
		[string,size_is(Count),charset(UTF16)] uint16  	*Strings[];
	} WStringsArray_r;

	typedef struct {
		[range(0,100001)] uint32       				cValues;
		[size_is(cValues+1),length_is(cValues)] MAPITAGS	aulPropTag[];
	} SPropTagArray;

	typedef [public] struct {
		[range(0,2097152)] uint32      	cb;
		[size_is(cb)] uint8		*lpb;
	} Binary_r;

	typedef [public] struct {
		uint32 dwLowDateTime;
		uint32 dwHighDateTime;
	} FILETIME;

	typedef struct {
		[range(0,100000)] uint32	cValues;
		[size_is(cValues)] uint16	*lpi;
	} ShortArray_r;

	typedef struct {
		[range(0,100000)] uint32	cValues;
		[size_is(cValues)] uint32	*lpl; 
	} LongArray_r;

	typedef struct {
		[range(0,100000)] uint32	cValues;
		[size_is(cValues)] Binary_r	*lpbin;
	} BinaryArray_r;

	typedef [flag(NDR_NOALIGN)] struct {
		[range(0,100000)]uint32		cValues;
		[size_is(cValues)] FlatUID_r	**lpguid; 
	} FlatUIDArray_r;

	typedef struct {
		[range(0,100000)] uint32	cValues;
		[size_is(cValues)] FILETIME	*lpft;
	} DateTimeArray_r;

	typedef [switch_type(uint32)] union {
		[case(PT_I2)]			uint16			i;
		[case(PT_LONG)]			uint32			l;
		[case(PT_DOUBLE)]		dlong			dbl;
		[case(PT_BOOLEAN)]		uint8			b;
		[case(PT_I8)]			dlong			d;
		[case(PT_STRING8)][unique][string,charset(DOS)] uint8	*lpszA;
		[case(PT_BINARY)]		Binary_r       		bin;
		[case(PT_UNICODE)][string,charset(UTF16)] uint16	*lpszW;
		[case(PT_CLSID)]		FlatUID_r      		*lpguid;
		[case(PT_SYSTIME)]		FILETIME		ft;
		[case(PT_ERROR)]		MAPISTATUS		err;
		[case(PT_MV_I2)]		ShortArray_r		MVi;
		[case(PT_MV_LONG)]		LongArray_r		MVl;
		[case(PT_MV_STRING8)]		StringArray_r		MVszA;
		[case(PT_MV_BINARY)]		BinaryArray_r		MVbin;
		[case(PT_MV_CLSID)]		FlatUIDArray_r		MVguid;
		[case(PT_MV_UNICODE)]		WStringArray_r		MVszW;
		[case(PT_MV_SYSTIME)]		DateTimeArray_r		MVft;
		[case(PT_NULL)]			uint32			null;
		[case(PT_OBJECT)]		uint32			object;
	} SPropValue_CTR;

	typedef [public]struct {
		MAPITAGS ulPropTag;
		uint32 dwAlignPad;
		[switch_is(ulPropTag & 0xFFFF)] SPropValue_CTR value; 
	} SPropValue;
	
	typedef struct {
		uint32			       	ulAdrEntryPad;
		[range(0,100000)] uint32       	cValues;
		[size_is(cValues)]SPropValue	*lpProps;
	} SRow;


	typedef [public] struct {
		[range(0,100000)] uint32	cRows;
		[size_is(cRows)] SRow		aRow[];
	} SRowSet;
	
	typedef struct {
		[range(0,100000)] uint32		cRes;
		[size_is(cRes)] Restriction_r		*lpRes;
	} AndRestriction_r;

	typedef struct {
		[range(0,100000)] uint32		cRes;
		[size_is(cRes)] Restriction_r		*lpRes;
	} OrRestriction_r;

	typedef struct {
		Restriction_r				*lpRes;
	} NotRestriction_r;

	typedef struct {
		uint32					ulFuzzyLevel;
		MAPITAGS       				ulPropTag;
		SPropValue				*lpProp;
	} ContentRestriction_r;

	typedef struct {
		uint32					relop;
		MAPITAGS				ulPropTag;
		SPropValue				*lpProp;
	} PropertyRestriction_r;

	typedef struct {
		uint32					relop;
		MAPITAGS				ulPropTag1;
		MAPITAGS				ulPropTag2;
	} ComparePropsRestriction_r;

	typedef struct {
		uint32					relMBR;
		MAPITAGS				ulPropTag;
		uint32					ulMask;
	} BitMaskRestriction_r;

	typedef struct {
		uint32					relop;
		MAPITAGS				ulPropTag;
		uint32					cb;
	} SizeRestriction_r;

	typedef struct {
		uint32					ulReserved1;
		MAPITAGS				ulPropTag;
		uint32					ulReserved2;
	} ExistRestriction_r;

	typedef struct {
		uint32					ulSubObject;
		Restriction_r				*lpRes;
	} SubRestriction_r;

	typedef [v1_enum] enum {
		RES_AND			= 0x0,
		RES_OR			= 0x1,
		RES_NOT			= 0x2,
		RES_CONTENT		= 0x3,
		RES_PROPERTY		= 0x4,
		RES_COMPAREPROPS	= 0x5,
		RES_BITMASK		= 0x6,
		RES_SIZE		= 0x7,
		RES_EXIST		= 0x8,
		RES_SUBRESTRICTION	= 0x9,
		RES_COMMENT		= 0xA
	} RestrictionType_r;

	typedef [switch_type(uint32)] union {
		[case(RES_AND)]			AndRestriction_r		resAnd;
		[case(RES_OR)]			OrRestriction_r			resOr;
		[case(RES_NOT)]			NotRestriction_r		resNot;
		[case(RES_CONTENT)]		ContentRestriction_r		resContent;
		[case(RES_PROPERTY)]		PropertyRestriction_r		resProperty;
		[case(RES_COMPAREPROPS)]	ComparePropsRestriction_r	resCompareProps;
		[case(RES_BITMASK)]		BitMaskRestriction_r		resBitMask;
		[case(RES_SIZE)]		SizeRestriction_r		resSize;
		[case(RES_EXIST)]		ExistRestriction_r		resExist;
		[case(RES_SUBRESTRICTION)]	SubRestriction_r		resSub;
	} RestrictionUnion_r;

	typedef [public] struct _Restriction_r{
		RestrictionType_r      			rt;
		[switch_is(rt)] RestrictionUnion_r	res;
	} Restriction_r;

	/*****************/
	/* Function 0x00 */
	typedef [bitmap32bit] bitmap {
		fAnonymousLogin	= 0x00000020
	} NspiBind_dwFlags;

	MAPISTATUS NspiBind(
		[in] NspiBind_dwFlags	dwFlags,
		[in] STAT		*pStat,
		[in,out,unique] GUID   	*mapiuid,
		[out] policy_handle    	*handle
		);

	/*****************/
	/* Function 0x01 */
	MAPISTATUS NspiUnbind(
		[in, out] policy_handle	*handle,
		[in] uint32	       	Reserved
		);

	/*****************/
	/* Function 0x02 */
	MAPISTATUS NspiUpdateStat(
		[in] policy_handle	*handle,
		[in] uint32		Reserved,
		[in,out] STAT		*pStat,
		[in,out,unique] uint32	*plDelta
		);

	/*****************/
	/* Function 0x03 */
	typedef [bitmap32bit] bitmap {
		fSkipObjects	= 0x00000001,
		fEphID		= 0x00000002
	} NspiQueryRows_dwFlags;

	MAPISTATUS NspiQueryRows(
		[in]					policy_handle			*handle,
		[in]					NspiQueryRows_dwFlags		dwFlags,
		[in,out]				STAT				*pStat,
		[in,range(0,100000)]			uint32				dwETableCount,
 		[in,unique,size_is(dwETableCount)]	uint32				*lpETable,
		[in]					uint32				Count,
		[in,unique]    				SPropTagArray			*pPropTags,
		[out]					SRowSet				**ppRows
		);

	/*****************/
	/* Function 0x04 */
	MAPISTATUS NspiSeekEntries(
		[in]		policy_handle	*handle,
		[in]		uint32		Reserved,
		[in,out]	STAT		*pStat,
		[in]		SPropValue     	*pTarget,
		[in,unique]	SPropTagArray	*lpETable,
		[in,unique]	SPropTagArray	*pPropTags,
		[out]		SRowSet		**pRows
		);

	/*****************/
	/* Function 0x05 */
	MAPISTATUS NspiGetMatches(
		[in]		policy_handle	*handle,
		[in]		uint32		Reserved,
		[in,out]	STAT		*pStat,
		[in][unique]	SPropTagArray	*pReserved,
		[in]		uint32	       	Reserved2,
		[in][unique]	Restriction_r	*Filter,
 		[in][unique]	PropertyName_r	*lpPropName,
		[in]		uint32		ulRequested,
		[out]		SPropTagArray	**ppOutMIds,
		[in][unique]	SPropTagArray	*pPropTags,
		[out]      	SRowSet		**ppRows
		);

	/*****************/
	/* Function 0x06 */
	MAPISTATUS NspiResortRestriction(
		[in] policy_handle	*handle,
		[in] uint32		Reserved,
		[in,out] STAT		*pStat,
		[in] SPropTagArray	*pInMIds,
		[in,out] SPropTagArray	**ppMIds
		);

	/*****************/
	/* Function 0x07 */
	MAPISTATUS NspiDNToMId(
		[in] policy_handle	*handle,
		[in] uint32		Reserved,
		[in] StringsArray_r	*pNames,
		[out] SPropTagArray	**ppMIds
		);

	/*****************/
	/* Function 0x08 */
	MAPISTATUS NspiGetPropList(
		[in] policy_handle	*handle,
		[in] uint32		dwFlags,
		[in] uint32		dwMId,
		[in] uint32		CodePage,
		[out] SPropTagArray	**ppPropTags
		);

	/*****************/
	/* Function 0x09 */
	MAPISTATUS NspiGetProps(
		[in]   	policy_handle			*handle,
		[in]   	uint32				dwFlags,
		[in]	STAT				*pStat,
		[in,unique] SPropTagArray		*pPropTags,
		[out]	SRow				**ppRows
		);

	/*****************/
	/* Funcion 0xa   */
	MAPISTATUS NspiCompareMIds(
		[in] policy_handle     	*handle,
		[in] uint32	       	Reserved,
		[in] STAT	       	*pStat,
		[in] uint32	       	MId1,
		[in] uint32	       	MId2,
		[out] uint32	       	*plResult
		);

	/*****************/
	/* Function 0xb  */
	MAPISTATUS NspiModProps(
		[in] policy_handle		*handle,
		[in] uint32			Reserved,
		[in] STAT			*pStat,
		[in,unique] SPropTagArray	*pPropTags,
		[in] SRow			*pRow
		);

	/*****************/
	/* Function 0x0c */
	typedef [bitmap32bit] bitmap {
		NspiAddressCreationTemplates	= 0x00000002,
		NspiUnicodeStrings		= 0x00000004
	} NspiGetSpecialTable_dwFlags;

	MAPISTATUS NspiGetSpecialTable(
		[in] policy_handle			*handle,
		[in] NspiGetSpecialTable_dwFlags       	dwFlags,
		[in] STAT				*pStat,
 		[in,out] uint32				*lpVersion,
 		[out] SRowSet				**ppRows
		);

	/*******************/
	/* Function 0x0d   */
	typedef [bitmap32bit] bitmap {
		TI_TEMPLATE		= 0x00000001,
		TI_SCRIPT		= 0x00000004,
		TI_EMT			= 0x00000010,
		TI_HELPFILE_NAME	= 0x00000020,
		TI_HELPFILE_CONTENTS	= 0x00000040
	} TI_dwFlags;

	MAPISTATUS NspiGetTemplateInfo(
		[in] policy_handle			*handle,
		[in] TI_dwFlags				dwFlags,
		[in] uint32				ulType,
		[in,unique,string,charset(DOS)] uint8	*pDN,
		[in] uint32				dwCodePage,
		[in] uint32				dwLocaleID,
		[out] SRow				**ppData
		);

	/*******************/
	/* Function 0x0e   */
	MAPISTATUS NspiModLinkAtt(
		[in] policy_handle			*handle,
		[in] uint32				dwFlags,
		[in] uint32				ulPropTag,
		[in] uint32				MId,
		[in] BinaryArray_r			*lpEntryIds
		);

	/*************************************/
	/* Function 0x0f: Not used on wire   */
	MAPISTATUS NspiDeleteEntries(
		[in] policy_handle			*Reserved1,
		[in] uint32				Reserved2,
		[in] uint32				Reserved3,
		[in] BinaryArray_r			*Reserved4
		);

	/*******************/
	/* Function 0x10   */
	typedef [bitmap32bit] bitmap {
		NspiUnicodeProptypes	= 0x80000000
	} NspiQueryColumns_dwFlags;

	MAPISTATUS NspiQueryColumns(
		[in] policy_handle			*handle,
		[in] uint32				Reserved,
		[in] NspiQueryColumns_dwFlags		dwFlags,
		[out] SPropTagArray      		**ppColumns
		);

	/*******************/
	/* Function 0x11   */
	MAPISTATUS NspiGetNamesFromIDs(
		[in] policy_handle			*handle,
		[in] uint32				Reserved,
		[in,unique] FlatUID_r			*lpGuid,
		[in,unique] SPropTagArray		*pPropTags,
		[out] SPropTagArray			**ppReturnedPropTags,
		[out] PropertyNameSet_r			**ppNames
		);

	/*******************/
	/* Function 0x12   */
	MAPISTATUS NspiGetIDsFromNames(
		[in] policy_handle			*handle,
		[in] uint32				Reserved,
		[in] uint32				dwFlags,
		[in,range(0,100000)] uint32		cPropNames,
		[in,size_is(cPropNames)] PropertyName_r	**ppNames,
		[out] SPropTagArray			**ppPropTags
		);

	/*****************/
	/* Function 0x13 */
	MAPISTATUS NspiResolveNames(
		[in] policy_handle		*handle,
		[in] uint32			Reserved,
		[in] STAT			*pStat,
		[in,unique] SPropTagArray	*pPropTags,
 		[in] StringsArray_r		*paStr,
		[out] SPropTagArray		**ppMIds,
		[out] SRowSet			**ppRows
	);

	/*****************/
	/* Function 0x14 */
	MAPISTATUS NspiResolveNamesW(
		[in] policy_handle		*handle,
		[in] uint32			Reserved,
		[in] STAT			*pStat,
		[in,unique] SPropTagArray      	*pPropTags,
		[in] WStringsArray_r       	*paWStr,
		[out] SPropTagArray		**ppMIds,
		[out] SRowSet			**ppRows
		);
}

[
  uuid("a4f1db00-ca47-1067-b31f-00dd010662da"),
  pointer_default(unique),
  endpoint("ncacn_np:[\\pipe\\lsass]","ncacn_np:[\\pipe\\protected_storage]","ncacn_ip_tcp:"),
  //version(0.81),
  version(5308416),
  helpstring("Exchange 5.5 EMSMDB")
] interface exchange_emsmdb
{
	/*****************/
	/* Function 0x00 */

	MAPISTATUS EcDoConnect(
 		[out]				policy_handle	*handle,
                [in,string,charset(DOS)]	uint8		szUserDN[],
		[in]				uint32		ulFlags,
		[in]				uint32		ulConMod,
		[in]				uint32		cbLimit,
		[in]				uint32		ulCpid,
		[in]				uint32		ulLcidString,
		[in]				uint32		ulLcidSort,
		[in]				uint32		ulIcxrLink,
		[in]				uint16		usFCanConvertCodePages,
		[out]				uint32		*pcmsPollsMax,
		[out]				uint32		*pcRetry,
		[out]				uint32		*pcmsRetryDelay,
		[out]				uint32		*picxr,
                [out,unique,string,charset(DOS)]uint8		*szDNPrefix,
                [out,unique,string,charset(DOS)]uint8		*szDisplayName,
                [out]				uint16          rgwServerVersion[3],
		[in,out]       			uint16          rgwClientVersion[3],
                [in,out]			uint32		*pullTimeStamp
		);

	/*****************/
	/* Function 0x01 */
	MAPISTATUS EcDoDisconnect(
		[in,out]   policy_handle   *handle
		);

	/*****************/
	/* Function 0x02 */

	/*
	  EcDoRpc opnums
	*/

	typedef [public, enum8bit, flag(NDR_PAHEX)] enum 
		{
			MAPI_STORE	= 0x1,
			MAPI_ADDRBOOK	= 0x2,
			MAPI_FOLDER	= 0x3,
			MAPI_ABCONT	= 0x4,
			MAPI_MESSAGE	= 0x5,
			MAPI_MAILUSER	= 0x6, /* Individual Recipient */
			MAPI_ATTACH	= 0x7,
			MAPI_DISTLIST	= 0x8,
			MAPI_PROFSECT	= 0x9,
			MAPI_STATUS	= 0xA,
			MAPI_SESSION	= 0xB,
			MAPI_FORMINFO	= 0xC
		} MAPI_OBJTYPE;

	typedef [public, v1_enum, flag(NDR_PAHEX)] enum 
		{
			RightsNone		= 0x00000000,
			RightsReadItems		= 0x00000001,
			RightsCreateItems	= 0x00000002,
			RightsEditOwn		= 0x00000008,
			RightsDeleteOwn		= 0x00000010,
			RightsEditAll		= 0x00000020,
			RightsDeleteAll		= 0x00000040,
			RightsCreateSubfolders	= 0x00000080,
			RightsFolderOwner	= 0x00000100,
			RightsFolderContact	= 0x00000200,
			RoleNone		= 0x00000400,
			RoleReviewer		= 0x00000401,
			RoleContributor		= 0x00000402,
			RoleNoneditingAuthor	= 0x00000413,
			RoleAuthor		= 0x0000041B,
			RoleEditor		= 0x0000047B,
			RolePublishAuthor	= 0x0000049B,
			RolePublishEditor	= 0x000004FB,
			RightsAll		= 0x000005FB,
			RoleOwner		= 0x000007FB
	       	} ACLRIGHTS;

	typedef [public, enum8bit, flag(NDR_PAHEX)] enum
		{
			op_MAPI_Release				= 0x1,
			op_MAPI_OpenFolder			= 0x2,
			op_MAPI_OpenMessage			= 0x3,
			op_MAPI_GetHierarchyTable		= 0x4,
			op_MAPI_GetContentsTable		= 0x5,
			op_MAPI_CreateMessage			= 0x6,
			op_MAPI_GetProps			= 0x7,
			op_MAPI_GetPropsAll			= 0x8,
			op_MAPI_GetPropList			= 0x9,
			op_MAPI_SetProps			= 0xa,
			op_MAPI_DeleteProps			= 0xb,
			op_MAPI_SaveChangesMessage		= 0xc,
			op_MAPI_RemoveAllRecipients		= 0xd,
			op_MAPI_ModifyRecipients		= 0xe,
			op_MAPI_ReadRecipients			= 0xf,
			op_MAPI_ReloadCachedInformation		= 0x10,
			op_MAPI_SetMessageReadFlag		= 0x11,
			op_MAPI_SetColumns			= 0x12,
			op_MAPI_SortTable			= 0x13,
			op_MAPI_Restrict			= 0x14,
			op_MAPI_QueryRows			= 0x15,
			op_MAPI_GetStatus			= 0x16,
			op_MAPI_QueryPosition			= 0x17,
			op_MAPI_SeekRow				= 0x18,
			op_MAPI_SeekRowBookmark			= 0x19,
			op_MAPI_SeekRowApprox			= 0x1a,
			op_MAPI_CreateBookmark			= 0x1b,
			op_MAPI_CreateFolder			= 0x1c,
			op_MAPI_DeleteFolder			= 0x1d,
			op_MAPI_DeleteMessages			= 0x1e,
			op_MAPI_GetMessageStatus		= 0x1f,
			op_MAPI_SetMessageStatus		= 0x20,
			op_MAPI_GetAttachmentTable		= 0x21,
			op_MAPI_OpenAttach			= 0x22,
			op_MAPI_CreateAttach			= 0x23,
			op_MAPI_DeleteAttach			= 0x24,
			op_MAPI_SaveChangesAttachment  		= 0x25,
			op_MAPI_SetReceiveFolder		= 0x26,
			op_MAPI_GetReceiveFolder		= 0x27,
			op_MAPI_RegisterNotification   		= 0x29,
			op_MAPI_Notify				= 0x2a,
			op_MAPI_OpenStream			= 0x2b,
			op_MAPI_ReadStream			= 0x2c,
			op_MAPI_WriteStream			= 0x2d,
			op_MAPI_SeekStream			= 0x2e,
			op_MAPI_SetStreamSize			= 0x2f,
			op_MAPI_SetSearchCriteria		= 0x30,
			op_MAPI_GetSearchCriteria		= 0x31,
			op_MAPI_SubmitMessage			= 0x32,
			op_MAPI_MoveCopyMessages		= 0x33,
			op_MAPI_AbortSubmit			= 0x34,
			op_MAPI_MoveFolder			= 0x35,
			op_MAPI_CopyFolder			= 0x36,
			op_MAPI_QueryColumnsAll			= 0x37,
			op_MAPI_Abort				= 0x38,
			op_MAPI_CopyTo				= 0x39,
			op_MAPI_CopyToStream			= 0x3a,
			op_MAPI_CloneStream			= 0x3b,
			op_MAPI_GetTable			= 0x3e,
			op_MAPI_GetRulesTable			= 0x3f,
			op_MAPI_ModifyTable			= 0x40,
			op_MAPI_ModifyRules			= 0x41,
			op_MAPI_GetOwningServers		= 0x42,
			op_MAPI_LongTermIdFromId		= 0x43,
			op_MAPI_IdFromLongTermId		= 0x44,
			op_MAPI_PublicFolderIsGhosted		= 0x45,
			op_MAPI_OpenEmbeddedMessage		= 0x46,
			op_MAPI_SetSpooler			= 0x47,
			op_MAPI_SpoolerLockMessage		= 0x48,
			op_MAPI_AddressTypes			= 0x49,
			op_MAPI_TransportSend			= 0x4a,
			op_MAPI_FastTransferSourceGetBuffer	= 0x4e,
			op_MAPI_FindRow				= 0x4f,
			op_MAPI_Progress			= 0x50,
			op_MAPI_GetNamesFromIDs			= 0x55,
			op_MAPI_GetIDsFromNames			= 0x56,
			op_MAPI_UpdateDeferredActionMessages	= 0x57,
			op_MAPI_EmptyFolder			= 0x58,
			op_MAPI_ExpandRow			= 0x59,
			op_MAPI_CollapseRow			= 0x5a,
			op_MAPI_LockRegionStream		= 0x5b,
			op_MAPI_UnlockRegionStream		= 0x5c,
			op_MAPI_CommitStream			= 0x5d,
			op_MAPI_GetStreamSize			= 0x5e,
			op_MAPI_QueryNamedProperties		= 0x5f,
			op_MAPI_GetPerUserLongTermIds		= 0x60,
			op_MAPI_GetPerUserGuid			= 0x61,
			op_MAPI_ReadPerUserInformation		= 0x63,
			op_MAPI_SetReadFlags			= 0x66,
			op_MAPI_CopyProperties			= 0x67,
			op_MAPI_GetReceiveFolderTable		= 0x68,
			op_MAPI_GetCollapseState		= 0x6b,
			op_MAPI_SetCollapseState		= 0x6c,
			op_MAPI_GetTransportFolder		= 0x6d,
			op_MAPI_Pending				= 0x6e,
			op_MAPI_RegisterOptions			= 0x6f,
			op_MAPI_SyncConfigure			= 0x70,
			op_MAPI_SyncImportMessageChange		= 0x72,
			op_MAPI_SyncImportHierarchyChange	= 0x73,
			op_MAPI_SyncImportDeletes		= 0x74,
			op_MAPI_SyncUploadStateStreamBegin	= 0x75,
			op_MAPI_SyncUploadStateStreamContinue	= 0x76,
			op_MAPI_SyncUploadStateStreamEnd	= 0x77,
			op_MAPI_SyncImportMessageMove		= 0x78,
			op_MAPI_SetPropertiesNoReplicate	= 0x79,
			op_MAPI_DeletePropertiesNoReplicate	= 0x7a,
			op_MAPI_GetStoreState			= 0x7b,
			op_MAPI_SyncOpenCollector		= 0x7e,
			op_MAPI_GetLocalReplicaIds		= 0x7f,
			op_MAPI_SyncImportReadStateChanges	= 0x80,
			op_MAPI_ResetTable			= 0x81,
			op_MAPI_SyncGetTransferState		= 0x82,
			op_MAPI_OpenPublicFolderByName		= 0x87,
			op_MAPI_SetSyncNotificationGuid		= 0x88,
			op_MAPI_FreeBookmark			= 0x89,
			op_MAPI_WriteAndCommitStream		= 0x90,
			op_MAPI_HardDeleteMessages		= 0x91,
			op_MAPI_HardDeleteMessagesAndSubfolders	= 0x92,
			op_MAPI_Logon				= 0xfe,
			/****** custom MAPI opnum for mapiproxy ******/
			op_MAPI_proxypack			= 0xa5
		} MAPI_OPNUM;


	typedef [public,noprint,flag(NDR_NOALIGN)] struct {
		uint16				cb;
		[flag(NDR_BUFFERS)]uint8	lpb[cb];
	} SBinary_short;

	typedef [public] struct {
		uint32 cValues;
		uint32 lpl[cValues]; 
	} mapi_MV_LONG_STRUCT;

	typedef [public] struct {
		astring lppszA;
	} mapi_LPSTR;

	typedef [public] struct {
		uint32 cValues;
		mapi_LPSTR strings[cValues]; 
	} mapi_SLPSTRArray;

	typedef struct {
		[flag(STR_NULLTERM)] string lppszW;
	} mapi_LPWSTR;

	typedef struct {
		uint32 cValues;
		mapi_LPWSTR strings[cValues];
	} mapi_SPLSTRArrayW;
	
	typedef [public] struct {
		uint32		cValues;
		SBinary_short	bin[cValues];
	} mapi_SBinaryArray;

	typedef struct {
		uint32		cValues;
		GUID		lpguid[cValues];
	} mapi_SGuidArray;

	/******* part of the no-pointer deep recursion hack *******/
	typedef [nopull,nopush,noprint,flag(NDR_NOALIGN)] struct {
		uint8 wrap[0x8000];
	} mapi_SRestriction_wrap;

	typedef [nopush,nopull,noprint,flag(NDR_NOALIGN)] struct {
		uint8	wrap[0x8000];
	} mapi_SPropValue_wrap;

	typedef [nopush,nopull,noprint,flag(NDR_NOALIGN)] struct {
		uint8	wrap[0x8000];
	} mapi_SPropValue_array_wrap;
	/**********************************************************/	

	typedef [enum8bit] enum {
		ActionType_OP_MOVE		= 0x1,
		ActionType_OP_COPY		= 0x2,
		ActionType_OP_REPLY		= 0x3,
		ActionType_OP_OOF_REPLY		= 0x4,
		ActionType_OP_DEFER_ACTION	= 0x5,
		ActionType_OP_BOUNCE		= 0x6,
		ActionType_OP_FORWARD		= 0x7,
		ActionType_OP_DELEGATE		= 0x8,
		ActionType_OP_TAG		= 0x9,
		ActionType_OP_DELETE		= 0xA,
		ActionType_OP_MARK_AS_READ	= 0xB
	} ActionType;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8		FolderInThisStore;
		SBinary_short		StoreEID;
		SBinary_short		FolderEID;
	} MoveCopy_Action;

	typedef [flag(NDR_NOALIGN)] struct {
		hyper			ReplyTemplateFID;
		hyper			ReplyTemplateMID;
		GUID			ReplyTemplateGUID;			
	} ReplyOOF_Action;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8				Reserved;
		mapi_SPropValue_array_wrap	PropertyValue;
	} RecipientBlock;

	typedef [flag(NDR_NOALIGN)] enum {
		BOUNCE_MESSAGE_TOO_LARGE	= 0x0000000d,
		BOUNCE_MESSAGE_NOT_DISPLAYED	= 0x0000001f,
		BOUNCE_MESSAGE_DENIED		= 0x00000026
	} BounceCode;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16			RecipientCount;
		RecipientBlock		RecipientBlock[RecipientCount];
	} ForwardDelegate_Action;

	typedef [nodiscriminant, flag(NDR_NOALIGN)] union {
		[case(ActionType_OP_MOVE)]		MoveCopy_Action			MoveAction;
		[case(ActionType_OP_COPY)]		MoveCopy_Action			CopyAction;
		[case(ActionType_OP_REPLY)]		ReplyOOF_Action			ReplyAction;
		[case(ActionType_OP_OOF_REPLY)]		ReplyOOF_Action			ReplyOOFAction;
		[case(ActionType_OP_DEFER_ACTION)][flag(NDR_REMAINING)] DATA_BLOB	DeferAction;
		[case(ActionType_OP_BOUNCE)]		BounceCode			BounceCode;
		[case(ActionType_OP_TAG)]		mapi_SPropValue_wrap	       	PropValue;
		[case(ActionType_OP_FORWARD)]		ForwardDelegate_Action		ForwardAction;
		[case(ActionType_OP_DELEGATE)]		ForwardDelegate_Action		DelegateAction;
		[case(ActionType_OP_DELETE)];
		[case(ActionType_OP_MARK_AS_READ)];
	} ActionData;

	typedef [flag(NDR_NOALIGN)] struct {
		ActionType				ActionType;
		uint32					ActionFlavor;
		uint32					ActionFlags;
		[switch_is(ActionType)] ActionData	ActionDataBuffer;
	} ActionBlockData;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16					ActionLength;
		[subcontext(0),subcontext_size(ActionLength),flag(NDR_REMAINING)] ActionBlockData ActionBlockData;
	} ActionBlock;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16		count;
		ActionBlock	ActionBlock[count];
	} RuleAction;

	typedef [public,nodiscriminant,flag(NDR_NOALIGN)] union {
		[case(PT_I2)]		uint16			i;
		[case(PT_LONG)]     	uint32			l;
		[case(PT_DOUBLE)]	dlong			dbl;
		[case(PT_ERROR)]       	uint32			err;
		[case(PT_BOOLEAN)]	uint8			b;
		[case(PT_I8)]		dlong			d;
		[case(PT_STRING8)]	astring			lpszA;
		[case(PT_UNICODE)][flag(STR_NULLTERM)] string	lpszW;
		[case(PT_SYSTIME)]	FILETIME		ft;
		[case(PT_CLSID)]	GUID			lpguid;
 		[case(PT_SRESTRICT)]	mapi_SRestriction_wrap 	Restrictions;
		[case(PT_ACTIONS)]	RuleAction		RuleAction;
  		[case(PT_BINARY)]	SBinary_short		bin;
		[case(PT_SVREID)]      	SBinary_short		bin;
		[case(PT_MV_LONG)]	mapi_MV_LONG_STRUCT	MVl;	
		[case(PT_MV_STRING8)]	mapi_SLPSTRArray	MVszA;
		[case(PT_MV_UNICODE)]	mapi_SPLSTRArrayW	MVszW;
		[case(PT_MV_CLSID)]	mapi_SGuidArray		MVguid;
		[case(PT_MV_BINARY)]	mapi_SBinaryArray      	MVbin;
	} mapi_SPropValue_CTR;

	typedef [public,flag(NDR_NOALIGN)] struct {
		MAPITAGS ulPropTag;
		[switch_is(ulPropTag & 0xFFFF)] mapi_SPropValue_CTR value; 
	} mapi_SPropValue;

	typedef [public,flag(NDR_NOALIGN)] struct {
		uint16					cValues;
		[flag(NDR_REMAINING)]mapi_SPropValue	lpProps[cValues];
	} mapi_SPropValue_array;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16					cValues;
		MAPITAGS				aulPropTag[cValues];
	} mapi_SPropTagArray;

	typedef [enum8bit, flag(NDR_PAHEX)] enum {
		ROW_ADD		=	0x1,
		ROW_MODIFY	=	0x2,
		ROW_REMOVE	=	0x4
	} ulRowFlags;

	typedef [flag(NDR_NOALIGN)] struct {
		ulRowFlags				ulRowFlags;
		mapi_SPropValue_array			lpProps;
	} mapi_SRow;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8					padding;
		uint16					cEntries;
		mapi_SRow				aEntries[cEntries];
	} mapi_SRowList;

	/**************************/
	/* EcDoRpc Function 0x1   */
	typedef [nopush,nopull,flag(NDR_NOALIGN)] struct {
	} Release_req;

	typedef [nopush,nopull,flag(NDR_NOALIGN)] struct {
	} Release_repl;

	/**************************/
	/* EcDoRpc Function 0x2   */
	typedef [enum8bit] enum {
		OpenModeFlags_Folder		= 0x0,
		OpenModeFlags_SoftDeleted	= 0x4
	} OpenFolder_OpenModeFlags;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8				handle_idx;
		hyper				folder_id;
 		OpenFolder_OpenModeFlags	OpenModeFlags;
	} OpenFolder_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16		ServerCount;
		uint16		CheapServerCount;
		astring		Servers[ServerCount];
	} OpenFolder_Replicas;

	typedef [nodiscriminant, flag(NDR_NOALIGN)] union {
		[case(0x0)];
		[case(0x1)] OpenFolder_Replicas	Replicas;
	} IsGhosted;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8		       	       	HasRules;
		boolean8			       	IsGhosted;
		[switch_is(IsGhosted)] IsGhosted	Ghost;
	} OpenFolder_repl;
	
	/**************************/
	/* EcDoRpc Function 0x3   */
	typedef [enum8bit] enum {
		StringType_NONE			= 0x0,
		StringType_EMPTY		= 0x1,
		StringType_STRING8		= 0x2,
		StringType_UNICODE_REDUCED	= 0x3,
		StringType_UNICODE		= 0x4
	} StringType;

	typedef [nodiscriminant, flag(NDR_NOALIGN)] union {
		[case(0x0)];
		[case(0x1)];
		[case(0x2)] astring			lpszA;
		[case(0x3)] astring			lpszW_reduced;
		[case(0x4)] [flag(STR_NULLTERM)] string	lpszW;
	} String;

	typedef [flag(NDR_NOALIGN)] struct {
		StringType			StringType;
		[switch_is(StringType)] String	String;
	} TypedString;

	typedef [bitmap8bit] bitmap {
		/* 0x0 means Read Only */
		ReadWrite	= 0x1,
		Create		= 0x3
	} OpenMessage_OpenModeFlags;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8				handle_idx;
		uint16				CodePageId;
		hyper				FolderId;
		OpenMessage_OpenModeFlags	OpenModeFlags;
		hyper				MessageId;
	} OpenMessage_req;

	typedef [v1_enum, flag(NDR_PAHEX)] enum {
		CP_USASCII	= 0x04E4,
		CP_UNICODE	= 0x04B0,
		CP_JAUTODETECT	= 0xC6F4,
		CP_KAUTODETECT	= 0xC705,
		CP_ISO2022JPESC = 0xC42D,
		CP_ISO2022JPSIO	= 0xC42E
	} CODEPAGEID;

	typedef [enum8bit, flag(NDR_PAHEX)] enum {
		MAPI_ORIG		= 0x0,
		MAPI_TO			= 0x1,
		MAPI_CC			= 0x2,
		MAPI_BCC		= 0x3
	} ulRecipClass;

	typedef [enum8bit, flag(NDR_PAHEX)] enum {
		SINGLE_RECIPIENT	= 0x0,
		DISTRIBUTION_LIST	= 0x1
	} addr_type;

	typedef  [flag(NDR_NOALIGN)]struct {
		uint8		organization_length;
		addr_type	addr_type;
		astring		username;
	} RecipExchange;

	typedef [flag(NDR_NOALIGN)] struct {
	} RecipSMTP;

	typedef [nodiscriminant, flag(NDR_NOALIGN)] union {
		[case(0x0)] RecipExchange	EXCHANGE;
		[case(0xA)] RecipSMTP		SMTP;
		[default];
	} recipient_type;

	typedef [nodiscriminant, flag(NDR_NOALIGN)] union {
		[case(0x0)];
		[case(0x400)] astring				lpszA;
		[case(0x600)][flag(STR_NULLTERM)] string	lpszW;
		[default];
	} recipient_SimpleDisplayName;

	typedef [nodiscriminant, flag(NDR_NOALIGN)] union {
		[case(0x0)];
		[case(0x20)] astring				lpszA;
		[case(0x220)][flag(STR_NULLTERM)] string	lpszW;
		[default];
	} recipient_TransmittableDisplayName;

	typedef [nodiscriminant, flag(NDR_NOALIGN)] union {
		[case(0x0)];
		[case(0x10)] astring				lpszA;
		[case(0x210)][flag(STR_NULLTERM)] string	lpszW;
		[default];
	} recipient_DisplayName;

	typedef [nodiscriminant, flag(NDR_NOALIGN)] union {
		[case(0x0)];
		[case(0x8)] astring				lpszA;
		[case(0x208)][flag(STR_NULLTERM)] string	lpszW;
		[default];
	} recipient_EmailAddress;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16									RecipientFlags;
		[switch_is(RecipientFlags & 0xA)]   recipient_type			type;
		[switch_is(RecipientFlags & 0x208)] recipient_EmailAddress	       	EmailAddress;
		[switch_is(RecipientFlags & 0x210)] recipient_DisplayName		DisplayName;
		[switch_is(RecipientFlags & 0x600)] recipient_SimpleDisplayName    	SimpleDisplayName;
		[switch_is(RecipientFlags & 0x220)] recipient_TransmittableDisplayName	TransmittableDisplayName;
		uint16									prop_count;
		uint8									layout;
		[flag(NDR_REMAINING)] DATA_BLOB						prop_values;
	} RecipientRow;

	typedef [flag(NDR_NOALIGN)] struct {
		ulRecipClass	RecipClass;
		CODEPAGEID	codepage;
		[subcontext(2)] RecipientRow	RecipientRow;
	} OpenMessage_recipients;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8		HasNamedProperties;
		TypedString		SubjectPrefix;
		TypedString		NormalizedSubject;
		uint16			RecipientCount;
		mapi_SPropTagArray	RecipientColumns;
		uint8			RowCount;
		OpenMessage_recipients	recipients[RowCount];
	} OpenMessage_repl;

	/**************************/
	/* EcDoRpc Function 0x4   */
	typedef [bitmap8bit] bitmap {
		TableFlags_Depth			= 0x4,
		TableFlags_DeferredErrors		= 0x8,
		TableFlags_NoNotifications		= 0x10,
		TableFlags_SoftDeletes			= 0x20,
		TableFlags_UseUnicode			= 0x40,
		TableFlags_SuppressNotifications	= 0x80
	} TableFlags;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8		handle_idx;
		TableFlags	TableFlags;
	} GetHierarchyTable_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint32		RowCount;
	} GetHierarchyTable_repl;

	/**************************/
	/* EcDoRpc Function 0x5   */
	typedef [flag(NDR_NOALIGN)] struct {
		uint8		handle_idx;
		TableFlags	TableFlags;
	} GetContentsTable_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint32		RowCount;
	} GetContentsTable_repl;

	/**************************/
	/* EcDoRpc Function 0x6   */
	typedef [flag(NDR_NOALIGN)] struct {
		uint8		handle_idx;
		uint16		CodePageId;
		hyper		FolderId;
		boolean8	AssociatedFlag;
	} CreateMessage_req;

	typedef [nodiscriminant, flag(NDR_NOALIGN)] union {
		[case(0x0)];
		[case(0x1)] hyper	MessageId;
	} CreateMessage_MessageId;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8						HasMessageId;
		[switch_is(HasMessageId)] CreateMessage_MessageId	MessageId;
	} CreateMessage_repl;

	/*************************/
	/* EcDoRpc Function 0x7  */
	typedef [flag(NDR_NOALIGN)] struct {
		uint16		PropertySizeLimit;
		uint16		WantUnicode;
		uint16		prop_count;
		MAPITAGS	properties[prop_count];
	} GetProps_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8		layout;
		[flag(NDR_REMAINING)] DATA_BLOB prop_data;
	} GetProps_repl;

	/*************************/
	/* EcDoRpc Function 0x8  */
	typedef [flag(NDR_NOALIGN)] struct {
		uint16		PropertySizeLimit;
		uint16		WantUnicode;
	} GetPropsAll_req;

	typedef [flag(NDR_NOALIGN)] struct {
		mapi_SPropValue_array	properties;
	} GetPropsAll_repl;

	/*************************/
	/* EcDoRpc Function 0x9  */
	typedef [flag(NDR_NOALIGN)] struct {
	} GetPropList_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16		count;
		MAPITAGS	tags[count];
	} GetPropList_repl;

	/*************************/
	/* EcDoRpc Function 0xa  */
	typedef [flag(NDR_NOALIGN)] struct {
	  	uint32		index; 		/* index into array of property tags */
		MAPITAGS	property_tag;	/* property for which there was an error */
		MAPISTATUS	error_code; 	/* the error that occurred for this property */
	} PropertyProblem;

	typedef [flag(NDR_NOALIGN)] struct {
 		[subcontext(2)] mapi_SPropValue_array values;
	} SetProps_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16		PropertyProblemCount;
		PropertyProblem	PropertyProblem[PropertyProblemCount];		
	} SetProps_repl;

	/*************************/
	/* EcDoRpc Function 0xb  */
	typedef [flag(NDR_NOALIGN)] struct {
		uint16		count;
		MAPITAGS	tags[count];
	} DeleteProps_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16		PropertyProblemCount;
		PropertyProblem	PropertyProblem[PropertyProblemCount];
	} DeleteProps_repl;

	/*************************/
	/* EcDoRpc Function 0xc  */
	typedef [enum8bit] enum {
		KeepOpenReadOnly	= 0x9,
		KeepOpenReadWrite	= 0xA,
		ForceSave		= 0xC
	} SaveFlags;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8		handle_idx;
		uint8		SaveFlags;
	} SaveChangesMessage_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8		handle_idx;
		hyper		MessageId;
	} SaveChangesMessage_repl;

	/*************************/
	/* EcDoRpc Function 0xd  */
	typedef [flag(NDR_NOALIGN)] struct {
		uint32		ulReserved;
	} RemoveAllRecipients_req;

	typedef [flag(NDR_NOALIGN)] struct {

	} RemoveAllRecipients_repl;

	/*************************/
	/* EcDoRpc Function 0xe  */

	/* 
	 * MODRECIP_NULL and INVALID are not part of the msdn flags
	 * but are added for printing support 
	 */
	typedef [enum8bit,flag(NDR_PAHEX)] enum {
		MODRECIP_NULL		= 0x0,
		MODRECIP_INVALID	= 0x1,
		MODRECIP_ADD		= 0x2,
		MODRECIP_MODIFY		= 0x4,
		MODRECIP_REMOVE		= 0x8
	} modrecip;

	typedef [flag(NDR_NOALIGN)]struct {
		uint32		idx;
		ulRecipClass	RecipClass;		
		[subcontext(2),flag(NDR_REMAINING)] RecipientRow RecipientRow;
	} ModifyRecipientRow;

	typedef [flag(NDR_NOALIGN)] struct {
 		uint16				prop_count;
 		MAPITAGS			properties[prop_count];
		uint16				cValues;
		ModifyRecipientRow     		RecipientRow[cValues];
	} ModifyRecipients_req;

	typedef [flag(NDR_NOALIGN)] struct {

	} ModifyRecipients_repl;

	/*************************/
	/* EcDoRpc Function 0xf  */
	typedef [flag(NDR_NOALIGN)] struct {
		uint32		RowId;
		uint16		ulReserved;
	} ReadRecipients_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint32				RowId;
		ulRecipClass			RecipientType;
		uint16				CodePageId;
		uint16				ulReserved;
		[subcontext(2)] RecipientRow	RecipientRow;
	} ReadRecipientRow;

	typedef [flag(NDR_NOALIGN)] struct {
 		uint8			RowCount;
 		ReadRecipientRow	RecipientRows[RowCount];
	} ReadRecipients_repl;

	/*************************/
	/* EcDoRpc Function 0x10 */
	typedef [flag(NDR_NOALIGN)] struct {
		ulRecipClass		RecipientType;
		uint16			CodePageId;
		uint16			Reserved;
		uint16			RecipientRowSize;
		[subcontext(0),subcontext_size(RecipientRowSize),flag(NDR_REMAINING)]RecipientRow      	RecipientRow;
	} OpenRecipientRow;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16		Reserved;
	} ReloadCachedInformation_req;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8		HasNamedProperties;
		TypedString		SubjectPrefix;
		TypedString		NormalizedSubject;
		uint16			RecipientCount;
		uint16			ColumnCount;
		MAPITAGS		RecipientColumns[ColumnCount];
		uint8			RowCount;
		OpenRecipientRow	RecipientRows[RowCount];
	} ReloadCachedInformation_repl;

	/*************************/
	/* EcDoRpc Function 0x11 */

	typedef [bitmap8bit] bitmap {
		SUPPRESS_RECEIPT	= 0x01,
		CLEAR_READ_FLAG		= 0x04,
		MAPI_DEFERRED_ERRORS	= 0x08,
		GENERATE_RECEIPT_ONLY	= 0x10,
		CLEAR_RN_PENDING	= 0x20,
	       	CLEAR_NRN_PENDING	= 0x40
	} MSGFLAG_READ;

	/* TODO: there is a variation that can provide "client data" here */
	typedef [flag(NDR_NOALIGN)] struct {
		uint8				handle_idx;
		MSGFLAG_READ			flags;
		[flag(NDR_REMAINING)] DATA_BLOB clientdata;
	} SetMessageReadFlag_req;

	typedef [nodiscriminant, flag(NDR_NOALIGN)] union {
		[case(0x0)];
		[case(0x1)] uint8	LogonId;
	} SetMessageReadFlag_LogonId;

	typedef [nodiscriminant, flag(NDR_NOALIGN)] union {
		[case(0x0)];
		[case(0x1)] uint8	ClientData[24];
	} SetMessageReadFlag_ClientData;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8							ReadStatusChanged;
		[switch_is(ReadStatusChanged)] SetMessageReadFlag_LogonId	LogonId;
		[switch_is(ReadStatusChanged)] SetMessageReadFlag_ClientData	ClientData;
	} SetMessageReadFlag_repl;

	/*************************/
	/* EcDoRpc Function 0x12 */
	typedef [enum8bit] enum {
		SetColumns_TBL_SYNC	= 0x0,
		SetColumns_TBL_ASYNC	= 0x1
	} SetColumnsFlags;
	
	typedef [enum8bit] enum {
		TBLSTAT_COMPLETE	= 0x0,
		TBLSTAT_SORTING		= 0x9,
		TBLSTAT_SORT_ERROR	= 0xA,
		TBLSTAT_SETTING_COLS	= 0xB,
		TBLSTAT_SETCOL_ERROR	= 0xD,
		TBLSTAT_RESTRICTING	= 0xE,
		TBLSTAT_RESTRICT_ERROR	= 0xF
	} TableStatus;

	typedef [flag(NDR_NOALIGN)] struct {
		SetColumnsFlags	SetColumnsFlags;
		uint16		prop_count;
		MAPITAGS	properties[prop_count];
	} SetColumns_req;

	typedef [flag(NDR_NOALIGN)] struct {
		TableStatus	TableStatus;
	} SetColumns_repl;

	/**************************/
	/* EcDoRpc Function 0x13  */
        typedef [enum8bit, flag(NDR_PAHEX)] enum {
                TBL_ASYNC = 0x1,
                TBL_BATCH = 0x2
        } TBL_FLAGS;
	
        typedef [enum8bit, flag(NDR_PAHEX)] enum {
                TABLE_SORT_ASCEND = 0x0,
                TABLE_SORT_COMBINE = 0x1,
                TABLE_SORT_DESCEND = 0x2
        } TABLE_SORT;

        typedef [public, flag(NDR_NOALIGN)] struct _SSortOrder{
                MAPITAGS ulPropTag;
                TABLE_SORT ulOrder;
        } SSortOrder;

	typedef [public, flag(NDR_NOALIGN)] struct _SSortOrderSet {
 		uint16		cSorts;
 		uint16		cCategories;
 		uint16		cExpanded;
		SSortOrder	aSort[cSorts];
	} SSortOrderSet;

        typedef [flag(NDR_NOALIGN)] struct {
		uint8		SortTableFlags;
		SSortOrderSet	lpSortCriteria;
        } SortTable_req;

	typedef [flag(NDR_NOALIGN)] struct {
		TableStatus	TableStatus;
	} SortTable_repl;

	/**************************/
	/* EcDoRpc Function 0x14  */
	typedef [flag(NDR_NOALIGN)] struct {
		uint16			cRes;
   		mapi_SRestriction_and	res[cRes];
	} mapi_SAndRestriction;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16	cRes;
    		mapi_SRestriction_or	res[cRes];
	} mapi_SOrRestriction;

	typedef [flag(NDR_NOALIGN)] struct {
		mapi_SRestriction_wrap	res;
	} mapi_SNotRestriction;

 	typedef [noprint, bitmap32bit] bitmap {
		FL_FULLSTRING		= 0x00000,
	       	FL_SUBSTRING		= 0x00001,
		FL_PREFIX		= 0x00002,
		FL_IGNORECASE		= 0x10000,
		FL_IGNORENONSPACE	= 0x20000,
		FL_LOOSE		= 0x40000
	} fuzzyLevel;

	typedef [flag(NDR_NOALIGN)] struct {
		fuzzyLevel	fuzzy;
		MAPITAGS	ulPropTag;
		mapi_SPropValue	lpProp;
	} mapi_SContentRestriction;

	typedef [enum8bit, flag(NDR_PAHEX)] enum {
		BMR_EQZ = 0x0,
		BMR_NEZ = 0x1
	} relMBR;

	typedef [flag(NDR_NOALIGN)] struct {
		relMBR		relMBR;
		MAPITAGS	ulPropTag;
		uint32		ulMask;
	} mapi_SBitmaskRestriction;

	typedef [enum8bit, flag(NDR_PAHEX)] enum {
		RELOP_LT = 0x0,		/* <  */
		RELOP_LE = 0x1,		/* <= */
		RELOP_GT = 0x2,		/* >  */
		RELOP_GE = 0x3,		/* >= */
		RELOP_EQ = 0x4,		/* == */
		RELOP_NE = 0x5,		/* != */
		RELOP_RE = 0x6		/* LIKE (Regular expression) */
	} CompareRelop;

	typedef [flag(NDR_NOALIGN)] struct {
		CompareRelop	relop;
		MAPITAGS	ulPropTag;
		uint32		size;
	} mapi_SSizeRestriction;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8		relop;
		MAPITAGS	ulPropTag;
		mapi_SPropValue	lpProp;
	} mapi_SPropertyRestriction;

	typedef [flag(NDR_NOALIGN)] struct {
		CompareRelop   	relop;
		MAPITAGS	ulPropTag1;
		MAPITAGS	ulPropTag2;
	} mapi_SCompareProps;

	typedef [flag(NDR_NOALIGN)] struct {
		MAPITAGS	ulPropTag;
	} mapi_SExistRestriction;

	typedef [flag(NDR_NOALIGN)] struct {
 		MAPITAGS	       	ulSubObject;
  		mapi_SRestriction_sub  	res[ulSubObject - ulSubObject + 1]; /* nasty hack - generates fake pointer */
	} mapi_SSubRestriction;

	typedef [nopush,nopull,noprint,nodiscriminant] union {
		[case(0x0)];
		[case(0x1)] mapi_SRestriction_comment *res;
	} RestrictionVariable;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8				TaggedValuesCount;
		mapi_SPropValue			TaggedValues[TaggedValuesCount];
		boolean8			RestrictionPresent;
		[switch_is(RestrictionPresent)] RestrictionVariable Restriction;
	} mapi_SCommentRestriction;

	typedef [public,nodiscriminant] union {
		[case(RES_AND)]			mapi_SAndRestriction		resAnd;
		[case(RES_OR)]			mapi_SOrRestriction		resOr;
 		[case(RES_NOT)]			mapi_SNotRestriction		resNot;
		[case(RES_CONTENT)]		mapi_SContentRestriction	resContent;
		[case(RES_PROPERTY)]		mapi_SPropertyRestriction	resProperty;
		[case(RES_COMPAREPROPS)]	mapi_SCompareProps		resCompareProps;
		[case(RES_BITMASK)]		mapi_SBitmaskRestriction	resBitmask;
		[case(RES_SIZE)]		mapi_SSizeRestriction		resSize;
		[case(RES_EXIST)]		mapi_SExistRestriction		resExist;
		[case(RES_SUBRESTRICTION)]	mapi_SSubRestriction		resSub;
		[case(RES_COMMENT)]		mapi_SCommentRestriction	resComment;
		[default];
	} mapi_SRestriction_CTR;

	typedef [public,flag(NDR_NOALIGN)] struct {
		uint8 rt;
		[switch_is(rt)] mapi_SRestriction_CTR res;
	} mapi_SRestriction;

	typedef [public,flag(NDR_NOALIGN)] struct _mapi_SRestriction {
		uint8 rt;
		[switch_is(rt)] mapi_SRestriction_CTR res;
	} mapi_SRestriction_and;

	typedef [public,flag(NDR_NOALIGN)] struct _mapi_SRestriction {
		uint8 rt;
		[switch_is(rt)] mapi_SRestriction_CTR res;
	} mapi_SRestriction_or;

	typedef [public,flag(NDR_NOALIGN)] struct _mapi_SRestriction {
		uint8 rt;
		[switch_is(rt)] mapi_SRestriction_CTR res;
	} mapi_SRestriction_sub;

	typedef [public,flag(NDR_NOALIGN)] struct _mapi_SRestriction {
		uint8 rt;
		[switch_is(rt)] mapi_SRestriction_CTR res;
	} mapi_SRestriction_comment;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8 handle_idx;
		[subcontext(2)] mapi_SRestriction  restrictions;
	} Restrict_req;

	typedef [flag(NDR_NOALIGN)] struct {
		TableStatus	TableStatus;
	} Restrict_repl;

	/**************************/
	/* EcDoRpc Function 0x15  */
	typedef [enum8bit] enum {
		TBL_ADVANCE		= 0x0,
		TBL_NOADVANCE		= 0x1,
		TBL_ENABLEPACKEDBUFFERS = 0x2
	} QueryRowsFlags;

	typedef [flag(NDR_NOALIGN)] struct {
		QueryRowsFlags	QueryRowsFlags;
		uint8		ForwardRead;
		uint16		RowCount;
	} QueryRows_req;

	typedef [nopush,nopull,flag(NDR_NOALIGN)] struct {
		uint8		Origin;
		uint16		RowCount;
		[flag(NDR_REMAINING)]DATA_BLOB	RowData;
	} QueryRows_repl;

	/**************************/
	/* EcDoRpc Function 0x16  */
	typedef [flag(NDR_NOALIGN)] struct {
	} GetStatus_req;

	typedef [flag(NDR_NOALIGN)] struct {
		TableStatus	TableStatus;
	} GetStatus_repl;

	/**************************/
	/* EcDoRpc Function 0x17  */
	typedef [flag(NDR_NOALIGN)] struct {
	} QueryPosition_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint32	Numerator;
		uint32	Denominator;
	} QueryPosition_repl;

	/**************************/
	/* EcDoRpc Function 0x18  */
	typedef [enum8bit] enum {
		BOOKMARK_BEGINNING	= 0x0,
		BOOKMARK_CURRENT	= 0x1,
		BOOKMARK_END		= 0x2,
		BOOKMARK_USER		= 0x3
	} BOOKMARK;

	typedef [flag(NDR_NOALIGN)] struct {
		BOOKMARK	origin;
		int32		offset;
		boolean8	WantRowMovedCount;
	} SeekRow_req;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8	HasSoughtLess;
		uint32		RowsSought;
	} SeekRow_repl;

	/**************************/
	/* EcDoRpc Function 0x19  */
	typedef [flag(NDR_NOALIGN)] struct {
		SBinary_short	Bookmark;
		uint32		RowCount;
		boolean8	WantRowMovedCount;
	} SeekRowBookmark_req;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8	RowNoLongerVisible;
		boolean8	HasSoughtLess;
		uint32		RowsSought;
	} SeekRowBookmark_repl;

	/**************************/
	/* EcDoRpc Function 0x1a  */
	typedef [flag(NDR_NOALIGN)] struct {
		uint32		ulNumerator;
		uint32		ulDenominator;
	} SeekRowApprox_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} SeekRowApprox_repl;
	
	/**************************/
	/* EcDoRpc Function 0x1b  */
	typedef [flag(NDR_NOALIGN)] struct {
	} CreateBookmark_req;

	typedef [flag(NDR_NOALIGN)] struct {
		SBinary_short	bookmark;
	} CreateBookmark_repl;

	/**************************/
	/* EcDoRpc Function 0x1c  */
	typedef [enum8bit] enum {
		FOLDER_GENERIC	= 0x1,
		FOLDER_SEARCH	= 0x2
	} FOLDER_TYPE;

	typedef [enum8bit] enum {
		MAPI_FOLDER_ANSI       	= 0x0,
		MAPI_FOLDER_UNICODE    	= 0x1
	} FOLDER_STRING;

	typedef [nodiscriminant, flag(NDR_NOALIGN)] union {
		[case(MAPI_FOLDER_ANSI)] astring			lpszA;
		[case(MAPI_FOLDER_UNICODE)][flag(STR_NULLTERM)] string	lpszW;
	} LPTSTR;

	typedef [enum16bit] enum {
		NONE		= 0x0000,
		OPEN_IF_EXISTS	= 0x0001
	} FOLDER_FLAGS;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8				handle_idx;
		FOLDER_TYPE			ulFolderType;
		FOLDER_STRING			ulType;
		FOLDER_FLAGS	       		ulFlags;
		[switch_is(ulType)] LPTSTR	FolderName;
		[switch_is(ulType)] LPTSTR	FolderComment;
	} CreateFolder_req;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8				HasRules;
		boolean8				IsGhosted;
		[switch_is(IsGhosted)] IsGhosted	Ghost;
	} CreateFolder_GhostInfo;

	typedef [nodiscriminant, flag(NDR_NOALIGN)] union {
		[case(0x0)];
		[case(0x1)] CreateFolder_GhostInfo	GhostInfo;
	} CreateFolder_GhostUnion;

	typedef [flag(NDR_NOALIGN)] struct {
		hyper							folder_id;
		boolean8						IsExistingFolder;
		[switch_is(IsExistingFolder)]	CreateFolder_GhostUnion	GhostUnion;
	} CreateFolder_repl;

	/**************************/
	/* EcDoRpc Function 0x1d  */
	typedef [bitmap8bit] bitmap {
		DEL_MESSAGES		= 0x1,
		DEL_FOLDERS		= 0x4,
		DELETE_HARD_DELETE	= 0x10
	} DeleteFolderFlags;

	typedef [flag(NDR_NOALIGN)] struct {
		DeleteFolderFlags      	DeleteFolderFlags;
		hyper			FolderId;
	} DeleteFolder_req;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8		PartialCompletion;
	} DeleteFolder_repl;

	/**************************/
	/* EcDoRpc Function 0x1e  */
	typedef [flag(NDR_NOALIGN)] struct {
		boolean8	WantAsynchronous;
		boolean8	NotifyNonRead;
		uint16		cn_ids;
		hyper		message_ids[cn_ids];
	} DeleteMessages_req;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8	PartialCompletion;
	} DeleteMessages_repl;

	/**************************/
	/* EcDoRpc Function 0x1f  */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper		msgid;
	} GetMessageStatus_req;

	/**************************/
	/* EcDoRpc Function 0x20  */
	typedef [bitmap32bit] bitmap {
		MSGSTATUS_HIGHLIGHTED		= 0x1,
		MSGSTATUS_TAGGED		= 0x2,
		MSGSTATUS_HIDDEN		= 0x4,
	        MSGSTATUS_DELMARKED		= 0x8,
		MSGSTATUS_REMOTE_DOWNLOAD	= 0x1000,
		MSGSTATUS_REMOTE_DELETE		= 0x2000
	} ulMessageStatus;


	typedef [flag(NDR_NOALIGN)] struct {
		hyper		msgid;
		uint32		ulNewStatus;
		ulMessageStatus	ulNewStatusMask;
	} SetMessageStatus_req;

	typedef [flag(NDR_NOALIGN)] struct {
		ulMessageStatus	ulOldStatus;
	} SetMessageStatus_repl;

	/**************************/
	/* EcDoRpc Function 0x21  */
	typedef [flag(NDR_NOALIGN)] struct {
		uint8		handle_idx;
		TableFlags	TableFlags;
	} GetAttachmentTable_req;

	typedef [flag(NDR_NOALIGN)] struct {		
	} GetAttachmentTable_repl;

	/*************************/
	/* EcDoRpc Function 0x22 */
	typedef [enum8bit] enum {
		OpenAttachmentFlags_ReadOnly	= 0x0,
		OpenAttachmentFlags_ReadWrite	= 0x1,
		OpenAttachmentFlags_BestAccess	= 0x3
	} OpenAttachmentFlags;

  	typedef [flag(NDR_NOALIGN)] struct {
		uint8			handle_idx;
		OpenAttachmentFlags	OpenAttachmentFlags;
		uint32			AttachmentID;
	} OpenAttach_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} OpenAttach_repl;

	/*************************/
	/* EcDoRpc Function 0x23 */
	typedef [flag(NDR_NOALIGN)] struct {
		uint8	handle_idx;
	} CreateAttach_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint32	AttachmentID;
	} CreateAttach_repl;

	/*************************/
	/* EcDoRpc Function 0x24 */
	typedef [flag(NDR_NOALIGN)] struct {
		uint32		AttachmentID;
	} DeleteAttach_req;


	typedef [flag(NDR_NOALIGN)] struct {
	} DeleteAttach_repl;

	/*************************/
	/* EcDoRpc Function 0x25 */
	typedef [flag(NDR_NOALIGN)] struct {
		uint8		handle_idx;
		SaveFlags	SaveFlags;
	} SaveChangesAttachment_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} SaveChangesAttachment_repl;

	/*************************/
	/* EcDoRpc Function 0x26 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper		fid;
		astring		lpszMessageClass;
	} SetReceiveFolder_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} SetReceiveFolder_repl;

	/*************************/
	/* EcDoRpc Function 0x27 */
	typedef [flag(NDR_NOALIGN)] struct {
		astring		MessageClass;
	} GetReceiveFolder_req;

	typedef [flag(NDR_NOALIGN)] struct {
		hyper		folder_id;
		astring		MessageClass;
	} GetReceiveFolder_repl;

	/*************************/
	/* EcDoRpc Function 0x29 */
	typedef [bitmap16bit] bitmap {
		fnevCriticalError		= 0x0001,
		fnevNewMail			= 0x0002,
		fnevObjectCreated		= 0x0004,
		fnevObjectDeleted		= 0x0008,
		fnevObjectModified		= 0x0010,
		fnevObjectMoved			= 0x0020,
		fnevObjectCopied		= 0x0040,
		fnevSearchComplete		= 0x0080,
		fnevTableModified		= 0x0100,
		fnevStatusObjectModified	= 0x0200,
		fnevReserved			= 0x0400,
		fnevTbit       			= 0x1000,
		fnevUbit			= 0x2000,
		fnevSbit			= 0x4000,
		fnevMbit			= 0x8000
	} NotificationFlags;

	typedef [nodiscriminant,flag(NDR_NOALIGN)] union {
		[case(0x0)] hyper	ID;
		[case(0x1)];
	} hyperbool;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8					handle_idx;
		NotificationFlags			NotificationFlags;
		boolean8				WantWholeStore;
		[switch_is(WantWholeStore)] hyperbool	FolderId;
		[switch_is(WantWholeStore)] hyperbool	MessageId;
	} RegisterNotification_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} RegisterNotification_repl;

	/*************************/
	/* EcDoRpc Function 0x2a */
	typedef [bitmap32bit] bitmap {
		MSGFLAG_READ		= 0x1,
		MSGFLAG_UNMODIFIED	= 0x2,
		MSGFLAG_SUBMIT		= 0x4,
		MSGFLAG_UNSENT		= 0x8,
		MSGFLAG_HASATTACH	= 0x10,
		MSGFLAG_FROMME		= 0x20,
		MSGFLAG_ASSOCIATED	= 0x40,
		MSGFLAG_RESEND		= 0x80,
		MSGFLAG_RN_PENDING	= 0x100,
	        MSGFLAG_NRN_PENDING	= 0x200
	} MsgFlags;

	typedef [nodiscriminant, flag(NDR_NOALIGN)] union {
		[case(0x0)] astring			lpszA;
		[case(0x1)][flag(STR_NULLTERM)] string	lpszW;
	} MessageClass;

	typedef [flag(NDR_NOALIGN)] struct {
		GUID		DatabaseGUID;
		uint8		GlobalCounter[6];
	} GID;

	typedef [enum16bit] enum {
		TABLE_CHANGED		=	0x1,
		TABLE_ROW_ADDED		=	0x3,
		TABLE_ROW_DELETED	=	0x4,
		TABLE_ROW_MODIFIED	=	0x5,
		TABLE_RESTRICT_DONE	=	0x7
	} RichTableNotificationType;

	/* NewMailNotification: case 0x2 and 0x8002 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper					FID;
		hyper					MID;
		MsgFlags				MessageFlags;
		boolean8				UnicodeFlag;
		[switch_is(UnicodeFlag)] MessageClass	MessageClass;
	} NewMailNotification;

	/* FolderCreatedNotification: case 0x4 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper					FID;
		hyper					ParentFID;
		uint16					TagCount;
		MAPITAGS				Tags[TagCount];
	} FolderCreatedNotification;

	/* FolderDeletedNotification: case 0x8 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper					FID;
		hyper					ParentFID;
	} FolderDeletedNotification;

	/* FolderModifiedNotification: case 0x10 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper			FID;
		uint16			TagCount;
		MAPITAGS		Tags[TagCount];
	} FolderModifiedNotification_10;

	/* FolderMoveCopyNotification: case 0x20 and 0x40 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper			FID;
		hyper			ParentFID;
		hyper			OldFID;
		hyper			OldParentFID;
	} FolderMoveCopyNotification;

	/* SearchCompleteNotification: case 0x80 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper			FID;
	} SearchCompleteNotification;

	/* HierarchyTable: case 0x100 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper				FID;
		hyper				InsertAfterFID;
		[subcontext(2)] DATA_BLOB	Columns;
	} HierarchyRowAddedNotification;

	typedef [flag(NDR_NOALIGN)] struct {
		hyper				FID;
	} HierarchyRowDeletedNotification;
	
	typedef [flag(NDR_NOALIGN)] struct {
		hyper				FID;
		hyper				InsertAfterFID;
		[subcontext(2)] DATA_BLOB	Columns;
	} HierarchyRowModifiedNotification;

	typedef [nodiscriminant] union {
		[case(TABLE_ROW_ADDED)] HierarchyRowAddedNotification		HierarchyRowAddedNotification;
		[case(TABLE_ROW_DELETED)] HierarchyRowDeletedNotification	HierarchyRowDeletedNotification;
		[case(TABLE_ROW_MODIFIED)] HierarchyRowModifiedNotification	HierarchyRowModifiedNotification;
		[default];
	} HierarchyTableChangeUnion;

	typedef [flag(NDR_NOALIGN)] struct {
		RichTableNotificationType				TableEvent;
		[switch_is(TableEvent)] HierarchyTableChangeUnion	HierarchyTableChangeUnion;
	} HierarchyTableChange;

	/* IcsNotification: case 0x200 */
	typedef [flag(NDR_NOALIGN)] struct {
		boolean8       		HierChanged;
		uint32			GIDCount;
		GID			GID[GIDCount];
	} IcsNotification;

	/* FolderModifiedNotification: case 0x1010 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper			FID;
		uint16			TagCount;
		MAPITAGS		Tags[TagCount];
		uint32			TotalMessageCount;
	} FolderModifiedNotification_1010;

	/* FolderModifiedNotification: case 0x2010 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper			FID;
		uint16			TagCount;
		MAPITAGS		Tags[TagCount];
		uint32			UnreadMessageCount;
	} FolderModifiedNotification_2010;

	/* FolderModifiedNotification: case 0x3010 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper			FID;
		uint16			TagCount;
		MAPITAGS		Tags[TagCount];
		uint32			TotalMessageCount;
		uint32			UnreadMessageCount;
	} FolderModifiedNotification_3010;

	/* MessageCreatedNotification: case 0x8004 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper					FID;
		hyper					MID;
		uint16					TagCount;
		MAPITAGS				Tags[TagCount];
	} MessageCreatedNotification;

	/* MessageDeletedNotification: case 0x8008 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper					FID;
		hyper					MID;
	} MessageDeletedNotification;

	/* MessageModifiedNotification: case 0x8010 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper					FID;
		hyper					MID;
		uint16					TagCount;
		MAPITAGS				Tags[TagCount];
	} MessageModifiedNotification;

	/* MessageMoveCopyNotification: case 0x8020 and 0x8040 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper			FID;
		hyper			MID;
		hyper			OldFID;
		hyper			OldMID;
	} MessageMoveCopyNotification;	

	/* ContentsTableChange: case 0x8100 and 0xc100 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper				FID;
		hyper				MID;
		uint32				Instance;
		hyper				InsertAfterFID;
		hyper				InsertAfterMID;
		uint32				InsertAfterInstance;
		[subcontext(2)] DATA_BLOB	Columns;
	} ContentsRowAddedNotification;

	typedef [flag(NDR_NOALIGN)] struct {
		hyper				FID;
		hyper				MID;
		uint32				Instance;
	} ContentsRowDeletedNotification;

	typedef [flag(NDR_NOALIGN)] struct {
		hyper				FID;
		hyper				MID;
		uint32				Instance;
		hyper				InsertAfterFID;
		hyper				InsertAfterMID;
		uint32				InsertAfterInstance;
		[subcontext(2)] DATA_BLOB	Columns;
	} ContentsRowModifiedNotification;

	typedef [nodiscriminant] union {
		[case(TABLE_ROW_ADDED)] ContentsRowAddedNotification		ContentsRowAddedNotification;
		[case(TABLE_ROW_DELETED)] ContentsRowDeletedNotification	ContentsRowDeletedNotification;
		[case(TABLE_ROW_MODIFIED)] ContentsRowModifiedNotification	ContentsRowModifiedNotification;
		[default];
	} ContentsTableChangeUnion;

	typedef [flag(NDR_NOALIGN)] struct {
		RichTableNotificationType				TableEvent;
		[switch_is(TableEvent)] ContentsTableChangeUnion	ContentsTableChangeUnion;
	} ContentsTableChange;

	/* SearchMessageCreatedNotification: case 0xc004 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper					FID;
		hyper					MID;
		hyper					SearchFID;
		uint16					TagCount;
		MAPITAGS				Tags[TagCount];
	} SearchMessageCreatedNotification;

	/* SearchMessageRemovedNotification: case 0xc008 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper					FID;
		hyper					MID;
		hyper					SearchFID;
	} SearchMessageRemovedNotification;

	/* SearchMessageModifiedNotification: 0xc010 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper					FID;
		hyper					MID;
		uint16					TagCount;
		MAPITAGS				Tags[TagCount];
	} SearchMessageModifiedNotification;

	typedef [nodiscriminant] union {
		[case(0x0002)] NewMailNotification			NewMailNotification;
		[case(0x0004)] FolderCreatedNotification		FolderCreatedNotification;
		[case(0x0008)] FolderDeletedNotification		FolderDeletedNotification;
		[case(0x0010)] FolderModifiedNotification_10		FolderModifiedNotification_10;
		[case(0x0020)] FolderMoveCopyNotification		FolderMoveNotification;
		[case(0x0040)] FolderMoveCopyNotification		FolderCopyNotification;
		[case(0x0080)] SearchCompleteNotification		SearchCompleteNotification;
		[case(0x0100)] HierarchyTableChange			HierarchyTableChange;
		[case(0x0200)] IcsNotification				IcsNotification;
		[case(0x1010)] FolderModifiedNotification_1010		FolderModifiedNotification_1010;
		[case(0x2010)] FolderModifiedNotification_2010		FolderModifiedNotification_2010;
		[case(0x3010)] FolderModifiedNotification_3010		FolderModifiedNotification_3010;
 		[case(0x8002)] NewMailNotification			NewMessageNotification;
		[case(0x8004)] MessageCreatedNotification		MessageCreatedNotification;
		[case(0x8008)] MessageDeletedNotification		MessageDeletedNotification;
		[case(0x8010)] MessageModifiedNotification		MessageModifiedNotification;
		[case(0x8020)] MessageMoveCopyNotification		MessageMoveNotification;
		[case(0x8040)] MessageMoveCopyNotification		MessageCopyNotification;
		[case(0x8100)] ContentsTableChange			ContentsTableChange;
		[case(0xc004)] SearchMessageCreatedNotification		SearchMessageCreatedNotification;
		[case(0xc008)] SearchMessageRemovedNotification		SearchMessageRemovedNotification;
		[case(0xc010)] SearchMessageModifiedNotification	SearchMessageModifiedNotification;
		[case(0xc100)] ContentsTableChange			SearchTableChange;
	} NotificationData;

	typedef [flag(NDR_NOALIGN)] struct {
		uint32						NotificationHandle;
		uint8						LogonId;
		NotificationFlags				NotificationType;
		[switch_is(NotificationType)] NotificationData	NotificationData;
	} Notify_repl;

	/*************************/
	/* EcDoRpc Function 0x2b */
	typedef [enum8bit] enum {
		OpenStream_ReadOnly	= 0x0,
		OpenStream_ReadWrite	= 0x1,
		OpenStream_Create	= 0x2,
		OpenStream_BestAccess	= 0x3
	} OpenStream_OpenModeFlags;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8				handle_idx;
		MAPITAGS			PropertyTag;
		OpenStream_OpenModeFlags       	OpenModeFlags;
	} OpenStream_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint32		StreamSize;
	} OpenStream_repl;

	/*************************/
	/* EcDoRpc Function 0x2c */
	typedef [nodiscriminant, flag(NDR_NOALIGN)] union {
		[case(0xBABE)] uint32	value;
		[default];
	} MaximumByteCount;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16						ByteCount;
		[switch_is(ByteCount)]	MaximumByteCount	MaximumByteCount;
	} ReadStream_req;

	typedef [flag(NDR_ALIGN2)] struct {
		[subcontext(2), flag(NDR_REMAINING)] DATA_BLOB data;
	} ReadStream_repl;

	/*************************/
	/* EcDoRpc Function 0x2d */
	typedef [flag(NDR_NOALIGN)] struct {
		[subcontext(2), flag(NDR_REMAINING)] DATA_BLOB	data;
	} WriteStream_req;


	typedef [flag(NDR_NOALIGN)] struct {
		uint16		WrittenSize;
	} WriteStream_repl;

	/*************************/
	/* EcDoRpc Function 0x2e */
	typedef [flag(NDR_NOALIGN)] struct {
		uint8		Origin;
		hyper		Offset;
	} SeekStream_req;

	typedef [flag(NDR_NOALIGN)] struct {
		hyper		NewPosition;
	} SeekStream_repl;

	/*************************/
	/* EcDoRpc Function 0x2f */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper		SizeStream;
	} SetStreamSize_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} SetStreamSize_repl;

	/*************************/
	/* EcDoRpc Function 0x30 */
	typedef [bitmap32bit, flag(NDR_PAHEX)] bitmap {
		STOP_SEARCH			= 0x00000001,
		RESTART_SEARCH			= 0x00000002,
		RECURSIVE_SEARCH		= 0x00000004,
		SHALLOW_SEARCH			= 0x00000008,
		FOREGROUND_SEARCH		= 0x00000010,
		BACKGROUND_SEARCH		= 0x00000020,
	        CONTENT_INDEXED_SEARCH		= 0x00010000,
		NON_CONTENT_INDEXED_SEARCH	= 0x00020000,
		STATIC_SEARCH			= 0x00040000
	} SearchFlags;

	typedef [flag(NDR_NOALIGN)] struct {
		[subcontext(2)] mapi_SRestriction	res;
		uint16					FolderIdCount;
		hyper					FolderIds[FolderIdCount];
		SearchFlags				SearchFlags;
	} SetSearchCriteria_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} SetSearchCriteria_repl;

	/*************************/
	/* EcDoRpc Function 0x31 */
	typedef [flag(NDR_NOALIGN)] struct {
		boolean8	UseUnicode;
		boolean8	IncludeRestriction;
		boolean8	IncludeFolders;
	} GetSearchCriteria_req;

	typedef [flag(NDR_NOALIGN)] struct {
		[subcontext(2)] mapi_SRestriction	res;
 		uint8					unknown;
		uint16					FolderIdCount;
		hyper					FolderIds[FolderIdCount];
		SearchFlags				SearchFlags;
	} GetSearchCriteria_repl;

	/*************************/
	/* EcDoRpc Function 0x32 */
	typedef [enum8bit] enum {
		None		= 0x0,	/* None */
		PreProcess	= 0x1,	/* Needs to be preprocessed by the server */
		NeedsSpooler	= 0x2	/* Is to be processed by a client spooler */
	} SubmitFlags;

	typedef [flag(NDR_NOALIGN)] struct {
		SubmitFlags    	SubmitFlags;
	} SubmitMessage_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} SubmitMessage_repl;

	/*************************/
	/* EcDoRpc Function 0x33 */
	typedef [flag(NDR_NOALIGN)] struct {
 		uint8		handle_idx;
 		uint16		count;
 		hyper		message_id[count];
		boolean8	WantAsynchronous;
		boolean8	WantCopy;
	} MoveCopyMessages_req;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8       	PartialCompletion;
	} MoveCopyMessages_repl;

	/*************************/
	/* EcDoRpc Function 0x34 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper		FolderId;
		hyper		MessageId;
	} AbortSubmit_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} AbortSubmit_repl;

	/*************************/
	/* EcDoRpc Function 0x35 */
	typedef [nodiscriminant, flag(NDR_NOALIGN)] union {
		[case(0x0)] astring			lpszA;
		[case(0x1)][flag(STR_NULLTERM)] string	lpszW;
	} Folder_name;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8					handle_idx;
		boolean8				WantAsynchronous;
		boolean8				UseUnicode;
		hyper					FolderId;
		[switch_is(UseUnicode)] Folder_name	NewFolderName;
	} MoveFolder_req;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8				PartialCompletion;
	} MoveFolder_repl;

	/*************************/
	/* EcDoRpc Function 0x36 */
	typedef [flag(NDR_NOALIGN)] struct {
		uint8					handle_idx;
		boolean8				WantAsynchronous;
		boolean8				WantRecursive;
		boolean8				UseUnicode;
		hyper					FolderId;
		[switch_is(UseUnicode)] Folder_name	NewFolderName;
	} CopyFolder_req;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8				PartialCompletion;
	} CopyFolder_repl;

	/*************************/
	/* EcDoRpc Function 0x37 */
	typedef [flag(NDR_NOALIGN)] struct {
	} QueryColumnsAll_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16		PropertyTagCount;
		MAPITAGS	PropertyTags[PropertyTagCount];
	} QueryColumnsAll_repl;

	/*************************/
	/* EcDoRpc Function 0x38 */
	typedef [flag(NDR_NOALIGN)] struct {
	} Abort_req;

	typedef [flag(NDR_NOALIGN)] struct {
		TableStatus	TableStatus;
	} Abort_repl;

	/*************************/
	/* EcDoRpc Function 0x39 */
	typedef [bitmap8bit] bitmap {
		CopyFlagsMove		= 0x1,	/* Move properties */
		CopyFlagsNoOverwrite	= 0x2	/* Do not overwrite existing properties */
	} CopyFlags;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8			handle_idx;
		boolean8		WantAsynchronous;
		boolean8		WantSubObjects;
		CopyFlags		CopyFlags;
		mapi_SPropTagArray	ExcludedTags;
	} CopyTo_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16		PropertyProblemCount;
		PropertyProblem	PropertyProblem[PropertyProblemCount];
	} CopyTo_repl;

	/*************************/
	/* EcDoRpc Function 0x3a */
	typedef [flag(NDR_NOALIGN)] struct {
		uint8		handle_idx;
		hyper		ByteCount;
	} CopyToStream_req;

	typedef [flag(NDR_NOALIGN)] struct {
		hyper		ReadByteCount;
		hyper		WrittenByteCount;
	} CopyToStream_repl;

	/*************************/
	/* EcDoRpc Function 0x3b */
	typedef [flag(NDR_NOALIGN)] struct {
		uint8		handle_idx;
	} CloneStream_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} CloneStream_repl;

	/*************************/
	/* EcDoRpc Function 0x3e */
	typedef [flag(NDR_NOALIGN)] struct {
		uint8		handle_idx;
		uint8		padding;
	} GetTable_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} GetTable_repl;

	/*************************/
	/* EcDoRpc Function 0x3f */
	typedef [bitmap8bit] bitmap {
		RulesTableFlags_Unicode	= 0x40
	} RulesTableFlags;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8		handle_idx;
		RulesTableFlags	TableFlags;
	} GetRulesTable_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} GetRulesTable_repl;

	/*************************/
	/* EcDoRpc Function 0x40 */
	typedef [flag(NDR_NOALIGN)] struct {
 		mapi_SRowList		rowList;
	} ModifyTable_req;

	typedef [flag(NDR_NOALIGN)] struct {
		[flag(NDR_REMAINING)] DATA_BLOB remaining;
	} ModifyTable_repl;

	/*************************/
	/* EcDoRpc Function 0x41 */
	typedef [flag(NDR_NOALIGN)] struct {
		ulRowFlags     		RuleDataFlags;
		mapi_SPropValue_array	PropertyValues;
	} RuleData;

	typedef [bitmap8bit] bitmap {
		ModifyRulesFlag_Replace	= 0x01
	} ModifyRulesFlag;

	typedef [flag(NDR_NOALIGN)] struct {
		ModifyRulesFlag	ModifyRulesFlags;
		uint16		RulesCount;
 		RuleData	RulesData[RulesCount];
	} ModifyRules_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} ModifyRules_repl;

	/*************************/
	/* EcDoRpc Function 0x42 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper		FolderId;
	} GetOwningServers_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16		OwningServersCount;
		uint16		CheapServersCount;
		astring		OwningServers[OwningServersCount];
	} GetOwningServers_repl;

	/*************************/
	/* EcDoRpc Function 0x43 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper	Id;
	} LongTermIdFromId_req;

	typedef [flag(NDR_NOALIGN)] struct {
		GUID	DatabaseGuid;
		uint8	GlobalCounter[6];
		uint16	padding;
	} LongTermId;

	typedef [flag(NDR_NOALIGN)] struct {
		LongTermId	LongTermId;
	} LongTermIdFromId_repl;

	/*************************/
	/* EcDoRpc Function 0x44 */
	typedef [flag(NDR_NOALIGN)] struct {
		LongTermId	LongTermId;
	} IdFromLongTermId_req;

	typedef [flag(NDR_NOALIGN)] struct {
		hyper		Id;
	} IdFromLongTermId_repl;

	/*************************/
	/* EcDoRpc Function 0x45 */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper		FolderId;
	} PublicFolderIsGhosted_req;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8				IsGhosted;
		[switch_is(IsGhosted)] IsGhosted	Ghost;
	} PublicFolderIsGhosted_repl;

	/*************************/
	/* EcDoRpc Function 0x46 */
	typedef [enum8bit, flag(NDR_PAHEX)] enum {
		MAPI_READONLY   = 0x0,
		MAPI_READWRITE	= 0x1,
		MAPI_CREATE	= 0x2
	} OpenEmbeddedMessage_OpenModeFlags;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8					handle_idx;
		uint16					CodePageId;
		OpenEmbeddedMessage_OpenModeFlags	OpenModeFlags;
	} OpenEmbeddedMessage_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8		       	Reserved;
		hyper		       	MessageId;
		boolean8	       	HasNamedProperties;
		TypedString	       	SubjectPrefix;
		TypedString	       	NormalizedSubject;
		uint16		       	RecipientCount;
		uint16		       	ColumnCount;
		MAPITAGS	       	RecipientColumns[ColumnCount];
		uint8		       	RowCount;
		OpenRecipientRow       	RecipientRows[RowCount];
	} OpenEmbeddedMessage_repl;

	/*************************/
	/* EcDoRpc Function 0x47 */
	typedef [flag(NDR_NOALIGN)] struct {
	} SetSpooler_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} SetSpooler_repl;

	/*************************/
	/* EcDoRpc Function 0x48 */
	typedef [enum8bit] enum {
		LockState_1stLock      	= 0x0,
		LockState_1stUnlock	= 0x1,
		LockState_1stFinished	= 0x2
	} LockState;

	typedef [flag(NDR_NOALIGN)] struct {
		hyper		MessageId;
		LockState	LockState;
	} SpoolerLockMessage_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} SpoolerLockMessage_repl;

	/*************************/
	/* EcDoRpc Function 0x49 */
	typedef [flag(NDR_NOALIGN)] struct {
	} AddressTypes_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16 		cValues;
		uint16 		size;
		mapi_LPSTR	transport[cValues];
	} AddressTypes_repl;

	/**************************/
	/* EcDoRpc Function 0x4a  */
	typedef [flag(NDR_NOALIGN)] struct {
	} TransportSend_req;

	typedef [nodiscriminant] union {
		[case(0x0)] mapi_SPropValue_array	lpProps;
		[case(0x1)];
	} TransportSend_lpProps;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8						NoPropertiesReturned;
		[switch_is(NoPropertiesReturned)] TransportSend_lpProps	properties;
	} TransportSend_repl;

	/**************************/
	/* EcDoRpc Function 0x4e  */
	typedef [flag(NDR_NOALIGN)] struct {
		uint16		BufferSize;
	} FastTransferSourceGetBuffer_req;

	typedef [enum16bit] enum {
		TransferStatus_Error	= 0x0,
		TransferStatus_Partial	= 0x1,
		TransferStatus_NoRoom	= 0x2,
		TransferStatus_Done	= 0x3
	} TransferStatus;

	typedef [flag(NDR_NOALIGN)] struct {
		TransferStatus	TransferStatus;
		uint16		InProgressCount;
		uint16		TotalStepCount;
		uint8		Reserved;
		uint16		TransferBufferSize;
		[subcontext(0),subcontext_size(TransferBufferSize),flag(NDR_REMAINING)] DATA_BLOB TransferBuffer;
	} FastTransferSourceGetBuffer_repl;

	/**************************/
	/* EcDoRpc Function 0x4f  */
	typedef [enum8bit] enum {
		DIR_FORWARD  = 0x0,
		DIR_BACKWARD = 0x1
	} FindRow_ulFlags;

	typedef [flag(NDR_NOALIGN)] struct {
		FindRow_ulFlags	ulFlags;
  		[subcontext(2)] mapi_SRestriction res;
		BOOKMARK	origin;
		SBinary_short	bookmark;
	} FindRow_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8		RowNoLongerVisible;
	  	uint8		HasRowData;
		[flag(NDR_NOALIGN)] DATA_BLOB row;
	} FindRow_repl;

	/**************************/
	/* EcDoRpc Function 0x50  */
	typedef [flag(NDR_NOALIGN)] struct {
		boolean8	WantCancel;
	} Progress_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint32		CompletedTaskCount;
		uint32		TotalTaskCount;
	} Progress_repl;

	/*************************/
	/* EcDoRpc Function 0x55 */
	typedef [enum8bit] enum {
		MNID_ID = 0,
		MNID_STRING = 1
	} ulKind;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8				NameSize;
		[flag(STR_NULLTERM)] string	Name;
	} mapi_name;

	typedef [nodiscriminant] union {
		[case(MNID_ID)] uint32		lid;
		[case(MNID_STRING)] mapi_name	lpwstr;
	} Kind;
	
	typedef [flag(NDR_NOALIGN)] struct {
		ulKind				ulKind;
		GUID				lpguid;
		[switch_is(ulKind)] Kind	kind;
	} MAPINAMEID;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16		PropertyIdCount;
		uint16		PropertyIds[PropertyIdCount];
	} GetNamesFromIDs_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16		count;
		MAPINAMEID	nameid[count];
	} GetNamesFromIDs_repl;

	/*************************/
	/* EcDoRpc Function 0x56 */
	typedef [flag(NDR_NOALIGN)] struct {
		uint8		ulFlags;
		uint16		count;
		MAPINAMEID	nameid[count];
	} GetIDsFromNames_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16		count;
		uint16		propID[count];
	} GetIDsFromNames_repl;

	/*************************/
	/* EcDoRpc Function 0x57 */
	typedef [flag(NDR_NOALIGN)] struct {
		SBinary_short	ServerEntryId;
		SBinary_short	ClientEntryId;
	} UpdateDeferredActionMessages_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} UpdateDeferredActionMessages_repl;

	/*************************/
	/* EcDoRpc Function 0x58 */
	typedef [flag(NDR_NOALIGN)] struct {
		boolean8	WantAsynchronous;
		boolean8	WantDeleteAssociated;
	} EmptyFolder_req;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8	PartialCompletion;
	} EmptyFolder_repl;

	/*************************/
	/* EcDoRpc Function 0x59 */
	typedef [flag(NDR_NOALIGN)] struct {
		uint16		MaxRowCount;
		hyper		CategoryId;
	} ExpandRow_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint32		ExpandedRowCount;
		uint16		RowCount;
		[flag(NDR_REMAINING)]DATA_BLOB  RowData;
	} ExpandRow_repl;

	/*************************/
	/* EcDoRpc Function 0x5a */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper		CategoryId;
	} CollapseRow_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint32		CollapsedRowCount;
	} CollapseRow_repl;

	/*************************/
	/* EcDoRpc Function 0x5b */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper		RegionOffset;
		hyper		RegionSize;
		uint32		LockFlags;
	} LockRegionStream_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} LockRegionStream_repl;

	/*************************/
	/* EcDoRpc Function 0x5c */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper		RegionOffset;
		hyper		RegionSize;
		uint32		LockFlags;
	} UnlockRegionStream_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} UnlockRegionStream_repl;

	/*************************/
	/* EcDoRpc Function 0x5d */
	typedef [flag(NDR_NOALIGN)] struct {
	} CommitStream_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} CommitStream_repl;

	/*************************/
	/* EcDoRpc Function 0x5e */
	typedef [flag(NDR_NOALIGN)] struct {
	} GetStreamSize_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint32		StreamSize;
	} GetStreamSize_repl;

	/*************************/
	/* EcDoRpc Function 0x5f */
	typedef [bitmap8bit] bitmap {
		NoStrings	= 0x01,
		NoIds	        = 0x02
	} QueryFlags;

	typedef [nodiscriminant] union {
		[case(0x0)];
	  	[case(0x1)] GUID guid;
	} QueryNamedProperties_guid;

	typedef [flag(NDR_NOALIGN)] struct {
		QueryFlags		QueryFlags;
		boolean8		HasGuid;
		[switch_is(HasGuid)]	QueryNamedProperties_guid PropertyGuid;
	} QueryNamedProperties_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16		IdCount;
		uint16		PropertyIds[IdCount];
		MAPINAMEID	PropertyNames[IdCount];
	} QueryNamedProperties_repl;
  
	/*************************/
	/* EcDoRpc Function 0x60 */
	typedef [flag(NDR_NOALIGN)] struct {
		GUID	DatabaseGuid;
	} GetPerUserLongTermIds_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16		LongTermIdCount;
		LongTermId	LongTermIds[LongTermIdCount];
	} GetPerUserLongTermIds_repl;

	/*************************/
	/* EcDoRpc Function 0x61 */
	typedef [flag(NDR_NOALIGN)] struct {
		LongTermId	LongTermId;
	} GetPerUserGuid_req;

	typedef [flag(NDR_NOALIGN)] struct {
		GUID		DatabaseGuid;
	} GetPerUserGuid_repl;

	/*************************/
	/* EcDoRpc Function 0x63 */
	typedef [flag(NDR_NOALIGN)] struct {
		uint8		FolderId[24];
		boolean8	WhatIfChanged;
		uint32		DataOffset;
		uint16		MaxDataSize;
	} ReadPerUserInformation_req;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8	HasFinished;
		uint16		DataSize;
		[subcontext(0), subcontext_size(DataSize), flag(NDR_REMAINING)] DATA_BLOB Data;
	} ReadPerUserInformation_repl;

	/*************************/
	/* EcDoRpc Function 0x66 */
	typedef [flag(NDR_NOALIGN)] struct {
		boolean8	WantAsynchronous;
	  	MSGFLAG_READ	ReadFlags;
	  	uint16		MessageIdCount;
	  	hyper		MessageIds[MessageIdCount];
	} SetReadFlags_req;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8	PartialCompletion;
	} SetReadFlags_repl;

	/*************************/
	/* EcDoRpc Function 0x67 */
	typedef [flag(NDR_NOALIGN)] struct {
 		uint8			handle_idx;
		boolean8		WantAsynchronous;
	  	CopyFlags		CopyFlags;
		mapi_SPropTagArray	PropertyTags;
	} CopyProperties_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16		PropertyProblemCount;
		PropertyProblem	PropertyProblem[PropertyProblemCount];
	} CopyProperties_repl;

	/*************************/
	/* EcDoRpc Function 0x68 */
	typedef [flag(NDR_NOALIGN)] struct {
		uint8		unknown;
		hyper		fid;
		astring		lpszMessageClass;
		FILETIME	modiftime;
	} ReceiveFolder;

	typedef [flag(NDR_NOALIGN)] struct {
	} GetReceiveFolderTable_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint32		cValues;
		ReceiveFolder	entries[cValues];
	} GetReceiveFolderTable_repl;

	/*************************/
	/* EcDoRpc Function 0x6b */
	typedef [flag(NDR_NOALIGN)] struct {
		hyper		RowId;
	  	uint32		RowInstanceNumber;
	} GetCollapseState_req;

	typedef [flag(NDR_NOALIGN)] struct {
		SBinary_short	CollapseState;
	} GetCollapseState_repl;

	/*************************/
	/* EcDoRpc Function 0x6c */
	typedef [flag(NDR_NOALIGN)] struct {
		SBinary_short	CollapseState;
	} SetCollapseState_req;

	typedef [flag(NDR_NOALIGN)] struct {
		SBinary_short	bookmark;
	} SetCollapseState_repl;

	/*************************/
	/* EcDoRpc Function 0x6d */
	typedef [flag(NDR_NOALIGN)] struct {
	} GetTransportFolder_req;

	typedef [flag(NDR_NOALIGN)] struct {
		hyper		FolderId;
	} GetTransportFolder_repl;

	/*************************/
	/* EcDoRpc Function 0x6e */
	typedef [flag(NDR_NOALIGN)] struct {
		uint16	SessionIndex;
	} Pending_repl;

	/*************************/
	/* EcDoRpc Function 0x6f */
	typedef [enum8bit,flag(NDR_NOALIGN)] enum {
		OPTION_TYPE_RECIPIENT	= 0x1,
		OPTION_TYPE_MESSAGE	= 0x2
	} OPTIONDATA_ulFlags;

	typedef [flag(NDR_NOALIGN)] struct {
		astring			transport;
		OPTIONDATA_ulFlags     	type;
	} RegisterOptions_req;

	typedef [flag(NDR_NOALIGN)] struct {
		OPTIONDATA_ulFlags     	ulFlags;
		DATA_BLOB		data;
	} RegisterOptions_repl;

	/*************************/
	/* EcDoRpc Function 0x70 */
	typedef [enum8bit] enum {
		Contents	= 0x1,
		Hierarchy	= 0x2
	} SynchronizationType;

	typedef [bitmap8bit] bitmap {
		SendOptions_Unicode		= 0x1,
		SendOptions_ForUpload		= 0x3,
		SendOptions_RecoverMode		= 0x4,
		SendOptions_ForceUnicode	= 0x8,
		SendOptions_Partial		= 0x10
	} SendOptions;

	typedef [bitmap16bit] bitmap {
		SynchronizationFlag_Unicode			= 0x1,
		SynchronizationFlag_NoDeletions			= 0x2,
		SynchronizationFlag_NoSoftDeletions		= 0x4,
	       	SynchronizationFlag_ReadState			= 0x8,
	       	SynchronizationFlag_FAI				= 0x10,
	       	SynchronizationFlag_Normal			= 0x20,
	       	SynchronizationFlag_OnlySpecifiedProperties	= 0x80,
	       	SynchronizationFlag_NoForeignIdentifiers	= 0x100,
	       	SynchronizationFlag_Reserved			= 0x1000,
	       	SynchronizationFlag_BestBody			= 0x2000,
	       	SynchronizationFlag_IgnoreSpecifiedOnFAI	= 0x4000,
	       	SynchronizationFlag_Progress			= 0x8000
	} SynchronizationFlag;

	typedef [bitmap32bit] bitmap {
		Eid			= 0x00000001,
		MessageSize		= 0x00000002,
		Cn			= 0x00000004,
	        OrderByDeliveryTime	= 0x00000008
	} SynchronizationExtraFlags;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8					handle_idx;
		SynchronizationType			SynchronizationType;
		SendOptions				SendOptions;
		SynchronizationFlag			SynchronizationFlag;
		uint16					RestrictionSize;
 		[subcontext(0),subcontext_size(RestrictionSize),flag(NDR_REMAINING)] DATA_BLOB	RestrictionData;
		SynchronizationExtraFlags		SynchronizationExtraFlags;
		mapi_SPropTagArray			PropertyTags;
	} SyncConfigure_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} SyncConfigure_repl;

	/*************************/
	/* EcDoRpc Function 0x72 */
	typedef [bitmap8bit] bitmap {
		ImportFlag_Associated		= 0x10,
	       	ImportFlag_FailOnConflict	= 0x40
	} ImportFlag;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8			handle_idx;
		ImportFlag		ImportFlag;
		mapi_SPropValue_array	PropertyValues;
	} SyncImportMessageChange_req;

	typedef [flag(NDR_NOALIGN)] struct {
		hyper		MessageId;
	} SyncImportMessageChange_repl;

	/*************************/
	/* EcDoRpc Function 0x73 */
	typedef [flag(NDR_NOALIGN)] struct {
		mapi_SPropValue_array	HierarchyValues;
		mapi_SPropValue_array	PropertyValues;
	} SyncImportHierarchyChange_req;

	typedef [flag(NDR_NOALIGN)] struct {
		hyper			FolderId;
	} SyncImportHierarchyChange_repl;

	/*************************/
	/* EcDoRpc Function 0x74 */
	typedef [flag(NDR_NOALIGN)] struct {
		boolean8		IsHierarchy;
		mapi_SPropValue_array	PropertyValues;
	} SyncImportDeletes_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} SyncImportDeletes_repl;

	/*************************/
	/* EcDoRpc Function 0x75 */
	typedef [v1_enum,flag(NDR_PAHEX)] enum {
		PidTagIdsetGiven	= 0x40170003,
		PidTagCnsetSeen		= 0x67960102,
		PidTagCnsetSeenFAI	= 0x67da0102,
		PidTagCnsetRead		= 0x67d20102
	} StateProperty;

	typedef [flag(NDR_NOALIGN)] struct {
		StateProperty		StateProperty;
		uint32			TransferBufferSize;
	} SyncUploadStateStreamBegin_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} SyncUploadStateStreamBegin_repl;

	/*************************/
	/* EcDoRpc Function 0x76 */
	typedef [flag(NDR_NOALIGN)] struct {
		uint32			StreamDataSize;
		uint8			StreamData[StreamDataSize];
	} SyncUploadStateStreamContinue_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} SyncUploadStateStreamContinue_repl;

	/*************************/
	/* EcDoRpc Function 0x77 */
	typedef [flag(NDR_NOALIGN)] struct {
	} SyncUploadStateStreamEnd_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} SyncUploadStateStreamEnd_repl;

	/*************************/
	/* EcDoRpc Function 0x78 */
	typedef [flag(NDR_NOALIGN)] struct {
		uint32		SourceFolderIdSize;
		uint8		SourceFolderId[SourceFolderIdSize];
		uint32		SourceMessageIdSize;
		uint8		SourceMessageId[SourceMessageIdSize];
		uint32		PredecessorChangeListSize;
		uint8		PredecessorChangeList[PredecessorChangeListSize];
		uint32		DestinationMessageIdSize;
		uint8		DestinationMessageId[DestinationMessageIdSize];
		uint32		ChangeNumberSize;
		uint8		ChangeNumber[ChangeNumberSize];
	} SyncImportMessageMove_req;

	typedef [flag(NDR_NOALIGN)] struct {
		hyper		MessageId;
	} SyncImportMessageMove_repl;

	/*************************/
	/* EcDoRpc Function 0x79 */
	typedef [flag(NDR_NOALIGN)] struct {
		[subcontext(2)] mapi_SPropValue_array	values;
	} SetPropertiesNoReplicate_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16		PropertyProblemCount;
		PropertyProblem	PropertyProblem[PropertyProblemCount];
	} SetPropertiesNoReplicate_repl;

	/*************************/
	/* EcDoRpc Function 0x7a */
	typedef [flag(NDR_NOALIGN)] struct {
		mapi_SPropTagArray	PropertyTags;
	} DeletePropertiesNoReplicate_req;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16		PropertyProblemCount;
		PropertyProblem	PropertyProblem[PropertyProblemCount];
	} DeletePropertiesNoReplicate_repl;

	/*************************/
	/* EcDoRpc Function 0x7b */
	typedef [public,bitmap32bit] bitmap {
		STORE_HAS_SEARCHES		= 0x010000000
	} StoreState;

	typedef [flag(NDR_NOALIGN)] struct {
	} GetStoreState_req;

	typedef [flag(NDR_NOALIGN)] struct {
		StoreState	StoreState;
	} GetStoreState_repl;

	/*************************/
	/* EcDoRpc Function 0x7e */
	typedef [flag(NDR_NOALIGN)] struct {
		uint8		handle_idx;
		boolean8	IsContentsCollector;
	} SyncOpenCollector_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} SyncOpenCollector_repl;

	/*************************/
	/* EcDoRpc Function 0x7f */
	typedef [flag(NDR_NOALIGN)] struct {
		uint32		IdCount;
	} GetLocalReplicaIds_req;

	typedef [flag(NDR_NOALIGN)] struct {
		GUID		ReplGuid;
		uint8		GlobalCount[6];
	} GetLocalReplicaIds_repl;

	/*************************/
	/* EcDoRpc Function 0x80 */
// 	typedef [flag(NDR_NOALIGN)] struct {
// 		uint16		MessageSize;
// 		uint8		MessageId[MessageSize];
// 		boolean8	MarkAsRead;
// 	} MessageReadStates;

	typedef [flag(NDR_NOALIGN)] struct {
		uint16		MessageReadStateSize;
		[subcontext(0),subcontext_size(MessageReadStateSize),flag(NDR_REMAINING)] DATA_BLOB MessageStates;
	} SyncImportReadStateChanges_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} SyncImportReadStateChanges_repl;

	/*************************/
	/* EcDoRpc Function 0x81 */
	typedef [flag(NDR_NOALIGN)] struct {
	} ResetTable_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} ResetTable_repl;

	/*************************/
	/* EcDoRpc Function 0x82 */
	typedef [flag(NDR_NOALIGN)] struct {
		uint8		handle_idx;
	} SyncGetTransferState_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} SyncGetTransferState_repl;

	/*************************/
	/* EcDoRpc Function 0x87 */
	typedef [flag(NDR_NOALIGN)] struct {
		uint8		handle_idx;
		asclstr		name;
	} OpenPublicFolderByName_req; 

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8				HasRules;
		boolean8				IsGhosted;
		[switch_is(IsGhosted)] IsGhosted	Ghost;
	} OpenPublicFolderByName_repl;

	/*************************/
	/* EcDoRpc Function 0x88 */
	typedef [flag(NDR_NOALIGN)] struct {
		GUID	NotificationGuid;
	} SetSyncNotificationGuid_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} SetSyncNotificationGuid_repl;

	/*************************/
	/* EcDoRpc Function 0x89 */
	typedef [flag(NDR_NOALIGN)] struct {
		SBinary_short	bookmark;
	} FreeBookmark_req;

	typedef [flag(NDR_NOALIGN)] struct {
	} FreeBookmark_repl;

	/*************************/
	/* EcDoRpc Function 0x90 */
	typedef [flag(NDR_NOALIGN)] struct {
		[subcontext(2), flag(NDR_REMAINING)] DATA_BLOB	data;
	} WriteAndCommitStream_req;


	typedef [flag(NDR_NOALIGN)] struct {
		uint16		WrittenSize;
	} WriteAndCommitStream_repl;

	/**************************/
	/* EcDoRpc Function 0x91  */
	typedef [flag(NDR_NOALIGN)] struct {
		boolean8	WantAsynchronous;
		boolean8	NotifyNonRead;
		uint16		MessageIdCount;
		hyper		MessageIds[MessageIdCount];
	} HardDeleteMessages_req;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8	PartialCompletion;
	} HardDeleteMessages_repl;

	/*************************/
	/* EcDoRpc Function 0x92 */
	typedef [flag(NDR_NOALIGN)] struct {
		boolean8	WantAsynchronous;
		boolean8	WantDeleteAssociated;
	} HardDeleteMessagesAndSubfolders_req;

	typedef [flag(NDR_NOALIGN)] struct {
		boolean8	PartialCompletion;
	} HardDeleteMessagesAndSubfolders_repl;

	/*************************/
	/* EcDoRpc Function 0xFE */
	typedef [public,bitmap8bit] bitmap {
		LogonPrivate	= 0x1,
		UnderCover	= 0x2,
		Ghosted		= 0x4,
		SpIProcess	= 0x8
	} LogonFlags;

	typedef [public,bitmap32bit] bitmap {
		PUBLIC				= 0x2,
		HOME_LOGON			= 0x4,
		TAKE_OWNERSHIP			= 0x8,
		ALTERNATE_SERVER		= 0x100,
		IGNORE_HOME_MDB			= 0x200,
		NO_MAIL				= 0x400,
		USE_PER_MDB_REPLID_MAPPING	= 0x010000000
	} OpenFlags;

	typedef [enum8bit] enum {
		DayOfWeek_Sunday	= 0x0,
		DayOfWeek_Monday	= 0x1,
		DayOfWeek_Tuesday	= 0x2,
		DayOfWeek_Wednesday	= 0x3,
		DayOfWeek_Thursday	= 0x4,
		DayOfWeek_Friday	= 0x5,
		DayOfWeek_Saturday	= 0x6
	} DayOfWeek;

	typedef [flag(NDR_NOALIGN)] struct {
		uint8		Seconds;
		uint8		Minutes;
		uint8		Hour;
		DayOfWeek	DayOfWeek;
		uint8		Day;
		uint8		Month;
		uint16		Year;
	} LogonTime;

	typedef [bitmap8bit] bitmap {
		ResponseFlags_Reserved		= 0x1,
		ResponseFlags_OwnerRight	= 0x2,
		ResponseFlags_SendAsRight	= 0x4,
		ResponseFlags_OOF		= 0x10
	} ResponseFlags;

	typedef [flag(NDR_NOALIGN)] struct {
		hyper			FolderIds[13];
		uint16			ReplId;
		GUID			Guid;
		GUID			PerUserGuid;
	} store_pf;

	typedef [flag(NDR_NOALIGN)] struct {
		hyper			FolderIds[13];
		ResponseFlags		ResponseFlags;
		GUID			MailboxGuid;
		uint16			ReplId;
		GUID			ReplGUID;
		LogonTime		LogonTime;
		hyper			GwartTime;
		StoreState		StoreState;
	} store_mailbox;

	typedef [nodiscriminant] union {
 		[case(0x0)]		store_pf	store_pf;
		[case(LogonPrivate)]	store_mailbox	store_mailbox;
	} LogonType;

	typedef [nopush,flag(NDR_NOALIGN)] struct {
		LogonFlags	LogonFlags;
		OpenFlags	OpenFlags;
		StoreState	StoreState;
		ascstr3		EssDN;
	} Logon_req;

	typedef [flag(NDR_NOALIGN)] struct {
		LogonFlags				LogonFlags;
		[switch_is(LogonFlags)] LogonType	LogonType;
	} Logon_repl;

	/* Logon redirect response buffer (error_code == ecWrongServer) */
	typedef [public,flag(NDR_NOALIGN)] struct {
		LogonFlags	LogonFlags;
		uint8		ServerNameSize;
		astring		ServerName;
	} Logon_redirect;

	/*************************/
	/* EcDoRpc Function 0xA5 */
	typedef [flag(NDR_NOALIGN)] struct {
		SBinary_short	bin;
	} proxypack_req;

	typedef [flag(NDR_NOALIGN)] struct {
		SBinary_short	bin;
	} proxypack_repl;

	typedef [public, nodiscriminant] union {
		[case(op_MAPI_Release)] Release_req mapi_Release;
		[case(op_MAPI_OpenFolder)] OpenFolder_req mapi_OpenFolder;
		[case(op_MAPI_OpenMessage)] OpenMessage_req mapi_OpenMessage;
		[case(op_MAPI_GetHierarchyTable)] GetHierarchyTable_req mapi_GetHierarchyTable;
		[case(op_MAPI_GetContentsTable)] GetContentsTable_req mapi_GetContentsTable;
		[case(op_MAPI_CreateMessage)] CreateMessage_req mapi_CreateMessage;
		[case(op_MAPI_GetProps)] GetProps_req mapi_GetProps;
		[case(op_MAPI_GetPropsAll)] GetPropsAll_req mapi_GetPropsAll;
		[case(op_MAPI_GetPropList)] GetPropList_req mapi_GetPropList;
		[case(op_MAPI_SetProps)] SetProps_req mapi_SetProps;
		[case(op_MAPI_DeleteProps)] DeleteProps_req mapi_DeleteProps;
		[case(op_MAPI_SaveChangesMessage)] SaveChangesMessage_req mapi_SaveChangesMessage;
		[case(op_MAPI_SetMessageReadFlag)] SetMessageReadFlag_req mapi_SetMessageReadFlag;
		[case(op_MAPI_ReloadCachedInformation)] ReloadCachedInformation_req mapi_ReloadCachedInformation;
		[case(op_MAPI_SetColumns)] SetColumns_req mapi_SetColumns;
		[case(op_MAPI_SortTable)] SortTable_req mapi_SortTable;
		[case(op_MAPI_Restrict)] Restrict_req mapi_Restrict;
		[case(op_MAPI_RemoveAllRecipients)] RemoveAllRecipients_req mapi_RemoveAllRecipients;
		[case(op_MAPI_ModifyRecipients)] ModifyRecipients_req mapi_ModifyRecipients;
		[case(op_MAPI_ReadRecipients)] ReadRecipients_req mapi_ReadRecipients;
		[case(op_MAPI_QueryRows)] QueryRows_req mapi_QueryRows;
		[case(op_MAPI_GetStatus)] GetStatus_req mapi_GetStatus;
		[case(op_MAPI_QueryPosition)] QueryPosition_req mapi_QueryPosition;
		[case(op_MAPI_SeekRow)] SeekRow_req mapi_SeekRow;
		[case(op_MAPI_SeekRowBookmark)] SeekRowBookmark_req mapi_SeekRowBookmark;
		[case(op_MAPI_SeekRowApprox)] SeekRowApprox_req mapi_SeekRowApprox;
		[case(op_MAPI_CreateBookmark)] CreateBookmark_req mapi_CreateBookmark;
		[case(op_MAPI_CreateFolder)] CreateFolder_req mapi_CreateFolder;
		[case(op_MAPI_DeleteFolder)] DeleteFolder_req mapi_DeleteFolder;
		[case(op_MAPI_DeleteMessages)] DeleteMessages_req mapi_DeleteMessages;
		[case(op_MAPI_GetMessageStatus)] GetMessageStatus_req mapi_GetMessageStatus;
		[case(op_MAPI_SetMessageStatus)] SetMessageStatus_req mapi_SetMessageStatus;
		[case(op_MAPI_GetAttachmentTable)] GetAttachmentTable_req mapi_GetAttachmentTable;
		[case(op_MAPI_OpenAttach)] OpenAttach_req mapi_OpenAttach;
		[case(op_MAPI_CreateAttach)] CreateAttach_req mapi_CreateAttach;
		[case(op_MAPI_DeleteAttach)] DeleteAttach_req mapi_DeleteAttach;
		[case(op_MAPI_SaveChangesAttachment)] SaveChangesAttachment_req mapi_SaveChangesAttachment;
		[case(op_MAPI_SetReceiveFolder)] SetReceiveFolder_req mapi_SetReceiveFolder;
		[case(op_MAPI_GetReceiveFolder)] GetReceiveFolder_req mapi_GetReceiveFolder;
		[case(op_MAPI_RegisterNotification)] RegisterNotification_req mapi_RegisterNotification;
		[case(op_MAPI_OpenStream)] OpenStream_req mapi_OpenStream;
		[case(op_MAPI_ReadStream)] ReadStream_req mapi_ReadStream;
		[case(op_MAPI_WriteStream)] WriteStream_req mapi_WriteStream;
		[case(op_MAPI_SeekStream)] SeekStream_req mapi_SeekStream;
		[case(op_MAPI_SetStreamSize)] SetStreamSize_req mapi_SetStreamSize;
		[case(op_MAPI_SetSearchCriteria)] SetSearchCriteria_req mapi_SetSearchCriteria;
		[case(op_MAPI_GetSearchCriteria)] GetSearchCriteria_req mapi_GetSearchCriteria;
		[case(op_MAPI_SubmitMessage)] SubmitMessage_req mapi_SubmitMessage;
		[case(op_MAPI_MoveCopyMessages)] MoveCopyMessages_req mapi_MoveCopyMessages;
		[case(op_MAPI_AbortSubmit)] AbortSubmit_req mapi_AbortSubmit;
		[case(op_MAPI_MoveFolder)] MoveFolder_req mapi_MoveFolder;
		[case(op_MAPI_CopyFolder)] CopyFolder_req mapi_CopyFolder;
		[case(op_MAPI_QueryColumnsAll)] QueryColumnsAll_req mapi_QueryColumnsAll;
		[case(op_MAPI_Abort)] Abort_req mapi_Abort;
		[case(op_MAPI_CopyTo)] CopyTo_req mapi_CopyTo;
		[case(op_MAPI_CopyToStream)] CopyToStream_req mapi_CopyToStream;
		[case(op_MAPI_CloneStream)] CloneStream_req mapi_CloneStream;
		[case(op_MAPI_GetTable)] GetTable_req mapi_GetTable;
		[case(op_MAPI_GetRulesTable)] GetRulesTable_req mapi_GetRulesTable;
		[case(op_MAPI_ModifyTable)] ModifyTable_req mapi_ModifyTable;
		[case(op_MAPI_ModifyRules)] ModifyRules_req mapi_ModifyRules;
		[case(op_MAPI_GetOwningServers)] GetOwningServers_req mapi_GetOwningServers;
		[case(op_MAPI_LongTermIdFromId)] LongTermIdFromId_req mapi_LongTermIdFromId;
		[case(op_MAPI_IdFromLongTermId)] IdFromLongTermId_req mapi_IdFromLongTermId;
		[case(op_MAPI_PublicFolderIsGhosted)] PublicFolderIsGhosted_req mapi_PublicFolderIsGhosted;
		[case(op_MAPI_OpenEmbeddedMessage)] OpenEmbeddedMessage_req mapi_OpenEmbeddedMessage;
		[case(op_MAPI_SetSpooler)] SetSpooler_req mapi_SetSpooler;
		[case(op_MAPI_SpoolerLockMessage)] SpoolerLockMessage_req mapi_SpoolerLockMessage;
		[case(op_MAPI_AddressTypes)] AddressTypes_req mapi_AddressTypes;
		[case(op_MAPI_TransportSend)] TransportSend_req mapi_TransportSend;
		[case(op_MAPI_FastTransferSourceGetBuffer)] FastTransferSourceGetBuffer_req mapi_FastTransferSourceGetBuffer;
		[case(op_MAPI_FindRow)] FindRow_req mapi_FindRow;
		[case(op_MAPI_Progress)] Progress_req mapi_Progress;
		[case(op_MAPI_GetNamesFromIDs)] GetNamesFromIDs_req mapi_GetNamesFromIDs;
		[case(op_MAPI_GetIDsFromNames)] GetIDsFromNames_req mapi_GetIDsFromNames;
		[case(op_MAPI_UpdateDeferredActionMessages)] UpdateDeferredActionMessages_req mapi_UpdateDeferredActionMessages;
		[case(op_MAPI_EmptyFolder)] EmptyFolder_req mapi_EmptyFolder;
		[case(op_MAPI_ExpandRow)] ExpandRow_req mapi_ExpandRow;
		[case(op_MAPI_CollapseRow)] CollapseRow_req mapi_CollapseRow;
		[case(op_MAPI_LockRegionStream)] LockRegionStream_req mapi_LockRegionStream;
		[case(op_MAPI_UnlockRegionStream)] UnlockRegionStream_req mapi_UnlockRegionStream;
		[case(op_MAPI_CommitStream)] CommitStream_req mapi_CommitStream;
		[case(op_MAPI_GetStreamSize)] GetStreamSize_req mapi_GetStreamSize;
		[case(op_MAPI_QueryNamedProperties)] QueryNamedProperties_req mapi_QueryNamedProperties;
		[case(op_MAPI_GetPerUserLongTermIds)] GetPerUserLongTermIds_req mapi_GetPerUserLongTermIds;
		[case(op_MAPI_GetPerUserGuid)] GetPerUserGuid_req mapi_GetPerUserGuid;
		[case(op_MAPI_ReadPerUserInformation)] ReadPerUserInformation_req mapi_ReadPerUserInformation;
		[case(op_MAPI_SetReadFlags)] SetReadFlags_req mapi_SetReadFlags;
		[case(op_MAPI_CopyProperties)] CopyProperties_req mapi_CopyProperties;
		[case(op_MAPI_GetReceiveFolderTable)] GetReceiveFolderTable_req mapi_GetReceiveFolderTable;
		[case(op_MAPI_GetCollapseState)] GetCollapseState_req mapi_GetCollapseState;
		[case(op_MAPI_SetCollapseState)] SetCollapseState_req mapi_SetCollapseState;
		[case(op_MAPI_GetTransportFolder)] GetTransportFolder_req mapi_GetTransportFolder;
		[case(op_MAPI_RegisterOptions)] RegisterOptions_req mapi_RegisterOptions;
		[case(op_MAPI_SyncConfigure)] SyncConfigure_req mapi_SyncConfigure;
		[case(op_MAPI_SyncImportMessageChange)] SyncImportMessageChange_req mapi_SyncImportMessageChange;
		[case(op_MAPI_SyncImportHierarchyChange)] SyncImportHierarchyChange_req mapi_SyncImportHierarchyChange;
		[case(op_MAPI_SyncImportDeletes)] SyncImportDeletes_req mapi_SyncImportDeletes;
		[case(op_MAPI_SyncUploadStateStreamBegin)] SyncUploadStateStreamBegin_req mapi_SyncUploadStateStreamBegin;
		[case(op_MAPI_SyncUploadStateStreamContinue)] SyncUploadStateStreamContinue_req mapi_SyncUploadStateStreamContinue;
		[case(op_MAPI_SyncUploadStateStreamEnd)] SyncUploadStateStreamEnd_req mapi_SyncUploadStateStreamEnd;
		[case(op_MAPI_SyncImportMessageMove)] SyncImportMessageMove_req mapi_SyncImportMessageMove;
		[case(op_MAPI_SetPropertiesNoReplicate)] SetPropertiesNoReplicate_req mapi_SetPropertiesNoReplicate;
		[case(op_MAPI_DeletePropertiesNoReplicate)] DeletePropertiesNoReplicate_req mapi_DeletePropertiesNoReplicate;
		[case(op_MAPI_GetStoreState)] GetStoreState_req mapi_GetStoreState;
		[case(op_MAPI_SyncOpenCollector)] SyncOpenCollector_req mapi_SyncOpenCollector;
		[case(op_MAPI_GetLocalReplicaIds)] GetLocalReplicaIds_req mapi_GetLocalReplicaIds;
		[case(op_MAPI_SyncImportReadStateChanges)] SyncImportReadStateChanges_req mapi_SyncImportReadStateChanges;
		[case(op_MAPI_ResetTable)] ResetTable_req mapi_ResetTable;
		[case(op_MAPI_SyncGetTransferState)] SyncGetTransferState_req mapi_SyncGetTransferState;
		[case(op_MAPI_OpenPublicFolderByName)] OpenPublicFolderByName_req mapi_OpenPublicFolderByName;
		[case(op_MAPI_SetSyncNotificationGuid)] SetSyncNotificationGuid_req mapi_SetSyncNotificationGuid;
		[case(op_MAPI_FreeBookmark)] FreeBookmark_req mapi_FreeBookmark;
		[case(op_MAPI_WriteAndCommitStream)] WriteAndCommitStream_req mapi_WriteAndCommitStream;
		[case(op_MAPI_HardDeleteMessages)] HardDeleteMessages_req mapi_HardDeleteMessages;
		[case(op_MAPI_HardDeleteMessagesAndSubfolders)] HardDeleteMessagesAndSubfolders_req mapi_HardDeleteMessagesAndSubfolders;
		[case(op_MAPI_Logon)] Logon_req mapi_Logon;
		[case(op_MAPI_proxypack)] proxypack_req mapi_proxypack;
	} EcDoRpc_MAPI_REQ_UNION;

	typedef [public, nodiscriminant] union {
 		[case(op_MAPI_Release)] Release_repl mapi_Release;
		[case(op_MAPI_OpenFolder)] OpenFolder_repl mapi_OpenFolder;
		[case(op_MAPI_OpenMessage)] OpenMessage_repl mapi_OpenMessage;
		[case(op_MAPI_GetHierarchyTable)] GetHierarchyTable_repl mapi_GetHierarchyTable;
		[case(op_MAPI_GetContentsTable)] GetContentsTable_repl mapi_GetContentsTable;
		[case(op_MAPI_CreateMessage)] CreateMessage_repl mapi_CreateMessage;
		[case(op_MAPI_GetProps)] GetProps_repl mapi_GetProps;
		[case(op_MAPI_GetPropsAll)] GetPropsAll_repl mapi_GetPropsAll;
		[case(op_MAPI_GetPropList)] GetPropList_repl mapi_GetPropList;
		[case(op_MAPI_SetProps)] SetProps_repl mapi_SetProps;
		[case(op_MAPI_DeleteProps)] DeleteProps_repl mapi_DeleteProps;
		[case(op_MAPI_SaveChangesMessage)] SaveChangesMessage_repl mapi_SaveChangesMessage;
		[case(op_MAPI_RemoveAllRecipients)] RemoveAllRecipients_repl mapi_RemoveAllRecipients;
		[case(op_MAPI_ModifyRecipients)] ModifyRecipients_repl mapi_ModifyRecipients;
		[case(op_MAPI_ReadRecipients)] ReadRecipients_repl mapi_ReadRecipients;
		[case(op_MAPI_SetMessageReadFlag)] SetMessageReadFlag_repl mapi_SetMessageReadFlag;
		[case(op_MAPI_ReloadCachedInformation)] ReloadCachedInformation_repl mapi_ReloadCachedInformation;
		[case(op_MAPI_SetColumns)] SetColumns_repl mapi_SetColumns;
		[case(op_MAPI_SortTable)] SortTable_repl mapi_SortTable;
		[case(op_MAPI_Restrict)] Restrict_repl mapi_Restrict;
		[case(op_MAPI_QueryRows)] QueryRows_repl mapi_QueryRows;
		[case(op_MAPI_GetStatus)] GetStatus_repl mapi_GetStatus;
		[case(op_MAPI_QueryPosition)] QueryPosition_repl mapi_QueryPosition;
		[case(op_MAPI_SeekRow)] SeekRow_repl mapi_SeekRow;
		[case(op_MAPI_SeekRowBookmark)] SeekRowBookmark_repl mapi_SeekRowBookmark;
		[case(op_MAPI_SeekRowApprox)] SeekRowApprox_repl mapi_SeekRowApprox;
		[case(op_MAPI_CreateBookmark)] CreateBookmark_repl mapi_CreateBookmark;
		[case(op_MAPI_CreateFolder)] CreateFolder_repl mapi_CreateFolder;
		[case(op_MAPI_DeleteFolder)] DeleteFolder_repl mapi_DeleteFolder;
		[case(op_MAPI_DeleteMessages)] DeleteMessages_repl mapi_DeleteMessages;
		[case(op_MAPI_SetMessageStatus)] SetMessageStatus_repl mapi_SetMessageStatus;
		[case(op_MAPI_GetAttachmentTable)] GetAttachmentTable_repl mapi_GetAttachmentTable;
		[case(op_MAPI_OpenAttach)] OpenAttach_repl mapi_OpenAttach;
		[case(op_MAPI_CreateAttach)] CreateAttach_repl mapi_CreateAttach;
		[case(op_MAPI_DeleteAttach)] DeleteAttach_repl mapi_DeleteAttach;
		[case(op_MAPI_SaveChangesAttachment)] SaveChangesAttachment_repl mapi_SaveChangesAttachment;
		[case(op_MAPI_SetReceiveFolder)] SetReceiveFolder_repl mapi_SetReceiveFolder;
		[case(op_MAPI_GetReceiveFolder)] GetReceiveFolder_repl mapi_GetReceiveFolder;
		[case(op_MAPI_RegisterNotification)] RegisterNotification_repl mapi_RegisterNotification;
		[case(op_MAPI_Notify)] Notify_repl mapi_Notify;
		[case(op_MAPI_OpenStream)] OpenStream_repl mapi_OpenStream;
		[case(op_MAPI_ReadStream)] ReadStream_repl mapi_ReadStream;
		[case(op_MAPI_WriteStream)] WriteStream_repl mapi_WriteStream;
		[case(op_MAPI_SeekStream)] SeekStream_repl mapi_SeekStream;
		[case(op_MAPI_SetStreamSize)] SetStreamSize_repl mapi_SetStreamSize;
		[case(op_MAPI_SetSearchCriteria)] SetSearchCriteria_repl mapi_SetSearchCriteria;
		[case(op_MAPI_GetSearchCriteria)] GetSearchCriteria_repl mapi_GetSearchCriteria;
		[case(op_MAPI_SubmitMessage)] SubmitMessage_repl mapi_SubmitMessage;
		[case(op_MAPI_MoveCopyMessages)] MoveCopyMessages_repl mapi_MoveCopyMessages;
		[case(op_MAPI_AbortSubmit)] AbortSubmit_repl mapi_AbortSubmit;
		[case(op_MAPI_MoveFolder)] MoveFolder_repl mapi_MoveFolder;
		[case(op_MAPI_CopyFolder)] CopyFolder_repl mapi_CopyFolder;
		[case(op_MAPI_QueryColumnsAll)] QueryColumnsAll_repl mapi_QueryColumnsAll;
		[case(op_MAPI_Abort)] Abort_repl mapi_Abort;
		[case(op_MAPI_CopyTo)] CopyTo_repl mapi_CopyTo;
		[case(op_MAPI_CopyToStream)] CopyToStream_repl mapi_CopyToStream;
		[case(op_MAPI_CloneStream)] CloneStream_repl mapi_CloneStream;
		[case(op_MAPI_GetTable)] GetTable_repl mapi_GetTable;
		[case(op_MAPI_GetRulesTable)] GetRulesTable_repl mapi_GetRulesTable;
		[case(op_MAPI_ModifyTable)] ModifyTable_repl mapi_ModifyTable;
		[case(op_MAPI_ModifyRules)] ModifyRules_repl mapi_ModifyRules;
		[case(op_MAPI_GetOwningServers)] GetOwningServers_repl mapi_GetOwningServers;
		[case(op_MAPI_LongTermIdFromId)] LongTermIdFromId_repl mapi_LongTermIdFromId;
		[case(op_MAPI_IdFromLongTermId)] IdFromLongTermId_repl mapi_IdFromLongTermId;
		[case(op_MAPI_PublicFolderIsGhosted)] PublicFolderIsGhosted_repl mapi_PublicFolderIsGhosted;
		[case(op_MAPI_OpenEmbeddedMessage)] OpenEmbeddedMessage_repl mapi_OpenEmbeddedMessage;
		[case(op_MAPI_SetSpooler)] SetSpooler_repl mapi_SetSpooler;
		[case(op_MAPI_SpoolerLockMessage)] SpoolerLockMessage_repl mapi_SpoolerLockMessage;
		[case(op_MAPI_AddressTypes)] AddressTypes_repl mapi_AddressTypes;
		[case(op_MAPI_TransportSend)] TransportSend_repl mapi_TransportSend;
		[case(op_MAPI_FastTransferSourceGetBuffer)] FastTransferSourceGetBuffer_repl mapi_FastTransferSourceGetBuffer;
		[case(op_MAPI_FindRow)] FindRow_repl mapi_FindRow;
		[case(op_MAPI_Progress)] Progress_repl mapi_Progress;
		[case(op_MAPI_GetNamesFromIDs)] GetNamesFromIDs_repl mapi_GetNamesFromIDs;
		[case(op_MAPI_GetIDsFromNames)] GetIDsFromNames_repl mapi_GetIDsFromNames;
		[case(op_MAPI_UpdateDeferredActionMessages)] UpdateDeferredActionMessages_repl mapi_UpdateDeferredActionMessages;
		[case(op_MAPI_EmptyFolder)] EmptyFolder_repl mapi_EmptyFolder;
		[case(op_MAPI_ExpandRow)] ExpandRow_repl mapi_ExpandRow;
		[case(op_MAPI_CollapseRow)] CollapseRow_repl mapi_CollapseRow;
		[case(op_MAPI_LockRegionStream)] LockRegionStream_repl mapi_LockRegionStream;
		[case(op_MAPI_UnlockRegionStream)] UnlockRegionStream_repl mapi_UnlockRegionStream;
		[case(op_MAPI_CommitStream)] CommitStream_repl mapi_CommitStream;
		[case(op_MAPI_GetStreamSize)] GetStreamSize_repl mapi_GetStreamSize;
		[case(op_MAPI_QueryNamedProperties)] QueryNamedProperties_repl mapi_QueryNamedProperties;
		[case(op_MAPI_GetPerUserLongTermIds)] GetPerUserLongTermIds_repl mapi_GetPerUserLongTermIds;
		[case(op_MAPI_GetPerUserGuid)] GetPerUserGuid_repl mapi_GetPerUserGuid;
		[case(op_MAPI_ReadPerUserInformation)] ReadPerUserInformation_repl mapi_ReadPerUserInformation;
		[case(op_MAPI_SetReadFlags)] SetReadFlags_repl mapi_SetReadFlags;
		[case(op_MAPI_CopyProperties)] CopyProperties_repl mapi_CopyProperties;
		[case(op_MAPI_GetReceiveFolderTable)] GetReceiveFolderTable_repl mapi_GetReceiveFolderTable;
		[case(op_MAPI_Pending)] Pending_repl mapi_Pending;
		[case(op_MAPI_GetCollapseState)] GetCollapseState_repl mapi_GetCollapseState;
		[case(op_MAPI_SetCollapseState)] SetCollapseState_repl mapi_SetCollapseState;
		[case(op_MAPI_GetTransportFolder)] GetTransportFolder_repl mapi_GetTransportFolder;
		[case(op_MAPI_RegisterOptions)] RegisterOptions_repl mapi_RegisterOptions;
		[case(op_MAPI_SyncConfigure)] SyncConfigure_repl mapi_SyncConfigure;
		[case(op_MAPI_SyncImportMessageChange)] SyncImportMessageChange_repl mapi_SyncImportMessageChange;
		[case(op_MAPI_SyncImportHierarchyChange)] SyncImportHierarchyChange_repl mapi_SyncImportHierarchyChange;
		[case(op_MAPI_SyncImportDeletes)] SyncImportDeletes_repl mapi_SyncImportDeletes;
		[case(op_MAPI_SyncUploadStateStreamBegin)] SyncUploadStateStreamBegin_repl mapi_SyncUploadStateStreamBegin;
		[case(op_MAPI_SyncUploadStateStreamContinue)] SyncUploadStateStreamContinue_repl mapi_SyncUploadStateStreamContinue;
		[case(op_MAPI_SyncUploadStateStreamEnd)] SyncUploadStateStreamEnd_repl mapi_SyncUploadStateStreamEnd;
		[case(op_MAPI_SyncImportMessageMove)] SyncImportMessageMove_repl mapi_SyncImportMessageMove;
		[case(op_MAPI_SetPropertiesNoReplicate)] SetPropertiesNoReplicate_repl mapi_SetPropertiesNoReplicate;
		[case(op_MAPI_DeletePropertiesNoReplicate)] DeletePropertiesNoReplicate_repl mapi_DeletePropertiesNoReplicate;
		[case(op_MAPI_GetStoreState)] GetStoreState_repl mapi_GetStoreState;
		[case(op_MAPI_SyncOpenCollector)] SyncOpenCollector_repl mapi_SyncOpenCollector;
		[case(op_MAPI_GetLocalReplicaIds)] GetLocalReplicaIds_repl mapi_GetLocalReplicaIds;
		[case(op_MAPI_SyncImportReadStateChanges)] SyncImportReadStateChanges_repl mapi_SyncImportReadStateChanges;
		[case(op_MAPI_ResetTable)] ResetTable_repl mapi_ResetTable;
		[case(op_MAPI_SyncGetTransferState)] SyncGetTransferState_repl mapi_SyncGetTransferState;
		[case(op_MAPI_OpenPublicFolderByName)] OpenPublicFolderByName_repl mapi_OpenPublicFolderByName;
		[case(op_MAPI_SetSyncNotificationGuid)] SetSyncNotificationGuid_repl mapi_SetSyncNotificationGuid;
		[case(op_MAPI_FreeBookmark)] FreeBookmark_repl mapi_FreeBookmark;
		[case(op_MAPI_WriteAndCommitStream)] WriteAndCommitStream_repl mapi_WriteAndCommitStream;
		[case(op_MAPI_HardDeleteMessages)] HardDeleteMessages_repl mapi_HardDeleteMessages;
		[case(op_MAPI_HardDeleteMessagesAndSubfolders)] HardDeleteMessagesAndSubfolders_repl mapi_HardDeleteMessagesAndSubfolders;
		[case(op_MAPI_Logon)] Logon_repl mapi_Logon;
		[case(op_MAPI_proxypack)] proxypack_repl mapi_proxypack;

	} EcDoRpc_MAPI_REPL_UNION;

	typedef [public, nodiscriminant] union {
		[case(op_MAPI_Logon)] Logon_redirect mapi_Logon;
		[default];
	} EcDoRpc_MAPI_REPL_UNION_SPECIAL;

	typedef [public,flag(NDR_NOALIGN)] struct {
		uint8		opnum;
		uint8		logon_id;
		uint8		handle_idx;
		[switch_is(opnum)] EcDoRpc_MAPI_REQ_UNION u;
	} EcDoRpc_MAPI_REQ;

	typedef [public,nopush,nopull,noprint,flag(NDR_NOALIGN)] struct {
		uint8     	opnum;
		uint8		handle_idx;
		MAPISTATUS	error_code;
		[switch_is(opnum)] EcDoRpc_MAPI_REPL_UNION u;
		[switch_is(opnum)] EcDoRpc_MAPI_REPL_UNION_SPECIAL us;
	} EcDoRpc_MAPI_REPL;


	/*
	  Abstract way to represent MAPI content
	*/

  	typedef [public,nopull,nopush,noprint] struct {
		uint32			mapi_len;	/* whole mapi_data length */
		uint16			length;		/* content length */
		EcDoRpc_MAPI_REQ	*mapi_req;
		uint32			*handles;	/* handles id array */
	} mapi_request;

	typedef [public,nopull,nopush,noprint] struct {
		uint32			mapi_len;
		uint16			length;
		EcDoRpc_MAPI_REPL	*mapi_repl;
		uint32			*handles;
	} mapi_response;
	

	[public] MAPISTATUS EcDoRpc(
		[in,out]						policy_handle	*handle,
		[in,out]						uint32		size,
		[in,out]						uint32		offset,
	  	[in] [subcontext(4),flag(NDR_REMAINING|NDR_NOALIGN)]	mapi_request	*mapi_request,
		[out][subcontext(4),flag(NDR_REMAINING|NDR_NOALIGN)]	mapi_response	*mapi_response,
		[in,out]						uint16		*length,
		[in]							uint16		max_data
		);

	/*****************/
	/* Function 0x03 */
	void EcGetMoreRpc();

	/*****************/
	/* Function 0x04 */

	/*
	  we could directly use a NOTIFKEY structure rather than
	  a uint8 array, but this makes the IDL more robust
	
	  sockaddr array is made of: 
	   - family (unsigned short in) sa_family_t
	   - address data sa_data[14];
	 */

	typedef struct {
		uint16		cb;
		uint8		ab[cb];
	} NOTIFKEY;

	MAPISTATUS EcRRegisterPushNotification(
               [in,out] policy_handle			*handle,
               [in] NotificationFlags			ulEventMask,
	       [in,size_is(cbContext)] uint8		rgbContext[*],
               [in] uint16				cbContext,
	       [in] uint32				grbitAdviseBits,
	       [in,size_is(cbCallbackAddress)] uint8	rgCallbackAddress[*],
	       [in] uint16				cbCallbackAddress,
	       [out,ref] uint32				*hNotification
		);

	/*****************/
	/* Function 0x05 */
	MAPISTATUS EcRUnregisterPushNotification(
		[in,out]	policy_handle		*handle,
		[in]		uint32			unknown[2]
		);

	/*****************/
	/* Function 0x06 */
	void EcDummyRpc();

	/*****************/
	/* Function 0x07 */
	void EcRGetDCName();

	/*****************/
	/* Function 0x08 */
	void EcRNetGetDCName();

	/*****************/
	/* Function 0x09 */
	void EcDoRpcExt();

	/*****************/
	/* Function 0xa  */
	MAPISTATUS EcDoConnectEx(
		[out]				policy_handle	*handle,
		[in,string,charset(DOS)]	uint8		szUserDN[],
		[in]				uint32		ulFlags,
		[in]				uint32		ulConMod,
		[in]				uint32		cbLimit,
		[in]				uint32		ulCpid,
		[in]				uint32		ulLcidString,
		[in]				uint32		ulLcidSort,
		[in]				uint32		ulIcxrLink,
		[in]				uint16		usFCanConvertCodePages,
		[out]				uint32		*pcmsPollsMax,
		[out]				uint32		*pcRetry,
		[out]				uint32		*pcmsRetryDelay,
		[out]				uint32		*picxr,
		[out,unique,string,charset(DOS)]uint8		*szDNPrefix,
		[out,unique,string,charset(DOS)]uint8		*szDisplayName,
		[in]				uint16		rgwClientVersion[3],
		[out]				uint16		rgwServerVersion[3],
		[out]				uint16		rgwBestVersion[3],
		[in,out]			uint32		*pulTimeStamp,
		[in][subcontext(4),flag(NDR_REMAINING|NDR_NOALIGN)] DATA_BLOB rgbAuxIn,
		[in,out][range(0x0,0x1008)]	uint32		*pcbAuxOut,
		[in][flag(NDR_REMAINING)] DATA_BLOB data
		);
}

[
  uuid("c840a7dc-42c0-1a10-b4b9-08002b2fe182"),
  pointer_default(unique),
  helpstring("Unknown")
] interface exchange_unknown
{
	void unknown_dummy();
}