#include "idl_types.h"
import "wsp_data.idl";
import "misc.idl";

[
	version(1.0),
	endpoint("ncacn_np:[\\pipe\\MsFteWds]"),
	helpstring("Windows Search WSP Protocol"),
	helper("../librpc/wsp/wsp_helper.h"),
	pointer_default(unique)
]

interface msftewds
{
	typedef [public] struct {
		/*
		 * hack to allow wsp_cbasestoragevariant to be used before
		 * it is defined
		 */
		wsp_cbasestoragevariant variant[SINGLE_ITEM];
	} vt_variant_wrap;

	/* MS-WSP 2.2.1.1.1.1 DECIMAL */
	typedef [public] struct {
		uint32 hi32;
		uint32 mid32;
		uint32 lo32;
	} vt_decimal;

	/* MS-WSP 2.2.1.1.1.2 VT_VECTOR (VT_DECIMAL) */
	typedef [public] struct {
		uint32 vvector_elements;
		vt_decimal vvector_data[vvector_elements];
	} vt_decimal_vec;

	/*
	 * variant elements in a vector (and presumably safearray also)
	 * must be aligned to 4-byte boundary, think this is automatic for
	 * elements which are structures
	 */

	/* MS-WSP see vValue details in 2.2.1.1 (VT_BSTR) */
	typedef [public] struct {
		[value(strlen_m_term(value)*2)] uint32 	nbytes;
		[flag(STR_NULLTERM)] string value;
	} vt_bstr;

	/* MS-WSP 2.2.1.1.1.2 VT_VECTOR (VT_BSTR) */
	typedef [public] struct {
		uint32 vvector_elements;
		vt_bstr vvector_data[vvector_elements];
	} vt_bstr_vec;

	/* MS-WSP see vValue details in 2.2.1.1 (VT_LPWSTR) */
	typedef [public] struct {
		[value(strlen_m_term(value))] uint32 nbytes;
		[flag(STR_NULLTERM)] string value;
	} vt_lpwstr;

	/* MS-WSP 2.2.1.1.1.2 VT_VECTOR (VT_LPWSTR) */
	typedef [public] struct {
		uint32 vvector_elements;
		vt_lpwstr vvector_data[vvector_elements];
	} vt_lpwstr_vec;

	/* MS-WSP see vValue details in 2.2.1.1 (VT_COMPRESSED_LPWSTR) */
	typedef [public] struct {
		uint32 cclen;
		uint8 bytes[cclen];
	} vt_compressed_lpwstr;

	/* MS-WSP 2.2.1.1.1.2 VT_VECTOR (VT_COMPRESSED_LPWSTR) */
	typedef [public] struct {
		uint32 vvector_elements;
		vt_compressed_lpwstr vvector_data[vvector_elements];
	} vt_compressed_lpwstr_vec;


	/* MS-WSP 2.2.1.1.1.2 VT_VECTOR (VT_I1) */
	typedef [public] struct {
		uint32 vvector_elements;
		int8 vvector_data[vvector_elements];
	} vt_i1_vec;

	/* MS-WSP 2.2.1.1.1.2 VT_VECTOR (VT_UI1) */
	typedef [public] struct {
		uint32 vvector_elements;
		uint8 vvector_data[vvector_elements];
	} vt_ui1_vec;

	/* MS-WSP 2.2.1.1.1.2 VT_VECTOR (VT_I2) */
	typedef [public] struct {
		uint32 vvector_elements;
		int16 vvector_data[vvector_elements];
	} vt_i2_vec;

	/* MS-WSP 2.2.1.1.1.2 VT_VECTOR (VT_UI2) */
	typedef [public] struct {
		uint32 vvector_elements;
		uint16 vvector_data[vvector_elements];
	} vt_ui2_vec;

	/* MS-WSP 2.2.1.1.1.2 VT_VECTOR (VT_I4) */
	typedef [public] struct {
		uint32 vvector_elements;
		int32 vvector_data[vvector_elements];
	} vt_i4_vec;

	/* MS-WSP 2.2.1.1.1.2 VT_VECTOR (VT_UI4) */
	typedef [public] struct {
		uint32 vvector_elements;
		uint32 vvector_data[vvector_elements];
	} vt_ui4_vec;

	/* MS-WSP 2.2.1.1.1.2 VT_VECTOR (VT_I8) */
	typedef [public] struct {
		uint32 vvector_elements;
		dlong vvector_data[vvector_elements];
	} vt_dlong_vec;

	/* MS-WSP 2.2.1.1.1.2 VT_VECTOR (VT_UI8) */
	typedef [public] struct {
		uint32 vvector_elements;
		udlong vvector_data[vvector_elements];
	} vt_udlong_vec;

	/* MS-WSP 2.2.1.1.1.2 VT_VECTOR (VT_CLSID) */
	typedef [public] struct {
		uint32 vvector_elements;
		GUID vvector_data[vvector_elements];
	} vt_clsid_vec;

	/* MS-WSP 2.2.1.1.1.2 VT_VECTOR (VT_VARIANT) wrapped version */
	typedef [public] struct {
		uint32 vvector_elements;
		vt_variant_wrap vvector_data[vvector_elements];
	} vt_variant_wrap_vec;

/*
 * would be great if there some way to specify the above like below
 * instead of having a vector
 * for each element type e.g. see vt_lpwstr_vec, vt_bstr_vec & vt_i4_vec?
 * typedef [public] struct {
 *	uint32 num;
 *	variant_types vec[num];
 *} vt_vector;
 */

	/* MS-WSP 2.2.1.1.1.4 SAFEARRAYBOUND */
	typedef [public] struct {
		uint32 celements;
		uint32 ilbound;
	} safearraybound;

	/* MS-WSP 2.2.1.1.1.4 SAFEARRAY (VT_I4) */
	typedef [public] struct {
		uint16 cdims;
		uint16 ffeatures;
		uint32 cbelements;
		safearraybound rgsabound[cdims];
		int32 vdata[calc_array_size(rgsabound, cdims)];
	} vt_i4_safe_array;

	/* MS-WSP 2.2.1.1.1.4 SAFEARRAY (VT_UI4) */
	typedef [public] struct {
		uint16 cdims;
		uint16 ffeatures;
		uint32 cbelements;
		safearraybound rgsabound[cdims];
		uint32 vdata[calc_array_size(rgsabound, cdims)];
	} vt_ui4_safe_array;

	/* MS-WSP 2.2.1.1.1.4 SAFEARRAY (VT_BSTR) */
	typedef [public] struct {
		uint16 cdims;
		uint16 ffeatures;
		uint32 cbelements;
		safearraybound rgsabound[cdims];
		vt_bstr vdata[calc_array_size(rgsabound, cdims)];
	} vt_bstr_safe_array;


	/* MS-WSP 2.2.1.1.1.4 SAFEARRAY (VT_I1) */
	typedef [public] struct {
		uint16 cdims;
		uint16 ffeatures;
		uint32 cbelements;
		safearraybound rgsabound[cdims];
		int8 vdata[calc_array_size(rgsabound, cdims)];
	} vt_i1_safe_array;

	/* MS-WSP 2.2.1.1.1.4 SAFEARRAY (VT_UI1) */
	typedef [public] struct {
		uint16 cdims;
		uint16 ffeatures;
		uint32 cbelements;
		safearraybound rgsabound[cdims];
		uint8 vdata[calc_array_size(rgsabound, cdims)];
	} vt_ui1_safe_array;


	/* MS-WSP 2.2.1.1.1.4 SAFEARRAY (VT_I2) */
	typedef [public] struct {
		uint16 cdims;
		uint16 ffeatures;
		uint32 cbelements;
		safearraybound rgsabound[cdims];
		int16 vdata[calc_array_size(rgsabound, cdims)];
	} vt_i2_safe_array;


	/* MS-WSP 2.2.1.1.1.4 SAFEARRAY (VT_UI2) */
	typedef [public] struct {
		uint16 cdims;
		uint16 ffeatures;
		uint32 cbelements;
		safearraybound rgsabound[cdims];
		uint16 vdata[calc_array_size(rgsabound, cdims)];
	} vt_ui2_safe_array;

	/* MS-WSP 2.2.1.1.1.4 SAFEARRAY (VT_I8) */
	typedef [public] struct {
		uint16 cdims;
		uint16 ffeatures;
		uint32 cbelements;
		safearraybound rgsabound[cdims];
		dlong vdata[calc_array_size(rgsabound, cdims)];
	} vt_dlong_safe_array;

	/* MS-WSP 2.2.1.1.1.4 SAFEARRAY (VT_VARIANT) */
	typedef [public] struct {
		uint16 cdims;
		uint16 ffeatures;
		uint32 cbelements;
		safearraybound rgsabound[cdims];
		vt_variant_wrap vdata[calc_array_size(rgsabound, cdims)];
	} vt_variant_wrap_safearray;

	typedef [public,nodiscriminant,switch_type(uint16)] union {
		[case(VT_I1)] int8 vt_i1;
		[case(VT_I1 | VT_ARRAY)]  vt_i1_safe_array vt_i1_array;
		[case(VT_I1 | VT_VECTOR)] vt_i1_vec vt_i1_vec;

		[case(VT_UI1)] uint8 vt_ui1;
		[case(VT_UI1 | VT_ARRAY)]  vt_ui1_safe_array vt_ui1_array;
		[case(VT_UI1 | VT_VECTOR)] vt_ui1_vec vt_ui1_vec;

		[case(VT_I2)] int16 vt_i2;
		[case(VT_I2 | VT_ARRAY)]  vt_i2_safe_array vt_i2_array;
		[case(VT_I2 | VT_VECTOR)] vt_i2_vec vt_i2_vec;

		[case(VT_UI2)] uint16 vt_ui2;
		[case(VT_UI2 | VT_ARRAY)]  vt_ui2_safe_array vt_ui2_array;
		[case(VT_UI2 | VT_VECTOR)] vt_ui2_vec vt_ui2_vec;

		[case(VT_BOOL)] uint16 vt_bool;
		[case(VT_BOOL | VT_ARRAY)]  vt_ui2_safe_array vt_bool_array;
		[case(VT_BOOL | VT_VECTOR)] vt_ui2_vec vt_bool_vec;

		[case(VT_I4)] int32 vt_i4;
		[case(VT_I4 | VT_VECTOR)] vt_i4_vec vt_i4_vec;
		[case(VT_I4 | VT_ARRAY)] vt_i4_safe_array vt_i4_array;

		[case(VT_UI4)] uint32 vt_ui4;
		[case(VT_UI4 | VT_VECTOR)] vt_ui4_vec vt_ui4_vec;
		[case(VT_UI4 | VT_ARRAY)] vt_ui4_safe_array vt_ui4_array;

		[case(VT_R4)] uint32 vt_r4;
		[case(VT_R4 | VT_VECTOR)] vt_i4_vec vt_r4_vec;
		[case(VT_R4 | VT_ARRAY)] vt_i4_safe_array vt_r4_array;

		[case(VT_INT)] int32 vt_int;
		[case(VT_INT | VT_ARRAY)] vt_i4_safe_array vt_int_array;

		[case(VT_UINT)] uint32 vt_uint;
		[case(VT_UINT | VT_ARRAY)] vt_ui4_safe_array vt_uint_array;

		[case(VT_ERROR)] uint32 vt_error;
		[case(VT_ERROR | VT_VECTOR)] vt_ui4_vec vt_error_vec;
		[case(VT_ERROR | VT_ARRAY)] vt_ui4_safe_array vt_error_array;

		[case(VT_I8)] dlong vt_i8;
		[case(VT_I8 | VT_VECTOR)] vt_dlong_vec vt_i8_vec;

		[case(VT_UI8)] udlong vt_ui8;
		[case(VT_UI8 | VT_VECTOR)] vt_udlong_vec vt_ui8_vec;

		[case(VT_R8)] dlong vt_r8;
		[case(VT_R8 | VT_VECTOR)] vt_dlong_vec vt_r8_vec;
		[case(VT_R8 | VT_ARRAY)] vt_dlong_safe_array vt_r8_array;

		[case(VT_CY)] dlong vt_cy;
		[case(VT_CY | VT_VECTOR)] vt_dlong_vec vt_cy_vec;
		[case(VT_CY | VT_ARRAY)] vt_dlong_safe_array vt_cy_array;

		[case(VT_DATE)] dlong vt_date;
		[case(VT_DATE | VT_VECTOR)] vt_dlong_vec vt_date_vec;
		[case(VT_DATE| VT_ARRAY)] vt_dlong_safe_array vt_date_array;

		[case(VT_FILETIME)] udlong vt_filetime;
		[case(VT_FILETIME | VT_VECTOR)] vt_udlong_vec vt_filetime_vec;

		[case(VT_BSTR)] vt_bstr vt_bstr;
		[case(VT_BSTR | VT_VECTOR)] vt_bstr_vec vt_bstr_v;
		[case(VT_BSTR | VT_ARRAY)] vt_bstr_safe_array vt_bstr_array;

		[case(VT_LPWSTR)] vt_lpwstr vt_lpwstr;
		[case(VT_LPWSTR | VT_VECTOR)] vt_lpwstr_vec vt_lpwstr_v;

		[case(VT_COMPRESSED_LPWSTR)] vt_compressed_lpwstr vt_compressed_lpwstr;
		[case(VT_COMPRESSED_LPWSTR | VT_VECTOR)] vt_compressed_lpwstr_vec vt_compresseed_lpwstr_v;

		[case(VT_DECIMAL)] vt_decimal vt_decimal;
		[case(VT_DECIMAL | VT_VECTOR)] vt_decimal_vec vt_decimal_v;

		[case(VT_CLSID)] GUID vt_clid;
		[case(VT_CLSID | VT_VECTOR)] vt_clsid_vec vt_clsid_v;

		[case(VT_BLOB)] DATA_BLOB vt_blob;
		[case(VT_BLOB_OBJECT)] DATA_BLOB vt_blob_object;

		[case(VT_NULL)];
		[case(VT_EMPTY)];
		[case(VT_VARIANT)] vt_variant_wrap vt_variant_wrap;

		[case(VT_VARIANT | VT_VECTOR)] vt_variant_wrap_vec vt_variant_wrap_vec;
		[case(VT_VARIANT | VT_ARRAY)]  vt_variant_wrap_safearray vt_variant_wrap_array;
	} variant_types;

	/*
	 * MS-WSP 2.2.1.1 CBaseStorageVariant
	 */
	typedef [public] struct {
		uint16 vtype;
		uint8 vdata1;
		uint8 vdata2;
		[max_recursion(102), switch_is(vtype)] variant_types vvalue;
	} wsp_cbasestoragevariant;

	typedef [public, nodiscriminant, switch_type(uint32)] union {
		[case(DBKIND_GUID_NAME)] string vstring;
		[default];
	} wsp_cdbcolid_opt_name;

	/* MS-WSP 2.2.1.29 CDbColId */
	typedef [public] struct {
		uint32 ekind;
		[flag(NDR_ALIGN8)]    DATA_BLOB _pad1;
		GUID guid;
		uint32 uiid;
		[switch_is(ekind)] wsp_cdbcolid_opt_name vstring;
	} wsp_cdbcolid;


	/* MS-WSP 2.2.2 Message Headers */
	typedef [public] struct {
		uint32 msg;
		uint32 status;
		uint32 checksum;
		uint32 ulreserved2;
	} wsp_header;

	/* MS-WSP 2.2.1.30 CDbProp */
	typedef [public,flag(NDR_ALIGN4)] struct {
		uint32 dbpropid;
		uint32 dbpropoptions;
		uint32 dbpropstatus;
		wsp_cdbcolid colid;
		wsp_cbasestoragevariant vvalue;
	} wsp_cdbprop;

	/* MS-WSP 2.2.1.31 CDbPropSet */
	typedef [flag(NDR_NOALIGN),public] struct {
		GUID guidpropertyset;
		[flag(NDR_ALIGN4)]    DATA_BLOB _pad1;
		uint32 cproperties;
		wsp_cdbprop aprops[cproperties];
	} wsp_cdbpropset;

	/* MS-WSP 2.2.1.10 CSort */
	typedef [public] struct {
		uint32 pidcolimn;
		uint32 dworder;
		uint32 dwindividual;
		uint32 locale;
	} wsp_csort;

	/* MS-WSP 2.2.1.42 CSortSet */
	typedef [public] struct {
		uint32 count;
		wsp_csort sortarray[count];
	} wsp_csortset;

	/*
	 * cPropSets, PropterySet1 & PropertySet2 (parts of CPMConnectIn)
	 */
	typedef [public] struct {
		uint32 cpropsets;
		wsp_cdbpropset propertyset1;
		wsp_cdbpropset propertyset2;
	} connectin_propsets;

	/*
	 * cExtPropSet, aPropertySets (parts of CPMConnectIn)
	 */
	typedef [public] struct {
		uint32 cextpropset;
		wsp_cdbpropset apropertysets[cextpropset];
	} connectin_extpropsets;

	/* MS-WSP 2.2.3.2 CPMConnectIn */
	typedef [public] struct {
		uint32 iclientversion;
		uint32 fclientisremote;
		uint32 cbblob1;
		uint32 paddingcbblob2;
		uint32 cbblob2;
		uint8  padding[12];
		[flag(STR_NULLTERM)] string machinename;
		[flag(STR_NULLTERM)] string username;
		[flag(NDR_ALIGN8)]    DATA_BLOB _pad1;
		uint8 propsets[cbblob1];
		[flag(NDR_ALIGN8)]    DATA_BLOB _pad2;
		uint8 extpropsets[cbblob2];
	} wsp_cpmconnectin;

	typedef [public] struct {
		uint32 reserved;
		uint32 dwwinvermajor;
		uint32 dwwinverminor;
		uint32 dwnlsvermajor;
		uint32 dwnlsverminor;
	} version_info;

	typedef [public, nodiscriminant, switch_type(uint32)] union {
		[case(WINDOWS_7)] version_info version_info;
		[case(WINDOWS_2008)] version_info version_info;
		[default] uint32 reserved[4];
	} version_dependant;

	/* MS-WSP 2.2.3.3 CPMConnectOut */
	typedef [public] struct {
		uint32 server_version;
		[switch_is(server_version)] version_dependant version_dependant;
	} wsp_cpmconnectout;

	/* MS-WSP 2.2.1.18 CColumnSet */
	typedef [public] struct {
		uint32 count;
		uint32 indexes[count];
	} wsp_ccolumnset;


	/* MS-WSP 2.2.1.6 CNodeRestriction */
	typedef [public] struct {
		uint32 cnode;
		[max_recursion(100)] wsp_crestriction panode[cnode];
	} wsp_cnoderestriction;

	typedef [public] struct {
		uint32 len;
		[charset(UTF16)] uint8 vstring[len*2];
	} wsp_len_string_pair;

	typedef [public, nodiscriminant, switch_type(uint32)] union {
		[case(PRSPEC_LPWSTR)] wsp_len_string_pair propname;
		[case(PRSPEC_PROPID)] uint32 prspec;
	} wsp_propname_or_propid;

	typedef [public] struct {
		uint32 cclabel;
		[charset(UTF16)] uint8 vstring[cclabel*2];
	} wsp_labeldata;

	typedef [public, nodiscriminant, switch_type(uint8)] union {
		[case(0)];
		[case(1)] wsp_labeldata data;
	} opt_labeldata;

	/* MS-WSP 2.2.1.23 RANGEBOUNDARY */
	typedef [public] struct {
		uint32 ultype;
		wsp_cbasestoragevariant prval;
		uint8 labelpresent;
		[switch_is(labelpresent)] opt_labeldata opt_data;
	} wsp_rangeboundary;

	/* MS-WSP 2.2.1.22 CRangeCategSpec */
	typedef [public] struct {
		uint32 lcid;
		uint32 crange;
		wsp_rangeboundary arangebegin[crange + 1];
	} wsp_crangecategspec;

	typedef [public, nodiscriminant, switch_type(uint32)] union {
		[case(0)];
		[default] wsp_crangecategspec crangecategspec;
	} opt_crangecatespec;

	/* MS-WSP 2.2.1.21 CCategSpec */
	typedef [public] struct {
		uint32 ulcategtype;
		wsp_csort sortkey;
		[switch_is(ulcategtype)] opt_crangecatespec opt;
	} wsp_ccategspec;

	typedef [public] struct {
		uint32 ulmaxnumtoret;
		uint32 idrepresentitive;
	} wsp_repofdata;

	typedef [public,nodiscriminant,switch_type(uint8)] union {
		[case(DBAGGTTYPE_FIRST)] uint32 firstmaxnumret;
		[case(DBAGGTTYPE_BYFREQ)] uint32 firstbyfreq;
		[case(DBAGGTTYPE_REPRESENTATIVEOF)] wsp_repofdata repofdata;
		[default];
	} opt_type_data;

	/* MS-WSP 2.2.1.25 CAggregSpec */
	typedef [public] struct {
		uint8 type;
		[flag(NDR_ALIGN4)] DATA_BLOB _pad1;
		uint32 ccalias;
		[charset(UTF16)] uint8 alias[ccalias*2];
		uint32 idcolumn;
		[switch_is(type)] opt_type_data opt_data;
	} wsp_caggregspec;

	/* MS-WSP 2.2.1.24 CAggregSet */
	typedef [public] struct {
		uint32 ccount;
		wsp_caggregspec aggregspecs[ccount];
	} wsp_caggregset;

	/* MS-WSP 2.2.1.27 CAggregSortKey */
	typedef [public] struct {
		uint32 order;
		wsp_caggregspec columnspec;
	} wsp_caggregsortkey;

	/* MS-WSP 2.2.1.26 CSortAggregSet */
	typedef [public] struct {
		uint32 ccount;
		wsp_caggregsortkey sortkeys[ccount];
	} wsp_csortaggregset;

	typedef [public, nodiscriminant, switch_type(uint8)] union {
		/*
		 * if type == GroupIdValue then wsp_cbasestoragevariant
		 * ingroupid is present
		 */
		[case(0x03)] wsp_cbasestoragevariant ingroupid;
		[default];
	} wsp_opt_ingroupid;

	typedef [public] struct {
		uint8 type;
		[flag(NDR_ALIGN4)]    DATA_BLOB _pad1;
		[switch_is(type)] wsp_opt_ingroupid opt_groupid;
		wsp_csortset sortaggregset;
	} wsp_cingroupsortaggregset;

	/* MS-WSP 2.2.1.28 CInGroupSortAggregSets */
	typedef [public] struct {
		uint32 ccount;
		wsp_cingroupsortaggregset sortsets[ccount];
	} wsp_cingroupsortaggregsets;

	/* MS-WSP 2.2.1.20 CCategorizationSpec */
	typedef [public] struct {
		wsp_ccolumnset cscolumns;
		wsp_ccategspec spec;
		wsp_caggregset aggregset;
		wsp_csortaggregset sortaggregset;
		wsp_cingroupsortaggregsets ingroupsortaggset;
		uint32 cmaxresults;
	} wsp_ccategorizationspec;

	/* MS-WSP 2.2.1.19 CCategorizationSet */
	typedef [public] struct {
		uint32 size;
		wsp_ccategorizationspec	categories[size];
	} wsp_ccategorizationset;

	/* MS-WSP 2.2.1.2 CFullPropSpec */
	typedef [flag(NDR_NOALIGN),public] struct {
		[flag(NDR_ALIGN8)] DATA_BLOB _pad1;
		GUID guidpropset;
		uint32 ulkind;
		[switch_is(ulkind)] wsp_propname_or_propid name_or_id;
	} wsp_cfullpropspec;

	/* MS-WSP 2.2.1.3 CContentRestriction */
	typedef [public] struct {
		wsp_cfullpropspec property;
		[flag(NDR_ALIGN4)]    DATA_BLOB _pad1;
		uint32 cc;
		[charset(UTF16)] uint8 pwcsphrase[cc*2];
		[flag(NDR_ALIGN4)]    DATA_BLOB _pad2;
		uint32 lcid;
		uint32 ulgeneratemethod;
	} wsp_ccontentrestriction;

	/* MS-WSP 2.2.1.7 CPropertyRestriction */
	typedef [public] struct {
		uint32 relop;
		wsp_cfullpropspec property;
		wsp_cbasestoragevariant prval;
		[flag(NDR_ALIGN4)]    DATA_BLOB _pad1;
		uint32 lcid;
	} wsp_cpropertyrestriction;

	/* MS-WSP 2.2.1.5 CNatLanguageRestriction */
	typedef [public] struct {
		wsp_cfullpropspec property;
		[flag(NDR_ALIGN4)]    DATA_BLOB _pad1;
		uint32 cc;
		[charset(UTF16)] uint8 pwcsphrase[cc*2];
		[flag(NDR_ALIGN4)]    DATA_BLOB _pad2;
		uint32 lcid;
	} wsp_cnatlanguagerestriction;

	typedef [public] struct {
		wsp_crestriction restriction[SINGLE_ITEM];
	} wsp_wrap_crestriction;


	/* MS-WSP 2.2.1.12 CCoercionRestriction*/
	typedef [public] struct {
		/* no IEEE 754 implementation for float ?? */
		/* float ffvalue; */
		uint32 ffvalue;
		wsp_crestriction childres[SINGLE_ITEM];
	} wsp_ccoercionrestriction;

	/* MS-WSP 2.2.1.11 CVectorRestriction */
	typedef [public] struct {
		uint32 pres;
		[flag(NDR_ALIGN4)]    DATA_BLOB padding;
		uint32 uirankmethod;
	} wsp_cvectorrestriction;

	/* MS-WSP 2.2.1.9 CScopeRestriction */
	typedef [public] struct {
		uint32 cclowerpath;
		[charset(UTF16)] uint8 lowerpath[cclowerpath*2];
		[flag(NDR_ALIGN4)]    DATA_BLOB padding;
		uint32 length;
		uint32 frecursive;
		uint32 fvirtual;
	} wsp_cscoperestriction;

	/* MS-WSP 2.2.1.8 CReuseWhere */
	typedef [public] struct {
		uint32 whereid;
	} wsp_creusewhere;

	/* MS-WSP 2.2.1.4 CInternalPropertyRestriction */
	typedef [public] struct {
		uint32 relop;
		uint32 pid;
		wsp_cbasestoragevariant prval;
		uint32 lcid;
		uint8  restrictionpresent;
		wsp_crestriction nextrestriction[SINGLE_ITEM];
	} wsp_cinternalpropertyrestriction;


	/* MS-WSP 2.2.1.14 CProbRestriction */
	typedef [public] struct {
		wsp_cfullpropspec property;
		uint32 fik1;
		uint32 fik2;
		uint32 fik3;
		uint32 flb;
		uint32 cfeedbackdoc;
		uint32 probquerypid;
	} wsp_cprobrestriction;

	/* MS-WSP 2.2.1.15 CFeedbackRestriction */
	typedef [public] struct {
		uint32 feedbackdoc;
		wsp_cfullpropspec property;
	} wsp_cfeedbackrestriction;

	/* MS-WSP 2.2.1.13 CRelDocRestriction */
	typedef [public] struct {
		wsp_cbasestoragevariant vdocument;
	} wsp_creldocrestriction;

	typedef [public,nodiscriminant,switch_type(uint32)] union {
		[case(RTNONE)];
		[case(RTNOT)] wsp_wrap_crestriction restriction;
		[case(RTAND)] wsp_cnoderestriction cnoderestriction;
		[case(RTOR)]  wsp_cnoderestriction orcnoderestriction;
		[case(RTCONTENT)] wsp_ccontentrestriction ccontentrestriction;
		[case(RTPROPERTY)] wsp_cpropertyrestriction cpropertyrestriction;
		[case(RTPROXIMITY)] wsp_cnoderestriction proximityrestriction;
		[case(RTVECTOR)] wsp_cvectorrestriction vectorrestriction;
		[case(RTNATLANGUAGE)] wsp_cnatlanguagerestriction cnatlanguagerestriction;
		[case(RTSCOPE)] wsp_cscoperestriction scoperestriction;
		[case(RTREUSEWHERE)] wsp_creusewhere reusewhere;
		[case(RTINTERNALPROP)] wsp_cinternalpropertyrestriction internalpropertyrestriction;
		[case(RTPHRASE)] wsp_cnoderestriction phraserestriction;
		[case(RTCOERCE_ABSOLUTE)] wsp_ccoercionrestriction ccoercionrestriction_abs;
		[case(RTCOERCE_ADD)] wsp_ccoercionrestriction ccoercionrestriction_add;
		[case(RTCOERCE_MULTIPLY)] wsp_ccoercionrestriction ccoercionrestriction_mul;
		[case(RTPROB)] wsp_cprobrestriction probrestriction;
		[case(RTFEEDBACK)] wsp_cfeedbackrestriction feedbackrestriction;
		[case(RTRELDOC)] wsp_creldocrestriction reldocrestriction;

	} wsp_crestrictions;


	/* MS-WSP 2.2.1.17 CRestriction */
	typedef [public] struct {
		uint32 ultype;
		uint32 weight;
		[switch_is(ultype)] wsp_crestrictions restriction;
	} wsp_crestriction;

	/* MS-WSP 2.2.1.16 CRestrictionArray */
	typedef [flag(NDR_NOALIGN),public] struct {
		uint8 count;
		uint8 ispresent;
		[flag(NDR_ALIGN4)] DATA_BLOB _pad1;
		wsp_crestriction restrictions[count];
	} wsp_crestrictionarray;

	/* MS-WSP 2.2.1.40 CRowsetProperties */
	typedef [public] struct {
		uint32 ubooleanoptions;
		uint32 ulmaxopenrows;
		uint32 ulmemoryusage;
		uint32 cmaxresults;
		uint32 ccmdtimeout;
	} wsp_crowsetproperties;

	/* MS-WSP 2.2.1.32 CPidMapper */
	typedef [public] struct {
		uint32 count;
		[flag(NDR_ALIGN4)] DATA_BLOB _pad2;
		wsp_cfullpropspec apropspec[count];
	} wsp_cpidmapper;

	/* MS-WSP 2.2.1.35 SProperty */
	typedef [public] struct {
		uint32 pid;
		uint32 weight;
	} wsp_sproperty;

	/* MS-WSP 2.2.1.34 CColumnGroup */
	typedef [public] struct {
		uint32 count;
		uint32 grouppid;
		wsp_sproperty props[count];
	} wsp_ccolumngroup;

	/* MS-WSP 2.2.1.33 CColumnGroupArray */
	typedef [public] struct {
		uint32 count;
		wsp_ccolumngroup agrouparray[count];
	} wsp_ccolumngrouparray;

	typedef [public,nodiscriminant,switch_type(uint8)] union {
		[case(0)];
		[default] wsp_cingroupsortaggregsets groupsortaggregsets;
	}opt_wsp_cingroupsortaggregsets;

	typedef [public,nodiscriminant,switch_type(uint8)] union {
		[case(0)];
		[default] wsp_crestrictionarray restrictionarray;
	}opt_wsp_crestrictionarray;

	typedef [public,nodiscriminant,switch_type(uint8)] union {
		[case(0)];
		[default] wsp_ccolumnset columnset;
	}opt_wsp_ccolumnset;

	typedef [public,nodiscriminant,switch_type(uint8)] union {
		[case(0)];
		[default] wsp_ccategorizationset ccategorizationset;
	}opt_wsp_ccategorizationset;

	typedef [public] struct {
		uint32 size;
		uint8 ccolumnsetpresent;
		/* padding is not needed here (and below)
		 * as structures are default aligned to 4 byte
		 * boundaries.
                 * commented out valued left for documentation
                 * and to match the actual structure definition
		 */
		/*[flag(NDR_ALIGN4)] DATA_BLOB paddingCColumnSetPresent;*/
		[switch_is(ccolumnsetpresent)] opt_wsp_ccolumnset columnset;
		uint8 crestrictionpresent;
		[switch_is(crestrictionpresent)] opt_wsp_crestrictionarray restrictionarray;
		uint8 csortsetpresent;
		/*[flag(NDR_ALIGN4)] DATA_BLOB paddingCSortSetPresent;*/
		[switch_is(csortsetpresent)] opt_wsp_cingroupsortaggregsets sortset;
		uint8 ccategorizationsetpresent;
		/*[flag(NDR_ALIGN4)] DATA_BLOB paddingCCategorizationSetPresent;*/
		[switch_is(ccategorizationsetpresent)] opt_wsp_ccategorizationset ccategorizationset;
		wsp_crowsetproperties rowsetproperties;
		wsp_cpidmapper pidmapper;
		wsp_ccolumngrouparray grouparray;
		uint32 lcid;
	} wsp_cpmcreatequeryin;

	/* MS-WSP 2.2.3.5 CPMCreateQueryOut */
	typedef [public] struct {
		uint32 ftruesequential;
		uint32 fWorkIdUnique;
		/*
		 * uint32 acursors[SIZE];
		 *
		 * after fWorkIdUnique is an array of uint32 cursors,
		 * actually there is always at least 1 item in the array,
		 * SIZE is determined by the optional ccategorizationset field in
		 * the request
		 */
	} wsp_cpmcreatequeryout;

	typedef [public, nodiscriminant, switch_type(uint8)] union {
		[case(1)] uint8 value;
		[case(0)];
	} aggregatetype;

	typedef [public, nodiscriminant, switch_type(uint8)] union {
		[case(1)] uint16 value;
		[case(0)];
	} valueoffset;

	typedef [public, nodiscriminant, switch_type(uint8)] union {
		[case(1)] uint16 value;
		[case(0)];
	} valuesize;

	typedef [public, nodiscriminant, switch_type(uint8)] union {
		[case(1)] uint16 value;
		[case(0)];
	} lengthoffset;

	typedef [public, nodiscriminant, switch_type(uint8)] union {
		[case(1)] uint16 value;
		[case(0)];
	} statusoffset;

	/* MS-WSP 2.2.1.43 CTableColumn */
	typedef [public] struct {
		wsp_cfullpropspec propspec;
		uint32 vtype;
		uint8 aggregateused;
		[switch_is(aggregateused)] aggregatetype aggregatetype;
		uint8 valueused;
		[switch_is(valueused)] valueoffset valueoffset; /* auto aligned to 2 byte boundary */
		[switch_is(valueused)] valuesize valuesize; /* auto aligned to 2 byte boundary */
		uint8 statusused;
		[switch_is(statusused)] statusoffset statusoffset; /* auto aligned to 2 byte boundary */
		uint8 lengthused;
		[switch_is(lengthused)] lengthoffset lengthoffset; /* auto aligned to 2 byte boundary */
		} wsp_ctablecolumn;

	/*
         * struct below is included for completeness but
         * isn't currently referenced.
         * MS-WSP 2.2.1.45 CCompletionCategSpec
         */
	typedef [public] struct {
		uint32 type;
		uint32 lcid;
		uint32 ccomplstrings;
		wsp_serializedpropertyvalue apszcomplstrings[ccomplstrings];
		uint32 ccomplpids;
		uint32 acomplpids[ccomplpids];
	} wsp_ccompletioncategspec;

	/* MS-WSP 2.2.3.10 CPMSetBindingsIn */
	typedef [public] struct {
		uint32 hcursor;
		uint32 brow;
		uint32 bbindingdesc;
		uint32 dummy;
		uint32 ccolumns;
		wsp_ctablecolumn acolumns[ccolumns];
	} wsp_cpmsetbindingsin;

	/* MS-WSP 2.2.1.39 CRowSeekNext */
	typedef [public] struct {
		uint32 cskip;
	} wsp_crowseeknext;

	/* MS-WSP 2.2.1.36 CRowSeekAt */
	typedef [public] struct {
		uint32 bmkoffset;
		uint32 cskip;
		uint32 hregion;
	} wsp_crowseekat;

	/* MS-WSP 2.2.1.37 CRowSeekAtRatio */
	typedef [public] struct {
		uint32 ulnumerator;
		uint32 uldenominator;
		uint32 hregion;
	} wsp_crowseekatratio;

	/* MS-WSP 2.2.1.38 CRowSeekByBookmark */
	typedef [public] struct {
		uint32 cbookmarks;
		uint32 abookmarks[cbookmarks];
		uint32 maxret;
		uint32 ascret[maxret];
	} wsp_crowseekbybookmark;

	typedef [public,nodiscriminant,switch_type(uint32)] union {
		[case(EROWSEEKNONE)];
		[case(EROWSEEKNEXT)] wsp_crowseeknext crowseeknext;
		[case(EROWSEEKAT)] wsp_crowseekat crowseekat;
		[case(EROWSEEKATRATIO)] wsp_crowseekatratio crowseekatratio;
		[case(EROWSEEKBYBOOKMARK)] wsp_crowseekbybookmark crowseekbybookmark;
	} wsp_seekdescription;

	/* MS-WSP 2.2.3.11 CPMGetRowsIn */
	typedef [public] struct {
		uint32 hcursor;
		uint32 crowstotransfer;
		uint32 cbrowWidth;
		uint32 cbseek;
		uint32 cbreserved;
		uint32 cbreadbuffer;
		uint32 ulclientbase;
		uint32 fbwdfetch;
		uint32 etype;
		uint32 chapt;
		[switch_is(etype)] wsp_seekdescription seekdescription;
	} wsp_cpmgetrowsin;

	/* MS-WSP 2.2.1.42 */
	typedef [public] struct {
		uint16 vtype;
		uint16 reserved1;
		uint32 reserved2;
		/* followed by offset either 4 or 8 byte count (if VT_VECTOR) */
		/* followed by offset either 4 or 8 byte offset (if variable size value)*/
		/* followed by fixed value (if fixed size value) */
	} wsp_ctablevariant;

	/* MS-WSP 2.2.3.12 CPMGetRowsOut */
	typedef [public] struct {
		uint32 rowsreturned;
		uint32 etype;
		uint32 chapt;
		[switch_is(etype)] wsp_seekdescription seekdescription;
		/*
		 * following rows data is not defined here, size is unknown
		 * in the context of this structure but is the size of
		 * breadbuffer defined in cpmgetrowsin.
		 */
	} wsp_cpmgetrowsout;

	/* MS-WSP 2.2.3.24 CPMFreeCursorIn */
	typedef [public] struct {
		uint32 hcursor;
	} wsp_cpmfreecursorin;

	/* MS-WSP 2.2.3.25 CPMFreeCursorOut */
	typedef [public] struct {
		uint32 ccursorsremaining;
	} wsp_cpmfreecursorout;

	/* MS-WSP 2.2.3.6 CPMGetQueryStatusIn */
	typedef [public] struct {
		uint32 hcursor;
	} wsp_cpmgetquerystatusin;

	/* MS-WSP 2.2.3.7 CPMGetQueryStatusOut */
	typedef [public] struct {
		uint32 qstatus;
	} wsp_cpmgetquerystatusout;

	/* MS-WSP 2.2.3.8 CPMGetQueryStatusExIn */
	typedef [public] struct {
		uint32 hcursor;
		uint32 bmk;
	} wsp_cpmgetquerystatusexin;

	/* MS-WSP 2.2.3.9 CPMGetQueryStatusExOut */
	typedef [public] struct {
		uint32 qstatus;
		uint32 cfiltereddocuments;
		uint32 cdocumentstofilter;
		uint32 dwratiofinisheddenominator;
		uint32 dwratiofinishednumerator;
		uint32 irowbmk;
		uint32 crowstotal;
		uint32 maxrank;
		uint32 resultsfound;
		uint32 whereid;
	} wsp_cpmgetquerystatusexout;

	/* MS-WSP 2.2.3.23 CPMRestartPositionIn */
	typedef [public] struct {
		uint32 hcursor;
		uint32 chapter;
	} wsp_cpmrestartpositionin;

	/* MS-WSP 2.2.3.13 CPMRatioFinishedIn */
	typedef [public] struct {
		uint32 hcursor;
		uint32 fquick;
	} wsp_cpmratiofinishedin;

	/* MS-WSP 2.2.3.14 CPMRatioFinishedOut */
	typedef [public] struct {
		uint32 ulnumerator;
		uint32 uldenominator;
		uint32 crows;
		uint32 fnewrows;
	} wsp_cpmratiofinishedout;

	/* MS-WSP 2.2.3.15 CPMRatioFinishedOut */
	typedef [public] struct {
		uint32 wid;
		uint32 cbsofar;
		uint32 cbpropspec;
		uint32 cbchunk;
		wsp_cfullpropspec propspec;
	} wsp_cpmfetchvaluein;

	typedef [public] struct {
		uint16 cdims;
		safearraybound rgsabound[cdims];
		int8 vdata[calc_array_size(rgsabound, cdims)];
	} vt_i1_safe2_array;

	typedef [public] struct {
		uint16 cdims;
		safearraybound rgsabound[cdims];
		uint8 vdata[calc_array_size(rgsabound, cdims)];
	} vt_ui1_safe2_array;

	typedef [public] struct {
		uint16 cdims;
		safearraybound rgsabound[cdims];
		int16 vdata[calc_array_size(rgsabound, cdims)];
	} vt_i2_safe2_array;

	typedef [public] struct {
		uint16 cdims;
		safearraybound rgsabound[cdims];
		uint16 vdata[calc_array_size(rgsabound, cdims)];
	} vt_ui2_safe2_array;

	typedef [public] struct {
		uint16 cdims;
		safearraybound rgsabound[cdims];
		int32 vdata[calc_array_size(rgsabound, cdims)];
	} vt_i4_safe2_array;

	typedef [public] struct {
		uint16 cdims;
		safearraybound rgsabound[cdims];
		uint32 vdata[calc_array_size(rgsabound, cdims)];
	} vt_ui4_safe2_array;

	typedef [public] struct {
		uint16 cdims;
		safearraybound rgsabound[cdims];
		dlong vdata[calc_array_size(rgsabound, cdims)];
	} vt_dlong_safe2_array;

	typedef [public] struct {
		uint16 cdims;
		safearraybound rgsabound[cdims];
		vt_bstr vdata[calc_array_size(rgsabound, cdims)];
	} vt_bstr_safe2_array;

	typedef [public] struct {
		uint16 cdims;
		safearraybound rgsabound[cdims];
		vt_variant_wrap vdata[calc_array_size(rgsabound, cdims)];
	} vt_variant_wrap_safearray2;

	typedef [public,nodiscriminant,switch_type(uint32)] union {
		[case(VT_I1)] int8 vt_i1;
		[case(VT_I1 | VT_ARRAY)]  vt_i1_safe2_array vt_i1_array;
		[case(VT_I1 | VT_VECTOR)] vt_i1_vec vt_i1_vec;

		[case(VT_UI1)] uint8 vt_ui1;
		[case(VT_UI1 | VT_ARRAY)]  vt_ui1_safe2_array vt_ui1_array;
		[case(VT_UI1 | VT_VECTOR)] vt_ui1_vec vt_ui1_vec;

		[case(VT_I2)] int16 vt_i2;
		[case(VT_I2 | VT_ARRAY)]  vt_i2_safe2_array vt_i2_array;
		[case(VT_I2 | VT_VECTOR)] vt_i2_vec vt_i2_vec;

		[case(VT_UI2)] uint16 vt_ui2;
		[case(VT_UI2 | VT_ARRAY)]  vt_ui2_safe2_array vt_ui2_array;
		[case(VT_UI2 | VT_VECTOR)] vt_ui2_vec vt_ui2_vec;

		[case(VT_BOOL)] uint16 vt_bool;
		[case(VT_BOOL | VT_ARRAY)]  vt_ui2_safe2_array vt_bool_array;
		[case(VT_BOOL | VT_VECTOR)] vt_ui2_vec vt_bool_vec;

		[case(VT_I4)] int32 vt_i4;
		[case(VT_I4 | VT_VECTOR)] vt_i4_vec vt_i4_vec;
		[case(VT_I4 | VT_ARRAY)] vt_i4_safe2_array vt_i4_array;

		[case(VT_UI4)] uint32 vt_ui4;
		[case(VT_UI4 | VT_VECTOR)] vt_ui4_vec vt_ui4_vec;
		[case(VT_UI4 | VT_ARRAY)] vt_ui4_safe2_array vt_ui4_array;

		[case(VT_R4)] uint32 vt_r4;
		[case(VT_R4 | VT_VECTOR)] vt_i4_vec vt_r4_vec;
		[case(VT_R4 | VT_ARRAY)] vt_i4_safe2_array vt_r4_array;

		[case(VT_INT)] int32 vt_int;
		[case(VT_INT | VT_ARRAY)] vt_i4_safe2_array vt_int_array;

		[case(VT_UINT)] uint32 vt_uint;
		[case(VT_UINT | VT_ARRAY)] vt_ui4_safe2_array vt_uint_array;

		[case(VT_ERROR)] uint32 vt_error;
		[case(VT_ERROR | VT_VECTOR)] vt_ui4_vec vt_error_vec;
		[case(VT_ERROR | VT_ARRAY)] vt_ui4_safe2_array vt_error_array;

		[case(VT_I8)] dlong vt_i8;
		[case(VT_I8 | VT_VECTOR)] vt_dlong_vec vt_i8_vec;

		[case(VT_UI8)] udlong vt_ui8;
		[case(VT_UI8 | VT_VECTOR)] vt_udlong_vec vt_ui8_vec;

		[case(VT_R8)] dlong vt_r8;
		[case(VT_R8 | VT_VECTOR)] vt_dlong_vec vt_r8_vec;
		[case(VT_R8 | VT_ARRAY)] vt_dlong_safe2_array vt_r8_array;

		[case(VT_CY)] dlong vt_cy;
		[case(VT_CY | VT_VECTOR)] vt_dlong_vec vt_cy_vec;
		[case(VT_CY | VT_ARRAY)] vt_dlong_safe2_array vt_cy_array;

		[case(VT_DATE)] dlong vt_date;
		[case(VT_DATE | VT_VECTOR)] vt_dlong_vec vt_date_vec;
		[case(VT_DATE| VT_ARRAY)] vt_dlong_safe2_array vt_date_array;

		[case(VT_FILETIME)] udlong vt_filetime;
		[case(VT_FILETIME | VT_VECTOR)] vt_udlong_vec vt_filetime_vec;

		[case(VT_BSTR)] vt_bstr vt_bstr;
		[case(VT_BSTR | VT_VECTOR)] vt_bstr_vec vt_bstr_v;
		[case(VT_BSTR | VT_ARRAY)] vt_bstr_safe2_array vt_bstr_array;

		[case(VT_LPWSTR)] vt_lpwstr vt_lpwstr;
		[case(VT_LPWSTR | VT_VECTOR)] vt_lpwstr_vec vt_lpwstr_v;

		[case(VT_COMPRESSED_LPWSTR)] vt_compressed_lpwstr vt_compressed_lpwstr;
		[case(VT_COMPRESSED_LPWSTR | VT_VECTOR)] vt_compressed_lpwstr_vec vt_compresseed_lpwstr_v;

		[case(VT_DECIMAL)] vt_decimal vt_decimal;
		[case(VT_DECIMAL | VT_VECTOR)] vt_decimal_vec vt_decimal_v;

		[case(VT_CLSID)] GUID vt_clid;
		[case(VT_CLSID | VT_VECTOR)] vt_clsid_vec vt_clsid_v;

		[case(VT_BLOB)] DATA_BLOB vt_blob;
		[case(VT_BLOB_OBJECT)] DATA_BLOB vt_blob_object;

		[case(VT_NULL)];
		[case(VT_EMPTY)];

		[case(VT_VARIANT)] vt_variant_wrap vt_variant_wrap;
		[case(VT_VARIANT | VT_VECTOR)] vt_variant_wrap_vec vt_variant_wrap_vec;
		[case(VT_VARIANT | VT_ARRAY)]  vt_variant_wrap_safearray2 vt_variant_wrap_array;
	} serialised_types;

	/* MS-WSP 2.2.1.44 SERIALIZEDPROPERTYVALUE */
	typedef [public] struct {
		uint32 dwtype;
		[switch_is(dwtype)] serialised_types rgb;
	} wsp_serializedpropertyvalue;

	/* MS-WSP 2.2.3.16 CPMFetchValueOut */
	typedef [public] struct {
		uint32 cbvalue;
		uint32 fmoreexists;
		uint32 fvalueexists;
		/*
		 * very nearly the same as wsp_cbasestoragevariant, only
		 * different in how array types are represented, also only
		 * a portion of the value (serializedpropertyvalue) is here
		 *
		 * Additionally if the property doesn't exist (e.g.
		 * fvalueexists == 0) cbvalue can still have value
		 * so we can't define the 'vvalue' element below
		 *
		 * uint8 value[cbvalue];
		 */
	} wsp_cpmfetchvalueout;

	/* MS-WSP 2.2.3.31 CPMSetScopePrioritizationIn */
	typedef [public] struct {
		uint32 priority;
		uint32 eventfrequency;
	} wsp_cpmsetscopeprioritizationin;

	/* MS-WSP 2.2.3.18 CPMSendNotifyOut */
	typedef [public] struct {
		uint32 watchnotify;
	} wsp_cpmsendnotifyout;

	/* MS-WSP 2.2.3.30 CPMGetRowsetNotifyOut */
	typedef [public] struct {
		uint32 wid;
		uint8 eventinfo;
		uint8 rowitemstate;
		uint8 changeditemstate;
		uint8 rowsetevent;
		dlong rowseteventdata1;
		dlong rowseteventdata2;
	} wsp_cpmgetrowsetnotifyout;

	/* MS-WSP 2.2.3.34 CPMGetScopeStatisticsOut */
	typedef [public] struct {
		uint32 dwindexeditems;
		uint32 dwoutstandingadds;
		uint32 dwoustandingmodifies;
	} wsp_cpmgetscopestatisticsout;

	/* MS-WSP 2.2.3.19 CPMGetApproximatePositionIn */
	typedef [public] struct {
		uint32 hcursor;
		uint32 chapt;
		uint32 bmk;
	} wsp_cpmgetapproximatepositionin;

	/* MS-WSP 2.2.3.20 CPMGetApproximatePositionOut */
	typedef [public] struct {
		uint32 numerator;
		uint32 denominator;
	} wsp_cpmgetapproximatepositionout;

	/* MS-WSP 2.2.3.21 CPMCompareBmkIn */
	typedef [public] struct {
		uint32 hcursor;
		uint32 chapt;
		uint32 bmkfirst;
		uint32 bmksecond;
	} wsp_cpmcomparebmkin;

	/* MS-WSP 2.2.3.22 CPMCompareBmkOut */
	typedef [public] struct {
		uint32 dwcomparison;
	} wsp_cpmcomparebmkout;

	/* MS-WSP 2.2.3.1 CPMCiStateInOut */
	typedef [public] struct {
		uint32 cbstruct;
		uint32 cwordlist;
		uint32 cpersistentindex;
		uint32 cqueries;
		uint32 cdocuments;
		uint32 cfreshtest;
		uint32 dwmergeprogress;
		uint32 estate;
		uint32 cfiltereddocuments;
		uint32 ctotaldocuments;
		uint32 cpendingscans;
		uint32 dwindexsize;
		uint32 cuniquekeys;
		uint32 csecqdocuments;
		uint32 dwpropcachesize;
	} wsp_cpmcistateinout;

	/* MS-WSP 2.2.3.27 CPMFindIndicesIn */
	typedef [public] struct {
		uint32 cwids;
		uint32 cdepthprev;
		uint32 pwids[cwids];
		uint32 prgirowprev[cdepthprev];
	} wsp_findindicesin;

	/* MS-WSP 2.2.3.28 CPMFindIndicesOut */
	typedef [public] struct {
		uint32 cdepthnext;
		uint32 prgirownext[cdepthnext];
	} wsp_findindicesout;

	typedef [public] struct {
		uint32 hcursor;
		uint32 chapt;
	} wsp_cpmsresetstartpos;

	typedef [public, nodiscriminant, switch_type(uint32)] union {
		[case(CPMCONNECT)] wsp_cpmconnectin cpmconnect;
		[case(CPMCREATEQUERY)] wsp_cpmcreatequeryin cpmcreatequery;
		[case(CPMFREECURSOR)] wsp_cpmfreecursorin cpmfreecursor;
		[case(CPMGETROWS)] wsp_cpmgetrowsin cpmgetrows;
		[case(CPMSETBINDINGSIN)] wsp_cpmsetbindingsin cpmsetbindings;
		[case(CPMRESTARTPOSITIONIN)] wsp_cpmsresetstartpos cpmresetstartpos;
		[case(CPMGETQUERYSTATUS)] wsp_cpmgetquerystatusin cpmgetquerystatus;
		[case(CPMGETQUERYSTATUSEX)] wsp_cpmgetquerystatusexin cpmgetquerystatusex;
		[case(CPMSETSCOPEPRIORITIZATION)]  wsp_cpmsetscopeprioritizationin cpmsetscopeprioritizationin;
		[case(CPMGETNOTIFY)]; /*header only*/
		[case(CPMGETROWSETNOTIFY)]; /*header only*/
		[case(CPMDISCONNECT)]; /*header only*/
		[case(CPMGETSCOPESTATISTICS)]; /*header only*/
		[case(CPMGETAPPROXIMATEPOSITION)] wsp_cpmgetapproximatepositionin getapproximateposition;
		[case(CPMCOMPAREBMK)] wsp_cpmcomparebmkin cpmcomparebmk;
		[case(CPMCISTATEOUT)] wsp_cpmcistateinout wsp_cpmcistate;
		[case(CPMFINDINDICES)] wsp_findindicesin wsp_findindices;
		[case(CPMRATIOFINISHED)] wsp_cpmratiofinishedin wsp_cpmratiofinished;
		[case(CPMFETCHVALUE)] wsp_cpmfetchvaluein cpmfetchvalue;
	} req_message;

	typedef [public, nodiscriminant, switch_type(uint32)] union {
		[case(CPMCONNECT)] wsp_cpmconnectout cpmconnect;
		[case(CPMCREATEQUERY)] wsp_cpmcreatequeryout cpmcreatequery;
		[case(CPMFREECURSOR)] wsp_cpmfreecursorout cpmfreecursor;
		[case(CPMGETROWS)] wsp_cpmgetrowsout cpmgetrows;
		[case(CPMSETBINDINGSIN)]; /* just has header */
		[case(CPMRESTARTPOSITIONIN)]; /* just has header */
		[case(CPMGETQUERYSTATUS)] wsp_cpmgetquerystatusout cpmgetquerystatus;
		[case(CPMSENDNOTIFYOUT)] wsp_cpmsendnotifyout cpmsendnotifyoutcpmgetquerystatus;
		[case(CPMGETQUERYSTATUSEX)] wsp_cpmgetquerystatusexout cpmgetquerystatusex;
		[case(CPMSETSCOPEPRIORITIZATION)]; /* just had header */
		[case(CPMGETROWSETNOTIFY)] wsp_cpmgetrowsetnotifyout cpmgetrowsetnotifyout;
		[case(CPMGETAPPROXIMATEPOSITION)] wsp_cpmgetapproximatepositionout getapproximateposition;
		[case(CPMCOMPAREBMK)] wsp_cpmcomparebmkout cpmcomparebmk;
		[case(CPMCISTATEOUT)] wsp_cpmcistateinout wsp_cpmcistate;
		[case(CPMFINDINDICES)] wsp_findindicesout wsp_findindices;
		[case(CPMGETSCOPESTATISTICS)] wsp_cpmgetscopestatisticsout cpmgetscopestatistics;
		[case(CPMRATIOFINISHED)] wsp_cpmratiofinishedout wsp_cpmratiofinished;
		[case(CPMFETCHVALUE)] wsp_cpmfetchvalueout cpmfetchvalue;
	} resp_message;

	typedef [public] struct {
		wsp_header header;
		[switch_is(header.msg)] req_message message;
	} wsp_request;

	typedef [public] struct {
		wsp_header header;
		[switch_is(header.msg)] resp_message message;
	} wsp_response;
};