include/webservices.h

   1 /*
   2  * Copyright 2015 Nikolay Sivov for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #ifndef __WINE_WEBSERVICES_H
  20 #define __WINE_WEBSERVICES_H
  21
  22 #ifdef __cplusplus
  23 extern "C" {
  24 #endif  /* __cplusplus */
  25
  26 typedef struct _WS_ERROR WS_ERROR;
  27 typedef struct _WS_HEAP WS_HEAP;
  28 typedef struct _WS_XML_BUFFER WS_XML_BUFFER;
  29 typedef struct _WS_XML_READER WS_XML_READER;
  30 typedef struct _WS_XML_WRITER WS_XML_WRITER;
  31 typedef struct _WS_PROXY_PROPERTY WS_PROXY_PROPERTY;
  32 typedef struct _WS_SECURITY_DESCRIPTION WS_SECURITY_DESCRIPTION;
  33 typedef struct _WS_CHANNEL_PROPERTY WS_CHANNEL_PROPERTY;
  34 typedef struct _WS_SERVICE_PROXY WS_SERVICE_PROXY;
  35 typedef struct _WS_SECURITY_BINDING_PROPERTY WS_SECURITY_BINDING_PROPERTY;
  36 typedef struct _WS_SECURITY_PROPERTY WS_SECURITY_PROPERTY;
  37 typedef struct _WS_SECURITY_PROPERTIES WS_SECURITY_PROPERTIES;
  38 typedef struct _WS_SECURITY_BINDING WS_SECURITY_BINDING;
  39 typedef struct _WS_CHANNEL WS_CHANNEL;
  40 typedef struct _WS_MESSAGE_PROPERTY WS_MESSAGE_PROPERTY;
  41 typedef struct _WS_MESSAGE_PROPERTIES WS_MESSAGE_PROPERTIES;
  42 typedef struct _WS_HTTP_BINDING_TEMPLATE WS_HTTP_BINDING_TEMPLATE;
  43 typedef struct _WS_HTTP_SSL_BINDING_TEMPLATE WS_HTTP_SSL_BINDING_TEMPLATE;
  44 typedef struct _WS_CHANNEL_PROPERTIES WS_CHANNEL_PROPERTIES;
  45 typedef struct _WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE;
  46 typedef struct _WS_SECURITY_BINDING_PROPERTIES WS_SECURITY_BINDING_PROPERTIES;
  47 typedef struct _WS_CERT_CREDENTIAL WS_CERT_CREDENTIAL;
  48 typedef struct _WS_ENDPOINT_ADDRESS WS_ENDPOINT_ADDRESS;
  49 typedef struct _WS_ENDPOINT_IDENTITY WS_ENDPOINT_IDENTITY;
  50 typedef struct _WS_ENUM_DESCRIPTION WS_ENUM_DESCRIPTION;
  51 typedef struct _WS_ENUM_VALUE WS_ENUM_VALUE;
  52 typedef struct _WS_HTTP_POLICY_DESCRIPTION WS_HTTP_POLICY_DESCRIPTION;
  53 typedef struct _WS_MESSAGE WS_MESSAGE;
  54 typedef struct _WS_MESSAGE_DESCRIPTION WS_MESSAGE_DESCRIPTION;
  55 typedef struct _WS_OPERATION_DESCRIPTION WS_OPERATION_DESCRIPTION;
  56 typedef struct _WS_PARAMETER_DESCRIPTION WS_PARAMETER_DESCRIPTION;
  57 typedef struct _WS_OPERATION_CONTEXT WS_OPERATION_CONTEXT;
  58 typedef struct _WS_CALL_PROPERTY WS_CALL_PROPERTY;
  59 typedef struct _WS_DOUBLE_DESCRIPTION WS_DOUBLE_DESCRIPTION;
  60 typedef struct _WS_DATETIME WS_DATETIME;
  61 typedef struct _WS_DATETIME_DESCRIPTION WS_DATETIME_DESCRIPTION;
  62 typedef struct _WS_GUID_DESCRIPTION WS_GUID_DESCRIPTION;
  63 typedef struct _WS_UNIQUE_ID_DESCRIPTION WS_UNIQUE_ID_DESCRIPTION;
  64 typedef struct _WS_URL WS_URL;
  65 typedef struct _WS_HTTP_URL WS_HTTP_URL;
  66 typedef struct _WS_HTTPS_URL WS_HTTPS_URL;
  67 typedef struct _WS_NETTCP_URL WS_NETTCP_URL;
  68 typedef struct _WS_SOAPUDP_URL WS_SOAPUDP_URL;
  69 typedef struct _WS_NETPIPE_URL WS_NETPIPE_URL;
  70 typedef struct _WS_CUSTOM_CHANNEL_CALLBACKS WS_CUSTOM_CHANNEL_CALLBACKS;
  71 typedef struct _WS_CHANNEL_ENCODER WS_CHANNEL_ENCODER;
  72 typedef struct _WS_CHANNEL_DECODER WS_CHANNEL_DECODER;
  73 typedef struct _WS_CUSTOM_HTTP_PROXY WS_CUSTOM_HTTP_PROXY;
  74 typedef struct _WS_HTTP_MESSAGE_MAPPING WS_HTTP_MESSAGE_MAPPING;
  75 typedef struct _WS_HTTP_HEADER_MAPPING WS_HTTP_HEADER_MAPPING;
  76 typedef struct _WS_HTTP_REDIRECT_CALLBACK_CONTEXT WS_HTTP_REDIRECT_CALLBACK_CONTEXT;
  77 typedef struct _WS_PROXY_MESSAGE_CALLBACK_CONTEXT WS_PROXY_MESSAGE_CALLBACK_CONTEXT;
  78
  79 struct _WS_STRUCT_DESCRIPTION;
  80 struct _WS_XML_STRING;
  81
  82 typedef enum {
  83     WS_ERROR_PROPERTY_STRING_COUNT,
  84     WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE,
  85     WS_ERROR_PROPERTY_LANGID
  86 } WS_ERROR_PROPERTY_ID;
  87
  88 typedef struct _WS_ERROR_PROPERTY {
  89     WS_ERROR_PROPERTY_ID id;
  90     void                *value;
  91     ULONG                valueSize;
  92 } WS_ERROR_PROPERTY;
  93
  94 typedef enum {
  95     WS_HEAP_PROPERTY_MAX_SIZE,
  96     WS_HEAP_PROPERTY_TRIM_SIZE,
  97     WS_HEAP_PROPERTY_REQUESTED_SIZE,
  98     WS_HEAP_PROPERTY_ACTUAL_SIZE
  99 } WS_HEAP_PROPERTY_ID;
 100
 101 typedef struct _WS_HEAP_PROPERTY {
 102     WS_HEAP_PROPERTY_ID id;
 103     void               *value;
 104     ULONG               valueSize;
 105 } WS_HEAP_PROPERTY;
 106
 107 typedef ULONG WS_XML_BUFFER_PROPERTY_ID;
 108
 109 typedef struct _WS_XML_BUFFER_PROPERTY {
 110     WS_XML_BUFFER_PROPERTY_ID id;
 111     void                     *value;
 112     ULONG                     valueSize;
 113 } WS_XML_BUFFER_PROPERTY;
 114
 115 typedef enum {
 116     WS_XML_READER_PROPERTY_MAX_DEPTH,
 117     WS_XML_READER_PROPERTY_ALLOW_FRAGMENT,
 118     WS_XML_READER_PROPERTY_MAX_ATTRIBUTES,
 119     WS_XML_READER_PROPERTY_READ_DECLARATION,
 120     WS_XML_READER_PROPERTY_CHARSET,
 121     WS_XML_READER_PROPERTY_ROW,
 122     WS_XML_READER_PROPERTY_COLUMN,
 123     WS_XML_READER_PROPERTY_UTF8_TRIM_SIZE,
 124     WS_XML_READER_PROPERTY_STREAM_BUFFER_SIZE,
 125     WS_XML_READER_PROPERTY_IN_ATTRIBUTE,
 126     WS_XML_READER_PROPERTY_STREAM_MAX_ROOT_MIME_PART_SIZE,
 127     WS_XML_READER_PROPERTY_STREAM_MAX_MIME_HEADERS_SIZE,
 128     WS_XML_READER_PROPERTY_MAX_MIME_PARTS,
 129     WS_XML_READER_PROPERTY_ALLOW_INVALID_CHARACTER_REFERENCES,
 130     WS_XML_READER_PROPERTY_MAX_NAMESPACES
 131 } WS_XML_READER_PROPERTY_ID;
 132
 133 typedef struct _WS_XML_READER_PROPERTY {
 134     WS_XML_READER_PROPERTY_ID id;
 135     void                     *value;
 136     ULONG                     valueSize;
 137 } WS_XML_READER_PROPERTY;
 138
 139 typedef enum {
 140     WS_XML_WRITER_PROPERTY_MAX_DEPTH,
 141     WS_XML_WRITER_PROPERTY_ALLOW_FRAGMENT,
 142     WS_XML_WRITER_PROPERTY_MAX_ATTRIBUTES,
 143     WS_XML_WRITER_PROPERTY_WRITE_DECLARATION,
 144     WS_XML_WRITER_PROPERTY_INDENT,
 145     WS_XML_WRITER_PROPERTY_BUFFER_TRIM_SIZE,
 146     WS_XML_WRITER_PROPERTY_CHARSET,
 147     WS_XML_WRITER_PROPERTY_BUFFERS,
 148     WS_XML_WRITER_PROPERTY_BUFFER_MAX_SIZE,
 149     WS_XML_WRITER_PROPERTY_BYTES,
 150     WS_XML_WRITER_PROPERTY_IN_ATTRIBUTE,
 151     WS_XML_WRITER_PROPERTY_MAX_MIME_PARTS_BUFFER_SIZE,
 152     WS_XML_WRITER_PROPERTY_INITIAL_BUFFER,
 153     WS_XML_WRITER_PROPERTY_ALLOW_INVALID_CHARACTER_REFERENCES,
 154     WS_XML_WRITER_PROPERTY_MAX_NAMESPACES,
 155     WS_XML_WRITER_PROPERTY_BYTES_WRITTEN,
 156     WS_XML_WRITER_PROPERTY_BYTES_TO_CLOSE,
 157     WS_XML_WRITER_PROPERTY_COMPRESS_EMPTY_ELEMENTS,
 158     WS_XML_WRITER_PROPERTY_EMIT_UNCOMPRESSED_EMPTY_ELEMENTS
 159 } WS_XML_WRITER_PROPERTY_ID;
 160
 161 typedef struct _WS_XML_WRITER_PROPERTY {
 162     WS_XML_WRITER_PROPERTY_ID id;
 163     void                     *value;
 164     ULONG                     valueSize;
 165 } WS_XML_WRITER_PROPERTY;
 166
 167 typedef struct _WS_BYTES {
 168     ULONG length;
 169     BYTE *bytes;
 170 } WS_BYTES;
 171
 172 typedef struct _WS_BUFFERS {
 173     ULONG bufferCount;
 174     WS_BYTES *buffers;
 175 } WS_BUFFERS;
 176
 177 typedef enum {
 178     WS_XML_READER_ENCODING_TYPE_TEXT   = 1,
 179     WS_XML_READER_ENCODING_TYPE_BINARY = 2,
 180     WS_XML_READER_ENCODING_TYPE_MTOM   = 3,
 181     WS_XML_READER_ENCODING_TYPE_RAW    = 4
 182 } WS_XML_READER_ENCODING_TYPE;
 183
 184 typedef struct _WS_XML_READER_ENCODING {
 185     WS_XML_READER_ENCODING_TYPE encodingType;
 186 } WS_XML_READER_ENCODING;
 187
 188 typedef enum {
 189     WS_XML_WRITER_ENCODING_TYPE_TEXT   = 1,
 190     WS_XML_WRITER_ENCODING_TYPE_BINARY = 2,
 191     WS_XML_WRITER_ENCODING_TYPE_MTOM   = 3,
 192     WS_XML_WRITER_ENCODING_TYPE_RAW    = 4
 193 } WS_XML_WRITER_ENCODING_TYPE;
 194
 195 typedef struct _WS_XML_WRITER_ENCODING {
 196     WS_XML_WRITER_ENCODING_TYPE encodingType;
 197 } WS_XML_WRITER_ENCODING;
 198
 199 typedef enum {
 200     WS_CHARSET_AUTO,
 201     WS_CHARSET_UTF8,
 202     WS_CHARSET_UTF16LE,
 203     WS_CHARSET_UTF16BE
 204 } WS_CHARSET;
 205
 206 typedef struct _WS_XML_READER_TEXT_ENCODING {
 207     WS_XML_READER_ENCODING encoding;
 208     WS_CHARSET charSet;
 209 } WS_XML_READER_TEXT_ENCODING;
 210
 211 typedef struct _WS_XML_WRITER_TEXT_ENCODING {
 212     WS_XML_WRITER_ENCODING encoding;
 213     WS_CHARSET charSet;
 214 } WS_XML_WRITER_TEXT_ENCODING;
 215
 216 typedef enum {
 217     WS_XML_READER_INPUT_TYPE_BUFFER = 1,
 218     WS_XML_READER_INPUT_TYPE_STREAM = 2
 219 } WS_XML_READER_INPUT_TYPE;
 220
 221 typedef enum {
 222     WS_XML_WRITER_OUTPUT_TYPE_BUFFER = 1,
 223     WS_XML_WRITER_OUTPUT_TYPE_STREAM = 2
 224 } WS_XML_WRITER_OUTPUT_TYPE;
 225
 226 typedef struct _WS_XML_READER_INPUT {
 227     WS_XML_READER_INPUT_TYPE inputType;
 228 } WS_XML_READER_INPUT;
 229
 230 typedef struct _WS_XML_WRITER_OUTPUT {
 231     WS_XML_WRITER_OUTPUT_TYPE outputType;
 232 } WS_XML_WRITER_OUTPUT;
 233
 234 typedef struct _WS_XML_READER_BUFFER_INPUT {
 235     WS_XML_READER_INPUT input;
 236     void *encodedData;
 237     ULONG encodedDataSize;
 238 } WS_XML_READER_BUFFER_INPUT;
 239
 240 typedef struct _WS_XML_WRITER_BUFFER_OUTPUT {
 241     WS_XML_WRITER_OUTPUT output;
 242 } WS_XML_WRITER_BUFFER_OUTPUT;
 243
 244 typedef enum {
 245     WS_SHORT_CALLBACK,
 246     WS_LONG_CALLBACK
 247 } WS_CALLBACK_MODEL;
 248
 249 typedef void (CALLBACK *WS_ASYNC_CALLBACK)
 250     (HRESULT, WS_CALLBACK_MODEL, void *);
 251
 252 typedef struct _WS_ASYNC_CONTEXT {
 253     WS_ASYNC_CALLBACK callback;
 254     void             *callbackState;
 255 } WS_ASYNC_CONTEXT;
 256
 257 typedef HRESULT (CALLBACK *WS_READ_CALLBACK)
 258     (void*, void*, ULONG, ULONG*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
 259
 260 typedef HRESULT (CALLBACK *WS_WRITE_CALLBACK)
 261     (void*, const WS_BYTES*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*);
 262
 263 typedef struct _WS_XML_READER_STREAM_INPUT {
 264     WS_XML_READER_INPUT input;
 265     WS_READ_CALLBACK readCallback;
 266     void *readCallbackState;
 267 } WS_XML_READER_STREAM_INPUT;
 268
 269 typedef struct _WS_XML_DICTIONARY {
 270     GUID                   guid;
 271     struct _WS_XML_STRING *strings;
 272     ULONG                  stringCount;
 273     BOOL                   isConst;
 274 } WS_XML_DICTIONARY;
 275
 276 typedef struct _WS_XML_STRING {
 277     ULONG              length;
 278     BYTE              *bytes;
 279     WS_XML_DICTIONARY *dictionary;
 280     ULONG              id;
 281 } WS_XML_STRING;
 282
 283 typedef enum {
 284     WS_ELEMENT_TYPE_MAPPING         = 1,
 285     WS_ATTRIBUTE_TYPE_MAPPING       = 2,
 286     WS_ELEMENT_CONTENT_TYPE_MAPPING = 3,
 287     WS_ANY_ELEMENT_TYPE_MAPPING     = 4
 288 } WS_TYPE_MAPPING;
 289
 290 typedef enum {
 291     WS_BOOL_TYPE,
 292     WS_INT8_TYPE,
 293     WS_INT16_TYPE,
 294     WS_INT32_TYPE,
 295     WS_INT64_TYPE,
 296     WS_UINT8_TYPE,
 297     WS_UINT16_TYPE,
 298     WS_UINT32_TYPE,
 299     WS_UINT64_TYPE,
 300     WS_FLOAT_TYPE,
 301     WS_DOUBLE_TYPE,
 302     WS_DECIMAL_TYPE,
 303     WS_DATETIME_TYPE,
 304     WS_TIMESPAN_TYPE,
 305     WS_GUID_TYPE,
 306     WS_UNIQUE_ID_TYPE,
 307     WS_STRING_TYPE,
 308     WS_WSZ_TYPE,
 309     WS_BYTES_TYPE,
 310     WS_XML_STRING_TYPE,
 311     WS_XML_QNAME_TYPE,
 312     WS_XML_BUFFER_TYPE,
 313     WS_CHAR_ARRAY_TYPE,
 314     WS_UTF8_ARRAY_TYPE,
 315     WS_BYTE_ARRAY_TYPE,
 316     WS_DESCRIPTION_TYPE,
 317     WS_STRUCT_TYPE,
 318     WS_CUSTOM_TYPE,
 319     WS_ENDPOINT_ADDRESS_TYPE,
 320     WS_FAULT_TYPE,
 321     WS_VOID_TYPE,
 322     WS_ENUM_TYPE,
 323     WS_DURATION_TYPE,
 324     WS_UNION_TYPE,
 325     WS_ANY_ATTRIBUTES_TYPE
 326 } WS_TYPE;
 327
 328 typedef enum {
 329     WS_READ_REQUIRED_VALUE   = 1,
 330     WS_READ_REQUIRED_POINTER = 2,
 331     WS_READ_OPTIONAL_POINTER = 3,
 332     WS_READ_NILLABLE_POINTER = 4,
 333     WS_READ_NILLABLE_VALUE   = 5
 334 } WS_READ_OPTION;
 335
 336 typedef enum {
 337     WS_WRITE_REQUIRED_VALUE   = 1,
 338     WS_WRITE_REQUIRED_POINTER = 2,
 339     WS_WRITE_NILLABLE_VALUE   = 3,
 340     WS_WRITE_NILLABLE_POINTER = 4
 341 } WS_WRITE_OPTION;
 342
 343 typedef struct _WS_BOOL_DESCRIPTION {
 344     BOOL value;
 345 } WS_BOOL_DESCRIPTION;
 346
 347 typedef struct _WS_INT8_DESCRIPTION {
 348     char minValue;
 349     char maxValue;
 350 } WS_INT8_DESCRIPTION;
 351
 352 typedef struct _WS_INT16_DESCRIPTION {
 353     short minValue;
 354     short maxValue;
 355 } WS_INT16_DESCRIPTION;
 356
 357 typedef struct _WS_INT32_DESCRIPTION {
 358     int minValue;
 359     int maxValue;
 360 } WS_INT32_DESCRIPTION;
 361
 362 typedef struct _WS_INT64_DESCRIPTION {
 363     __int64 DECLSPEC_ALIGN(8) minValue;
 364     __int64 DECLSPEC_ALIGN(8) maxValue;
 365 } WS_INT64_DESCRIPTION;
 366
 367 typedef struct _WS_UINT8_DESCRIPTION {
 368     BYTE minValue;
 369     BYTE maxValue;
 370 } WS_UINT8_DESCRIPTION;
 371
 372 typedef struct _WS_UINT16_DESCRIPTION {
 373     USHORT minValue;
 374     USHORT maxValue;
 375 } WS_UINT16_DESCRIPTION;
 376
 377 typedef struct _WS_UINT32_DESCRIPTION {
 378     ULONG minValue;
 379     ULONG maxValue;
 380 } WS_UINT32_DESCRIPTION;
 381
 382 typedef struct _WS_UINT64_DESCRIPTION {
 383     unsigned __int64 DECLSPEC_ALIGN(8) minValue;
 384     unsigned __int64 DECLSPEC_ALIGN(8) maxValue;
 385 } WS_UINT64_DESCRIPTION;
 386
 387 typedef struct _WS_WSZ_DESCRIPTION {
 388     ULONG minCharCount;
 389     ULONG maxCharCount;
 390 } WS_WSZ_DESCRIPTION;
 391
 392 typedef struct _WS_STRING_DESCRIPTION {
 393     ULONG minCharCount;
 394     ULONG maxCharCount;
 395 } WS_STRING_DESCRIPTION;
 396
 397 typedef struct _WS_XML_STRING_DESCRIPTION {
 398     ULONG minByteCount;
 399     ULONG maxByteCount;
 400 } WS_XML_STRING_DESCRIPTION;
 401
 402 struct _WS_ENUM_VALUE {
 403     int value;
 404     WS_XML_STRING *name;
 405 };
 406
 407 struct _WS_ENUM_DESCRIPTION {
 408     WS_ENUM_VALUE *values;
 409     ULONG valueCount;
 410     ULONG maxByteCount;
 411     ULONG *nameIndices;
 412 };
 413
 414 struct _WS_DOUBLE_DESCRIPTION {
 415     double DECLSPEC_ALIGN(8) minValue;
 416     double DECLSPEC_ALIGN(8) maxValue;
 417 };
 418
 419 struct _WS_GUID_DESCRIPTION {
 420     GUID value;
 421 };
 422
 423 struct _WS_UNIQUE_ID_DESCRIPTION {
 424     ULONG minCharCount;
 425     ULONG maxCharCount;
 426 };
 427
 428 typedef enum {
 429     WS_TYPE_ATTRIBUTE_FIELD_MAPPING,
 430     WS_ATTRIBUTE_FIELD_MAPPING,
 431     WS_ELEMENT_FIELD_MAPPING,
 432     WS_REPEATING_ELEMENT_FIELD_MAPPING,
 433     WS_TEXT_FIELD_MAPPING,
 434     WS_NO_FIELD_MAPPING,
 435     WS_XML_ATTRIBUTE_FIELD_MAPPING,
 436     WS_ELEMENT_CHOICE_FIELD_MAPPING,
 437     WS_REPEATING_ELEMENT_CHOICE_FIELD_MAPPING,
 438     WS_ANY_ELEMENT_FIELD_MAPPING,
 439     WS_REPEATING_ANY_ELEMENT_FIELD_MAPPING,
 440     WS_ANY_CONTENT_FIELD_MAPPING,
 441     WS_ANY_ATTRIBUTES_FIELD_MAPPING
 442 } WS_FIELD_MAPPING;
 443
 444 typedef struct _WS_DEFAULT_VALUE {
 445     void *value;
 446     ULONG valueSize;
 447 } WS_DEFAULT_VALUE;
 448
 449 typedef struct _WS_ITEM_RANGE {
 450     ULONG minItemCount;
 451     ULONG maxItemCount;
 452 } WS_ITEM_RANGE;
 453
 454 enum
 455 {
 456     WS_FIELD_POINTER         = 0x1,
 457     WS_FIELD_OPTIONAL        = 0x2,
 458     WS_FIELD_NILLABLE        = 0x4,
 459     WS_FIELD_NILLABLE_ITEM   = 0x8,
 460     WS_FIELD_OTHER_NAMESPACE = 0x10
 461 };
 462
 463 typedef struct _WS_FIELD_DESCRIPTION {
 464     WS_FIELD_MAPPING mapping;
 465     WS_XML_STRING *localName;
 466     WS_XML_STRING *ns;
 467     WS_TYPE type;
 468     void *typeDescription;
 469     ULONG offset;
 470     ULONG options;
 471     WS_DEFAULT_VALUE *defaultValue;
 472     ULONG countOffset;
 473     WS_XML_STRING *itemLocalName;
 474     WS_XML_STRING *itemNs;
 475     WS_ITEM_RANGE *itemRange;
 476 } WS_FIELD_DESCRIPTION;
 477
 478 enum
 479 {
 480     WS_STRUCT_ABSTRACT                        = 0x1,
 481     WS_STRUCT_IGNORE_TRAILING_ELEMENT_CONTENT = 0x2,
 482     WS_STRUCT_IGNORE_UNHANDLED_ATTRIBUTES     = 0x4
 483 };
 484
 485 typedef struct _WS_STRUCT_DESCRIPTION {
 486     ULONG size;
 487     ULONG alignment;
 488     WS_FIELD_DESCRIPTION **fields;
 489     ULONG fieldCount;
 490     WS_XML_STRING *typeLocalName;
 491     WS_XML_STRING *typeNs;
 492     struct _WS_STRUCT_DESCRIPTION *parentType;
 493     struct _WS_STRUCT_DESCRIPTION **subTypes;
 494     ULONG subTypeCount;
 495     ULONG structOptions;
 496 } WS_STRUCT_DESCRIPTION;
 497
 498 typedef struct _WS_ATTRIBUTE_DESCRIPTION {
 499     WS_XML_STRING *attributeLocalName;
 500     WS_XML_STRING *attributeNs;
 501     WS_TYPE type;
 502     void *typeDescription;
 503 } WS_ATTRIBUTE_DESCRIPTION;
 504
 505 typedef struct _WS_ELEMENT_DESCRIPTION {
 506     WS_XML_STRING *elementLocalName;
 507     WS_XML_STRING *elementNs;
 508     WS_TYPE type;
 509     void *typeDescription;
 510 } WS_ELEMENT_DESCRIPTION;
 511
 512 typedef struct _WS_STRING {
 513     ULONG length;
 514     WCHAR *chars;
 515 } WS_STRING;
 516
 517 typedef struct _WS_UNIQUE_ID {
 518     WS_STRING uri;
 519     GUID guid;
 520 } WS_UNIQUE_ID;
 521
 522 typedef enum {
 523     WS_XML_NODE_TYPE_ELEMENT     = 1,
 524     WS_XML_NODE_TYPE_TEXT        = 2,
 525     WS_XML_NODE_TYPE_END_ELEMENT = 3,
 526     WS_XML_NODE_TYPE_COMMENT     = 4,
 527     WS_XML_NODE_TYPE_CDATA       = 6,
 528     WS_XML_NODE_TYPE_END_CDATA   = 7,
 529     WS_XML_NODE_TYPE_EOF         = 8,
 530     WS_XML_NODE_TYPE_BOF         = 9
 531 } WS_XML_NODE_TYPE;
 532
 533 typedef struct _WS_XML_NODE {
 534     WS_XML_NODE_TYPE nodeType;
 535 } WS_XML_NODE;
 536
 537 typedef enum {
 538     WS_MOVE_TO_ROOT_ELEMENT,
 539     WS_MOVE_TO_NEXT_ELEMENT,
 540     WS_MOVE_TO_PREVIOUS_ELEMENT,
 541     WS_MOVE_TO_CHILD_ELEMENT,
 542     WS_MOVE_TO_END_ELEMENT,
 543     WS_MOVE_TO_PARENT_ELEMENT,
 544     WS_MOVE_TO_NEXT_NODE,
 545     WS_MOVE_TO_PREVIOUS_NODE,
 546     WS_MOVE_TO_FIRST_NODE,
 547     WS_MOVE_TO_BOF,
 548     WS_MOVE_TO_EOF,
 549     WS_MOVE_TO_CHILD_NODE
 550 } WS_MOVE_TO;
 551
 552 typedef enum {
 553     WS_XML_TEXT_TYPE_UTF8      = 1,
 554     WS_XML_TEXT_TYPE_UTF16     = 2,
 555     WS_XML_TEXT_TYPE_BASE64    = 3,
 556     WS_XML_TEXT_TYPE_BOOL      = 4,
 557     WS_XML_TEXT_TYPE_INT32     = 5,
 558     WS_XML_TEXT_TYPE_INT64     = 6,
 559     WS_XML_TEXT_TYPE_UINT64    = 7,
 560     WS_XML_TEXT_TYPE_FLOAT     = 8,
 561     WS_XML_TEXT_TYPE_DOUBLE    = 9,
 562     WS_XML_TEXT_TYPE_DECIMAL   = 10,
 563     WS_XML_TEXT_TYPE_GUID      = 11,
 564     WS_XML_TEXT_TYPE_UNIQUE_ID = 12,
 565     WS_XML_TEXT_TYPE_DATETIME  = 13,
 566     WS_XML_TEXT_TYPE_TIMESPAN  = 14,
 567     WS_XML_TEXT_TYPE_QNAME     = 15,
 568     WS_XML_TEXT_TYPE_LIST      = 16
 569 } WS_XML_TEXT_TYPE;
 570
 571 typedef struct _WS_XML_TEXT {
 572     WS_XML_TEXT_TYPE textType;
 573 } WS_XML_TEXT;
 574
 575 typedef struct _WS_XML_UTF8_TEXT {
 576     WS_XML_TEXT text;
 577     WS_XML_STRING value;
 578 } WS_XML_UTF8_TEXT;
 579
 580 typedef struct _WS_XML_UTF16_TEXT {
 581     WS_XML_TEXT text;
 582     BYTE *bytes;
 583     ULONG byteCount;
 584 } WS_XML_UTF16_TEXT;
 585
 586 typedef struct _WS_XML_BOOL_TEXT {
 587     WS_XML_TEXT text;
 588     BOOL value;
 589 } WS_XML_BOOL_TEXT;
 590
 591 typedef struct _WS_XML_INT32_TEXT {
 592     WS_XML_TEXT text;
 593     __int32 value;
 594 } WS_XML_INT32_TEXT;
 595
 596 typedef struct _WS_XML_INT64_TEXT {
 597     WS_XML_TEXT text;
 598     __int64 DECLSPEC_ALIGN(8) value;
 599 } WS_XML_INT64_TEXT;
 600
 601 typedef struct _WS_XML_UINT64_TEXT {
 602     WS_XML_TEXT text;
 603     unsigned __int64 DECLSPEC_ALIGN(8) value;
 604 } WS_XML_UINT64_TEXT;
 605
 606 typedef struct _WS_XML_DOUBLE_TEXT {
 607     WS_XML_TEXT text;
 608     double DECLSPEC_ALIGN(8) value;
 609 } WS_XML_DOUBLE_TEXT;
 610
 611 typedef struct _WS_XML_GUID_TEXT {
 612     WS_XML_TEXT text;
 613     GUID value;
 614 } WS_XML_GUID_TEXT;
 615
 616 typedef struct _WS_XML_UNIQUE_ID_TEXT {
 617     WS_XML_TEXT text;
 618     GUID value;
 619 } WS_XML_UNIQUE_ID_TEXT;
 620
 621 typedef enum {
 622     WS_BOOL_VALUE_TYPE,
 623     WS_INT8_VALUE_TYPE,
 624     WS_INT16_VALUE_TYPE,
 625     WS_INT32_VALUE_TYPE,
 626     WS_INT64_VALUE_TYPE,
 627     WS_UINT8_VALUE_TYPE,
 628     WS_UINT16_VALUE_TYPE,
 629     WS_UINT32_VALUE_TYPE,
 630     WS_UINT64_VALUE_TYPE,
 631     WS_FLOAT_VALUE_TYPE,
 632     WS_DOUBLE_VALUE_TYPE,
 633     WS_DECIMAL_VALUE_TYPE,
 634     WS_DATETIME_VALUE_TYPE,
 635     WS_TIMESPAN_VALUE_TYPE,
 636     WS_GUID_VALUE_TYPE,
 637     WS_DURATION_VALUE_TYPE
 638 } WS_VALUE_TYPE;
 639
 640 typedef struct _WS_XML_ATTRIBUTE {
 641     BYTE singleQuote;
 642     BYTE isXmlNs;
 643     WS_XML_STRING *prefix;
 644     WS_XML_STRING *localName;
 645     WS_XML_STRING *ns;
 646     WS_XML_TEXT *value;
 647 } WS_XML_ATTRIBUTE;
 648
 649 typedef struct _WS_XML_ELEMENT_NODE {
 650     WS_XML_NODE node;
 651     WS_XML_STRING *prefix;
 652     WS_XML_STRING *localName;
 653     WS_XML_STRING *ns;
 654     ULONG attributeCount;
 655     WS_XML_ATTRIBUTE **attributes;
 656     BOOL isEmpty;
 657 } WS_XML_ELEMENT_NODE;
 658
 659 typedef struct _WS_XML_TEXT_NODE {
 660     WS_XML_NODE node;
 661     WS_XML_TEXT *text;
 662 } WS_XML_TEXT_NODE;
 663
 664 typedef struct _WS_XML_COMMENT_NODE {
 665     WS_XML_NODE node;
 666     WS_XML_STRING value;
 667 } WS_XML_COMMENT_NODE;
 668
 669 typedef struct _WS_XML_NODE_POSITION {
 670     WS_XML_BUFFER *buffer;
 671     void *node;
 672 } WS_XML_NODE_POSITION;
 673
 674 typedef enum {
 675     WS_SERVICE_PROXY_STATE_CREATED,
 676     WS_SERVICE_PROXY_STATE_OPENING,
 677     WS_SERVICE_PROXY_STATE_OPEN,
 678     WS_SERVICE_PROXY_STATE_CLOSING,
 679     WS_SERVICE_PROXY_STATE_CLOSED,
 680     WS_SERVICE_PROXY_STATE_FAULTED
 681 } WS_SERVICE_PROXY_STATE;
 682
 683 typedef enum {
 684     WS_PROXY_PROPERTY_CALL_TIMEOUT,
 685     WS_PROXY_PROPERTY_MESSAGE_PROPERTIES,
 686     WS_PROXY_PROPERTY_MAX_CALL_POOL_SIZE,
 687     WS_PROXY_PROPERTY_STATE,
 688     WS_PROXY_PROPERTY_MAX_PENDING_CALLS,
 689     WS_PROXY_PROPERTY_MAX_CLOSE_TIMEOUT,
 690     WS_PROXY_FAULT_LANG_ID
 691 } WS_PROXY_PROPERTY_ID;
 692
 693 struct _WS_PROXY_PROPERTY {
 694     WS_PROXY_PROPERTY_ID id;
 695     void *value;
 696     ULONG valueSize;
 697 };
 698
 699 typedef enum {
 700     WS_CHANNEL_TYPE_INPUT           = 0x1,
 701     WS_CHANNEL_TYPE_OUTPUT          = 0x2,
 702     WS_CHANNEL_TYPE_SESSION         = 0x4,
 703     WS_CHANNEL_TYPE_INPUT_SESSION   = (WS_CHANNEL_TYPE_INPUT  | WS_CHANNEL_TYPE_SESSION),
 704     WS_CHANNEL_TYPE_OUTPUT_SESSION  = (WS_CHANNEL_TYPE_OUTPUT | WS_CHANNEL_TYPE_SESSION),
 705     WS_CHANNEL_TYPE_DUPLEX          = (WS_CHANNEL_TYPE_INPUT  | WS_CHANNEL_TYPE_OUTPUT),
 706     WS_CHANNEL_TYPE_DUPLEX_SESSION  = (WS_CHANNEL_TYPE_INPUT  | WS_CHANNEL_TYPE_OUTPUT | WS_CHANNEL_TYPE_SESSION),
 707     WS_CHANNEL_TYPE_REQUEST         = 0x8,
 708     WS_CHANNEL_TYPE_REPLY           = 0x10
 709 } WS_CHANNEL_TYPE;
 710
 711 typedef enum {
 712     WS_ENCODING_XML_BINARY_1,
 713     WS_ENCODING_XML_BINARY_SESSION_1,
 714     WS_ENCODING_XML_MTOM_UTF8,
 715     WS_ENCODING_XML_MTOM_UTF16BE,
 716     WS_ENCODING_XML_MTOM_UTF16LE,
 717     WS_ENCODING_XML_UTF8,
 718     WS_ENCODING_XML_UTF16BE,
 719     WS_ENCODING_XML_UTF16LE,
 720     WS_ENCODING_RAW
 721 } WS_ENCODING;
 722
 723 typedef enum {
 724     WS_CHANNEL_STATE_CREATED,
 725     WS_CHANNEL_STATE_OPENING,
 726     WS_CHANNEL_STATE_ACCEPTING,
 727     WS_CHANNEL_STATE_OPEN,
 728     WS_CHANNEL_STATE_FAULTED,
 729     WS_CHANNEL_STATE_CLOSING,
 730     WS_CHANNEL_STATE_CLOSED
 731 } WS_CHANNEL_STATE;
 732
 733 typedef enum {
 734     WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE               = 0,
 735     WS_CHANNEL_PROPERTY_MAX_STREAMED_MESSAGE_SIZE               = 1,
 736     WS_CHANNEL_PROPERTY_MAX_STREAMED_START_SIZE                 = 2,
 737     WS_CHANNEL_PROPERTY_MAX_STREAMED_FLUSH_SIZE                 = 3,
 738     WS_CHANNEL_PROPERTY_ENCODING                                = 4,
 739     WS_CHANNEL_PROPERTY_ENVELOPE_VERSION                        = 5,
 740     WS_CHANNEL_PROPERTY_ADDRESSING_VERSION                      = 6,
 741     WS_CHANNEL_PROPERTY_MAX_SESSION_DICTIONARY_SIZE             = 7,
 742     WS_CHANNEL_PROPERTY_STATE                                   = 8,
 743     WS_CHANNEL_PROPERTY_ASYNC_CALLBACK_MODEL                    = 9,
 744     WS_CHANNEL_PROPERTY_IP_VERSION                              = 10,
 745     WS_CHANNEL_PROPERTY_RESOLVE_TIMEOUT                         = 11,
 746     WS_CHANNEL_PROPERTY_CONNECT_TIMEOUT                         = 12,
 747     WS_CHANNEL_PROPERTY_SEND_TIMEOUT                            = 13,
 748     WS_CHANNEL_PROPERTY_RECEIVE_RESPONSE_TIMEOUT                = 14,
 749     WS_CHANNEL_PROPERTY_RECEIVE_TIMEOUT                         = 15,
 750     WS_CHANNEL_PROPERTY_CLOSE_TIMEOUT                           = 16,
 751     WS_CHANNEL_PROPERTY_ENABLE_TIMEOUTS                         = 17,
 752     WS_CHANNEL_PROPERTY_TRANSFER_MODE                           = 18,
 753     WS_CHANNEL_PROPERTY_MULTICAST_INTERFACE                     = 19,
 754     WS_CHANNEL_PROPERTY_MULTICAST_HOPS                          = 20,
 755     WS_CHANNEL_PROPERTY_REMOTE_ADDRESS                          = 21,
 756     WS_CHANNEL_PROPERTY_REMOTE_IP_ADDRESS                       = 22,
 757     WS_CHANNEL_PROPERTY_HTTP_CONNECTION_ID                      = 23,
 758     WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_CALLBACKS                = 24,
 759     WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_PARAMETERS               = 25,
 760     WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_INSTANCE                 = 26,
 761     WS_CHANNEL_PROPERTY_TRANSPORT_URL                           = 27,
 762     WS_CHANNEL_PROPERTY_NO_DELAY                                = 28,
 763     WS_CHANNEL_PROPERTY_SEND_KEEP_ALIVES                        = 29,
 764     WS_CHANNEL_PROPERTY_KEEP_ALIVE_TIME                         = 30,
 765     WS_CHANNEL_PROPERTY_KEEP_ALIVE_INTERVAL                     = 31,
 766     WS_CHANNEL_PROPERTY_MAX_HTTP_SERVER_CONNECTIONS             = 32,
 767     WS_CHANNEL_PROPERTY_IS_SESSION_SHUT_DOWN                    = 33,
 768     WS_CHANNEL_PROPERTY_CHANNEL_TYPE                            = 34,
 769     WS_CHANNEL_PROPERTY_TRIM_BUFFERED_MESSAGE_SIZE              = 35,
 770     WS_CHANNEL_PROPERTY_ENCODER                                 = 36,
 771     WS_CHANNEL_PROPERTY_DECODER                                 = 37,
 772     WS_CHANNEL_PROPERTY_PROTECTION_LEVEL                        = 38,
 773     WS_CHANNEL_PROPERTY_COOKIE_MODE                             = 39,
 774     WS_CHANNEL_PROPERTY_HTTP_PROXY_SETTING_MODE                 = 40,
 775     WS_CHANNEL_PROPERTY_CUSTOM_HTTP_PROXY                       = 41,
 776     WS_CHANNEL_PROPERTY_HTTP_MESSAGE_MAPPING                    = 42,
 777     WS_CHANNEL_PROPERTY_ENABLE_HTTP_REDIRECT                    = 43,
 778     WS_CHANNEL_PROPERTY_HTTP_REDIRECT_CALLBACK_CONTEXT          = 44,
 779     WS_CHANNEL_PROPERTY_FAULTS_AS_ERRORS                        = 45,
 780     WS_CHANNEL_PROPERTY_ALLOW_UNSECURED_FAULTS                  = 46,
 781     WS_CHANNEL_PROPERTY_HTTP_SERVER_SPN                         = 47,
 782     WS_CHANNEL_PROPERTY_HTTP_PROXY_SPN                          = 48,
 783     WS_CHANNEL_PROPERTY_MAX_HTTP_REQUEST_HEADERS_BUFFER_SIZE    = 49
 784 } WS_CHANNEL_PROPERTY_ID;
 785
 786 struct _WS_CHANNEL_PROPERTY {
 787     WS_CHANNEL_PROPERTY_ID id;
 788     void *value;
 789     ULONG valueSize;
 790 };
 791
 792 struct _WS_CHANNEL_PROPERTIES {
 793     WS_CHANNEL_PROPERTY *properties;
 794     ULONG propertyCount;
 795 };
 796
 797 typedef enum {
 798     WS_HTTP_CHANNEL_BINDING,
 799     WS_TCP_CHANNEL_BINDING,
 800     WS_UDP_CHANNEL_BINDING,
 801     WS_CUSTOM_CHANNEL_BINDING,
 802     WS_NAMEDPIPE_CHANNEL_BINDING
 803 } WS_CHANNEL_BINDING;
 804
 805 typedef enum {
 806     WS_SSL_TRANSPORT_SECURITY_BINDING_TYPE,
 807     WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TYPE,
 808     WS_HTTP_HEADER_AUTH_SECURITY_BINDING_TYPE,
 809     WS_USERNAME_MESSAGE_SECURITY_BINDING_TYPE,
 810     WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TYPE,
 811     WS_XML_TOKEN_MESSAGE_SECURITY_BINDING_TYPE,
 812     WS_SAML_MESSAGE_SECURITY_BINDING_TYPE,
 813     WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_TYPE,
 814     WS_NAMEDPIPE_SSPI_TRANSPORT_SECURITY_BINDING_TYPE
 815 } WS_SECURITY_BINDING_TYPE;
 816
 817 typedef enum {
 818     WS_SECURITY_BINDING_PROPERTY_REQUIRE_SSL_CLIENT_CERT                    = 1,
 819     WS_SECURITY_BINDING_PROPERTY_WINDOWS_INTEGRATED_AUTH_PACKAGE            = 2,
 820     WS_SECURITY_BINDING_PROPERTY_REQUIRE_SERVER_AUTH                        = 3,
 821     WS_SECURITY_BINDING_PROPERTY_ALLOW_ANONYMOUS_CLIENTS                    = 4,
 822     WS_SECURITY_BINDING_PROPERTY_ALLOWED_IMPERSONATION_LEVEL                = 5,
 823     WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_SCHEME                    = 6,
 824     WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_TARGET                    = 7,
 825     WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_BASIC_REALM               = 8,
 826     WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_DIGEST_REALM              = 9,
 827     WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_DIGEST_DOMAIN             = 10,
 828     WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_KEY_SIZE                  = 11,
 829     WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_KEY_ENTROPY_MODE          = 12,
 830     WS_SECURITY_BINDING_PROPERTY_MESSAGE_PROPERTIES                         = 13,
 831     WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_MAX_PENDING_CONTEXTS      = 14,
 832     WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_MAX_ACTIVE_CONTEXTS       = 15,
 833     WS_SECURITY_BINDING_PROPERTY_SECURE_CONVERSATION_VERSION                = 16,
 834     WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_SUPPORT_RENEW             = 17,
 835     WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_RENEWAL_INTERVAL          = 18,
 836     WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_ROLLOVER_INTERVAL         = 19,
 837     WS_SECURITY_BINDING_PROPERTY_CERT_FAILURES_TO_IGNORE                    = 20,
 838     WS_SECURITY_BINDING_PROPERTY_DISABLE_CERT_REVOCATION_CHECK              = 21,
 839     WS_SECURITY_BINDING_PROPERTY_DISALLOWED_SECURE_PROTOCOLS                = 22,
 840     WS_SECURITY_BINDING_PROPERTY_CERTIFICATE_VALIDATION_CALLBACK_CONTEXT    = 23
 841 } WS_SECURITY_BINDING_PROPERTY_ID;
 842
 843 struct _WS_SECURITY_BINDING_PROPERTY {
 844     WS_SECURITY_BINDING_PROPERTY_ID id;
 845     void *value;
 846     ULONG valueSize;
 847 };
 848
 849 struct _WS_SECURITY_BINDING_PROPERTIES {
 850     WS_SECURITY_BINDING_PROPERTY *properties;
 851     ULONG propertyCount;
 852 };
 853
 854 struct _WS_SECURITY_BINDING {
 855     WS_SECURITY_BINDING_TYPE bindingType;
 856     WS_SECURITY_BINDING_PROPERTY *properties;
 857     ULONG propertyCount;
 858 };
 859
 860 typedef enum {
 861     WS_SECURITY_PROPERTY_TRANSPORT_PROTECTION_LEVEL     = 1,
 862     WS_SECURITY_PROPERTY_ALGORITHM_SUITE                = 2,
 863     WS_SECURITY_PROPERTY_ALGORITHM_SUITE_NAME           = 3,
 864     WS_SECURITY_PROPERTY_MAX_ALLOWED_LATENCY            = 4,
 865     WS_SECURITY_PROPERTY_TIMESTAMP_VALIDITY_DURATION    = 5,
 866     WS_SECURITY_PROPERTY_MAX_ALLOWED_CLOCK_SKEW         = 6,
 867     WS_SECURITY_PROPERTY_TIMESTAMP_USAGE                = 7,
 868     WS_SECURITY_PROPERTY_SECURITY_HEADER_LAYOUT         = 8,
 869     WS_SECURITY_PROPERTY_SECURITY_HEADER_VERSION        = 9,
 870     WS_SECURITY_PROPERTY_EXTENDED_PROTECTION_POLICY     = 10,
 871     WS_SECURITY_PROPERTY_EXTENDED_PROTECTION_SCENARIO   = 11,
 872     WS_SECURITY_PROPERTY_SERVICE_IDENTITIES             = 12
 873 } WS_SECURITY_PROPERTY_ID;
 874
 875 struct _WS_SECURITY_PROPERTY {
 876     WS_SECURITY_PROPERTY_ID id;
 877     void *value;
 878     ULONG valueSize;
 879 };
 880
 881 struct _WS_SECURITY_PROPERTIES {
 882     WS_SECURITY_PROPERTY *properties;
 883     ULONG propertyCount;
 884 };
 885
 886 struct _WS_SECURITY_DESCRIPTION {
 887     WS_SECURITY_BINDING **securityBindings;
 888     ULONG securityBindingCount;
 889     WS_SECURITY_PROPERTY *properties;
 890     ULONG propertyCount;
 891 };
 892
 893 typedef enum {
 894     WS_HTTP_BINDING_TEMPLATE_TYPE,
 895     WS_HTTP_SSL_BINDING_TEMPLATE_TYPE,
 896     WS_HTTP_HEADER_AUTH_BINDING_TEMPLATE_TYPE,
 897     WS_HTTP_SSL_HEADER_AUTH_BINDING_TEMPLATE_TYPE,
 898     WS_HTTP_SSL_USERNAME_BINDING_TEMPLATE_TYPE,
 899     WS_HTTP_SSL_KERBEROS_APREQ_BINDING_TEMPLATE_TYPE,
 900     WS_TCP_BINDING_TEMPLATE_TYPE,
 901     WS_TCP_SSPI_BINDING_TEMPLATE_TYPE,
 902     WS_TCP_SSPI_USERNAME_BINDING_TEMPLATE_TYPE,
 903     WS_TCP_SSPI_KERBEROS_APREQ_BINDING_TEMPLATE_TYPE,
 904     WS_HTTP_SSL_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE,
 905     WS_HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE,
 906     WS_TCP_SSPI_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE,
 907     WS_TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE
 908 } WS_BINDING_TEMPLATE_TYPE;
 909
 910 typedef enum {
 911     WS_SUBJECT_NAME_CERT_CREDENTIAL_TYPE    = 1,
 912     WS_THUMBPRINT_CERT_CREDENTIAL_TYPE      = 2,
 913     WS_CUSTOM_CERT_CREDENTIAL_TYPE          = 3
 914 } WS_CERT_CREDENTIAL_TYPE;
 915
 916 struct _WS_CERT_CREDENTIAL {
 917     WS_CERT_CREDENTIAL_TYPE credentialType;
 918 };
 919
 920 struct _WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE {
 921     WS_SECURITY_BINDING_PROPERTIES securityBindingProperties;
 922     WS_CERT_CREDENTIAL *localCertCredential;
 923 };
 924
 925 struct _WS_HTTP_BINDING_TEMPLATE {
 926     WS_CHANNEL_PROPERTIES channelProperties;
 927 };
 928
 929 struct _WS_HTTP_SSL_BINDING_TEMPLATE {
 930     WS_CHANNEL_PROPERTIES channelProperties;
 931     WS_SECURITY_PROPERTIES securityProperties;
 932     WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE sslTransportSecurityBinding;
 933 };
 934
 935 enum {
 936     WS_MUST_UNDERSTAND_HEADER_ATTRIBUTE = 0x1,
 937     WS_RELAY_HEADER_ATTRIBUTE           = 0x2
 938 };
 939
 940 typedef enum {
 941     WS_ADDRESSING_VERSION_0_9       = 1,
 942     WS_ADDRESSING_VERSION_1_0       = 2,
 943     WS_ADDRESSING_VERSION_TRANSPORT = 3
 944 } WS_ADDRESSING_VERSION;
 945
 946 typedef enum {
 947     WS_ENVELOPE_VERSION_SOAP_1_1    = 1,
 948     WS_ENVELOPE_VERSION_SOAP_1_2    = 2,
 949     WS_ENVELOPE_VERSION_NONE        = 3
 950 } WS_ENVELOPE_VERSION;
 951
 952 typedef enum {
 953     WS_MESSAGE_PROPERTY_STATE,
 954     WS_MESSAGE_PROPERTY_HEAP,
 955     WS_MESSAGE_PROPERTY_ENVELOPE_VERSION,
 956     WS_MESSAGE_PROPERTY_ADDRESSING_VERSION,
 957     WS_MESSAGE_PROPERTY_HEADER_BUFFER,
 958     WS_MESSAGE_PROPERTY_HEADER_POSITION,
 959     WS_MESSAGE_PROPERTY_BODY_READER,
 960     WS_MESSAGE_PROPERTY_BODY_WRITER,
 961     WS_MESSAGE_PROPERTY_IS_ADDRESSED,
 962     WS_MESSAGE_PROPERTY_HEAP_PROPERTIES,
 963     WS_MESSAGE_PROPERTY_XML_READER_PROPERTIES,
 964     WS_MESSAGE_PROPERTY_XML_WRITER_PROPERTIES,
 965     WS_MESSAGE_PROPERTY_IS_FAULT,
 966     WS_MESSAGE_PROPERTY_MAX_PROCESSED_HEADERS,
 967     WS_MESSAGE_PROPERTY_USERNAME,
 968     WS_MESSAGE_PROPERTY_ENCODED_CERT,
 969     WS_MESSAGE_PROPERTY_TRANSPORT_SECURITY_WINDOWS_TOKEN,
 970     WS_MESSAGE_PROPERTY_HTTP_HEADER_AUTH_WINDOWS_TOKEN,
 971     WS_MESSAGE_PROPERTY_MESSAGE_SECURITY_WINDOWS_TOKEN,
 972     WS_MESSAGE_PROPERTY_SAML_ASSERTION,
 973     WS_MESSAGE_PROPERTY_SECURITY_CONTEXT,
 974     WS_MESSAGE_PROPERTY_PROTECTION_LEVEL
 975 } WS_MESSAGE_PROPERTY_ID;
 976
 977 struct _WS_MESSAGE_PROPERTY {
 978     WS_MESSAGE_PROPERTY_ID id;
 979     void *value;
 980     ULONG valueSize;
 981 };
 982
 983 struct _WS_MESSAGE_PROPERTIES {
 984     WS_MESSAGE_PROPERTY *properties;
 985     ULONG propertyCount;
 986 };
 987
 988 typedef enum {
 989     WS_MESSAGE_STATE_EMPTY          = 1,
 990     WS_MESSAGE_STATE_INITIALIZED    = 2,
 991     WS_MESSAGE_STATE_READING        = 3,
 992     WS_MESSAGE_STATE_WRITING        = 4,
 993     WS_MESSAGE_STATE_DONE           = 5
 994 } WS_MESSAGE_STATE;
 995
 996 typedef enum {
 997     WS_BLANK_MESSAGE,
 998     WS_DUPLICATE_MESSAGE,
 999     WS_REQUEST_MESSAGE,
1000     WS_REPLY_MESSAGE,
1001     WS_FAULT_MESSAGE
1002 } WS_MESSAGE_INITIALIZATION;
1003
1004 typedef enum {
1005     WS_ACTION_HEADER        = 1,
1006     WS_TO_HEADER            = 2,
1007     WS_MESSAGE_ID_HEADER    = 3,
1008     WS_RELATES_TO_HEADER    = 4,
1009     WS_FROM_HEADER          = 5,
1010     WS_REPLY_TO_HEADER      = 6,
1011     WS_FAULT_TO_HEADER      = 7
1012 } WS_HEADER_TYPE;
1013
1014 typedef enum {
1015     WS_DNS_ENDPOINT_IDENTITY_TYPE       = 1,
1016     WS_UPN_ENDPOINT_IDENTITY_TYPE       = 2,
1017     WS_SPN_ENDPOINT_IDENTITY_TYPE       = 3,
1018     WS_RSA_ENDPOINT_IDENTITY_TYPE       = 4,
1019     WS_CERT_ENDPOINT_IDENTITY_TYPE      = 5,
1020     WS_UNKNOWN_ENDPOINT_IDENTITY_TYPE   = 6
1021 } WS_ENDPOINT_IDENTITY_TYPE;
1022
1023 struct _WS_ENDPOINT_IDENTITY {
1024     WS_ENDPOINT_IDENTITY_TYPE identityType;
1025 };
1026
1027 struct _WS_ENDPOINT_ADDRESS {
1028     WS_STRING url;
1029     WS_XML_BUFFER *headers;
1030     WS_XML_BUFFER *extensions;
1031     WS_ENDPOINT_IDENTITY *identity;
1032 };
1033
1034 struct _WS_HTTP_POLICY_DESCRIPTION {
1035     WS_CHANNEL_PROPERTIES channelProperties;
1036 };
1037
1038 struct _WS_MESSAGE_DESCRIPTION {
1039     WS_XML_STRING *action;
1040     WS_ELEMENT_DESCRIPTION *bodyElementDescription;
1041 };
1042
1043 typedef enum {
1044     WS_PARAMETER_TYPE_NORMAL,
1045     WS_PARAMETER_TYPE_ARRAY,
1046     WS_PARAMETER_TYPE_ARRAY_COUNT,
1047     WS_PARAMETER_TYPE_MESSAGES
1048 } WS_PARAMETER_TYPE;
1049
1050 struct _WS_PARAMETER_DESCRIPTION {
1051     WS_PARAMETER_TYPE parameterType;
1052     USHORT inputMessageIndex;
1053     USHORT outputMessageIndex;
1054 };
1055
1056 typedef HRESULT (CALLBACK *WS_SERVICE_STUB_CALLBACK)(
1057     const WS_OPERATION_CONTEXT *context,
1058     void *frame,
1059     const void *callback,
1060     const WS_ASYNC_CONTEXT *asyncContext,
1061     WS_ERROR *error );
1062
1063 typedef enum {
1064     WS_NON_RPC_LITERAL_OPERATION,
1065     WS_RPC_LITERAL_OPERATION
1066 } WS_OPERATION_STYLE;
1067
1068 struct _WS_OPERATION_DESCRIPTION {
1069     ULONG versionInfo;
1070     WS_MESSAGE_DESCRIPTION *inputMessageDescription;
1071     WS_MESSAGE_DESCRIPTION *outputMessageDescription;
1072     ULONG inputMessageOptions;
1073     ULONG outputMessageOptions;
1074     USHORT parameterCount;
1075     WS_PARAMETER_DESCRIPTION *parameterDescription;
1076     WS_SERVICE_STUB_CALLBACK stubCallback;
1077     WS_OPERATION_STYLE style;
1078 };
1079
1080 typedef enum {
1081     WS_CALL_PROPERTY_CHECK_MUST_UNDERSTAND,
1082     WS_CALL_PROPERTY_SEND_MESSAGE_CONTEXT,
1083     WS_CALL_PROPERTY_RECEIVE_MESSAGE_CONTEXT,
1084     WS_CALL_PROPERTY_CALL_ID
1085 } WS_CALL_PROPERTY_ID;
1086
1087 struct _WS_CALL_PROPERTY {
1088     WS_CALL_PROPERTY_ID id;
1089     void *value;
1090     ULONG valueSize;
1091 };
1092
1093 typedef enum {
1094     WS_DATETIME_FORMAT_UTC,
1095     WS_DATETIME_FORMAT_LOCAL,
1096     WS_DATETIME_FORMAT_NONE
1097 } WS_DATETIME_FORMAT;
1098
1099 struct _WS_DATETIME {
1100     unsigned __int64 DECLSPEC_ALIGN(8) ticks;
1101     WS_DATETIME_FORMAT format;
1102 };
1103
1104 struct _WS_DATETIME_DESCRIPTION {
1105     WS_DATETIME minValue;
1106     WS_DATETIME maxValue;
1107 };
1108
1109 typedef enum {
1110     WS_URL_HTTP_SCHEME_TYPE,
1111     WS_URL_HTTPS_SCHEME_TYPE,
1112     WS_URL_NETTCP_SCHEME_TYPE,
1113     WS_URL_SOAPUDP_SCHEME_TYPE,
1114     WS_URL_NETPIPE_SCHEME_TYPE
1115 } WS_URL_SCHEME_TYPE;
1116
1117 enum {
1118     WS_URL_FLAGS_ALLOW_HOST_WILDCARDS   = 0x1,
1119     WS_URL_FLAGS_NO_PATH_COLLAPSE       = 0x2,
1120     WS_URL_FLAGS_ZERO_TERMINATE         = 0x4
1121 };
1122
1123 struct _WS_URL {
1124     WS_URL_SCHEME_TYPE scheme;
1125 };
1126
1127 struct _WS_HTTP_URL {
1128     WS_URL url;
1129     WS_STRING host;
1130     USHORT port;
1131     WS_STRING portAsString;
1132     WS_STRING path;
1133     WS_STRING query;
1134     WS_STRING fragment;
1135 };
1136
1137 struct _WS_HTTPS_URL {
1138     WS_URL url;
1139     WS_STRING host;
1140     USHORT port;
1141     WS_STRING portAsString;
1142     WS_STRING path;
1143     WS_STRING query;
1144     WS_STRING fragment;
1145 };
1146
1147 struct _WS_SOAPUDP_URL {
1148     WS_URL url;
1149     WS_STRING host;
1150     USHORT port;
1151     WS_STRING portAsString;
1152     WS_STRING path;
1153     WS_STRING query;
1154     WS_STRING fragment;
1155 };
1156
1157 struct _WS_NETPIPE_URL {
1158     WS_URL url;
1159     WS_STRING host;
1160     USHORT port;
1161     WS_STRING portAsString;
1162     WS_STRING path;
1163     WS_STRING query;
1164     WS_STRING fragment;
1165 };
1166
1167 typedef enum
1168 {
1169     WS_IP_VERSION_4    = 1,
1170     WS_IP_VERSION_6    = 2,
1171     WS_IP_VERSION_AUTO = 3
1172 } WS_IP_VERSION;
1173
1174 typedef enum
1175 {
1176     WS_BUFFERED_TRANSFER_MODE        = 0x0,
1177     WS_STREAMED_INPUT_TRANSFER_MODE  = 0x1,
1178     WS_STREAMED_OUTPUT_TRANSFER_MODE = 0x2,
1179     WS_STREAMED_TRANSFER_MODE        = (WS_STREAMED_INPUT_TRANSFER_MODE|WS_STREAMED_OUTPUT_TRANSFER_MODE)
1180 } WS_TRANSFER_MODE;
1181
1182 typedef HRESULT (CALLBACK *WS_CREATE_CHANNEL_CALLBACK)
1183     (WS_CHANNEL_TYPE, const void*, ULONG, void**, WS_ERROR*);
1184
1185 typedef void (CALLBACK *WS_FREE_CHANNEL_CALLBACK)
1186     (void*);
1187
1188 typedef HRESULT (CALLBACK *WS_RESET_CHANNEL_CALLBACK)
1189     (void*, WS_ERROR*);
1190
1191 typedef HRESULT (CALLBACK *WS_OPEN_CHANNEL_CALLBACK)
1192     (void*, const WS_ENDPOINT_ADDRESS*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1193
1194 typedef HRESULT (CALLBACK *WS_CLOSE_CHANNEL_CALLBACK)
1195     (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1196
1197 typedef HRESULT (CALLBACK *WS_ABORT_CHANNEL_CALLBACK)
1198     (void*, WS_ERROR*);
1199
1200 typedef HRESULT (CALLBACK *WS_GET_CHANNEL_PROPERTY_CALLBACK)
1201     (void*, WS_CHANNEL_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1202
1203 typedef HRESULT (CALLBACK *WS_SET_CHANNEL_PROPERTY_CALLBACK)
1204     (void*, WS_CHANNEL_PROPERTY_ID, const void*, ULONG, WS_ERROR*);
1205
1206 typedef HRESULT (CALLBACK *WS_WRITE_MESSAGE_START_CALLBACK)
1207     (void*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1208
1209 typedef HRESULT (CALLBACK *WS_WRITE_MESSAGE_END_CALLBACK)
1210     (void*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1211
1212 typedef HRESULT (CALLBACK *WS_READ_MESSAGE_START_CALLBACK)
1213     (void*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1214
1215 typedef HRESULT (CALLBACK *WS_READ_MESSAGE_END_CALLBACK)
1216     (void*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1217
1218 typedef HRESULT (CALLBACK *WS_ABANDON_MESSAGE_CALLBACK)
1219     (void*, WS_MESSAGE*, WS_ERROR*);
1220
1221 typedef HRESULT (CALLBACK *WS_SHUTDOWN_SESSION_CHANNEL_CALLBACK)
1222     (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1223
1224 struct _WS_CUSTOM_CHANNEL_CALLBACKS
1225 {
1226     WS_CREATE_CHANNEL_CALLBACK createChannelCallback;
1227     WS_FREE_CHANNEL_CALLBACK freeChannelCallback;
1228     WS_RESET_CHANNEL_CALLBACK resetChannelCallback;
1229     WS_OPEN_CHANNEL_CALLBACK openChannelCallback;
1230     WS_CLOSE_CHANNEL_CALLBACK closeChannelCallback;
1231     WS_ABORT_CHANNEL_CALLBACK abortChannelCallback;
1232     WS_GET_CHANNEL_PROPERTY_CALLBACK getChannelPropertyCallback;
1233     WS_SET_CHANNEL_PROPERTY_CALLBACK setChannelPropertyCallback;
1234     WS_WRITE_MESSAGE_START_CALLBACK writeMessageStartCallback;
1235     WS_WRITE_MESSAGE_END_CALLBACK writeMessageEndCallback;
1236     WS_READ_MESSAGE_START_CALLBACK readMessageStartCallback;
1237     WS_READ_MESSAGE_END_CALLBACK readMessageEndCallback;
1238     WS_ABANDON_MESSAGE_CALLBACK abandonMessageCallback;
1239     WS_SHUTDOWN_SESSION_CHANNEL_CALLBACK shutdownSessionChannelCallback;
1240 };
1241
1242 typedef HRESULT (CALLBACK *WS_CREATE_ENCODER_CALLBACK)
1243     (void*, WS_WRITE_CALLBACK, void*, void**, WS_ERROR*);
1244
1245 typedef HRESULT (CALLBACK *WS_ENCODER_GET_CONTENT_TYPE_CALLBACK)
1246     (void*, const WS_STRING*, WS_STRING*, WS_STRING*, WS_ERROR*);
1247
1248 typedef HRESULT (CALLBACK *WS_ENCODER_START_CALLBACK)
1249     (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1250
1251 typedef HRESULT (CALLBACK *WS_ENCODER_ENCODE_CALLBACK)
1252     (void*, const WS_BYTES*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1253
1254 typedef HRESULT (CALLBACK *WS_ENCODER_END_CALLBACK)
1255     (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1256
1257 typedef void (CALLBACK *WS_FREE_ENCODER_CALLBACK)
1258     (void*);
1259
1260 struct _WS_CHANNEL_ENCODER
1261 {
1262     void *createContext;
1263     WS_CREATE_ENCODER_CALLBACK createEncoderCallback;
1264     WS_ENCODER_GET_CONTENT_TYPE_CALLBACK encoderGetContentTypeCallback;
1265     WS_ENCODER_START_CALLBACK encoderStartCallback;
1266     WS_ENCODER_ENCODE_CALLBACK encoderEncodeCallback;
1267     WS_ENCODER_END_CALLBACK encoderEndCallback;
1268     WS_FREE_ENCODER_CALLBACK freeEncoderCallback;
1269 };
1270
1271 typedef HRESULT (CALLBACK *WS_CREATE_DECODER_CALLBACK)
1272     (void*, WS_READ_CALLBACK, void*, void**, WS_ERROR*);
1273
1274 typedef HRESULT (CALLBACK *WS_DECODER_GET_CONTENT_TYPE_CALLBACK)
1275     (void*, const WS_STRING*, const WS_STRING*, WS_STRING*, WS_ERROR*);
1276
1277 typedef HRESULT (CALLBACK *WS_DECODER_START_CALLBACK)
1278     (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1279
1280 typedef HRESULT (CALLBACK *WS_DECODER_DECODE_CALLBACK)
1281     (void*, void*, ULONG, ULONG*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1282
1283 typedef HRESULT (CALLBACK *WS_DECODER_END_CALLBACK)
1284     (void*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1285
1286 typedef void (CALLBACK *WS_FREE_DECODER_CALLBACK)
1287     (void*);
1288
1289 struct _WS_CHANNEL_DECODER
1290 {
1291     void *createContext;
1292     WS_CREATE_DECODER_CALLBACK createDecoderCallback;
1293     WS_DECODER_GET_CONTENT_TYPE_CALLBACK decoderGetContentTypeCallback;
1294     WS_DECODER_START_CALLBACK decoderStartCallback;
1295     WS_DECODER_DECODE_CALLBACK decoderDecodeCallback;
1296     WS_DECODER_END_CALLBACK decoderEndCallback;
1297     WS_FREE_DECODER_CALLBACK freeDecoderCallback;
1298 };
1299
1300 typedef enum
1301 {
1302     WS_PROTECTION_LEVEL_NONE             = 1,
1303     WS_PROTECTION_LEVEL_SIGN             = 2,
1304     WS_PROTECTION_LEVEL_SIGN_AND_ENCRYPT = 3
1305 } WS_PROTECTION_LEVEL;
1306
1307 typedef enum
1308 {
1309     WS_MANUAL_COOKIE_MODE = 1,
1310     WS_AUTO_COOKIE_MODE   = 2
1311 } WS_COOKIE_MODE;
1312
1313 typedef enum
1314 {
1315     WS_HTTP_PROXY_SETTING_MODE_AUTO   = 0x1,
1316     WS_HTTP_PROXY_SETTING_MODE_NONE   = 0x2,
1317     WS_HTTP_PROXY_SETTING_MODE_CUSTOM = 0x3
1318 } WS_HTTP_PROXY_SETTING_MODE;
1319
1320 struct _WS_CUSTOM_HTTP_PROXY
1321 {
1322     WS_STRING servers;
1323     WS_STRING bypass;
1324 };
1325
1326 struct _WS_HTTP_HEADER_MAPPING
1327 {
1328     WS_XML_STRING headerName;
1329     ULONG headerMappingOptions;
1330 };
1331
1332 struct _WS_HTTP_MESSAGE_MAPPING
1333 {
1334     ULONG requestMappingOptions;
1335     ULONG responseMappingOptions;
1336     WS_HTTP_HEADER_MAPPING **requestHeaderMappings;
1337     ULONG requestHeaderMappingCount;
1338     WS_HTTP_HEADER_MAPPING **responseHeaderMappings;
1339     ULONG responseHeaderMappingCount;
1340 };
1341
1342 typedef HRESULT (CALLBACK *WS_HTTP_REDIRECT_CALLBACK)
1343     (void*, const WS_STRING*, const WS_STRING*);
1344
1345 struct _WS_HTTP_REDIRECT_CALLBACK_CONTEXT
1346 {
1347     WS_HTTP_REDIRECT_CALLBACK callback;
1348     void *state;
1349 };
1350
1351 typedef enum
1352 {
1353     WS_RECEIVE_REQUIRED_MESSAGE = 1,
1354     WS_RECEIVE_OPTIONAL_MESSAGE = 2
1355 } WS_RECEIVE_OPTION;
1356
1357 typedef void (CALLBACK *WS_MESSAGE_DONE_CALLBACK)
1358     (void*);
1359
1360 typedef HRESULT (CALLBACK *WS_PROXY_MESSAGE_CALLBACK)
1361     (WS_MESSAGE*, WS_HEAP*, void*, WS_ERROR*);
1362
1363 struct _WS_PROXY_MESSAGE_CALLBACK_CONTEXT
1364 {
1365     WS_PROXY_MESSAGE_CALLBACK callback;
1366     void *state;
1367 };
1368
1369 HRESULT WINAPI WsAbortServiceProxy(WS_SERVICE_PROXY*, WS_ERROR*);
1370 HRESULT WINAPI WsAddCustomHeader(WS_MESSAGE*, const WS_ELEMENT_DESCRIPTION*, WS_WRITE_OPTION,
1371                                  const void*, ULONG, ULONG, WS_ERROR*);
1372 HRESULT WINAPI WsAddMappedHeader(WS_MESSAGE*, const WS_XML_STRING*, WS_TYPE, WS_WRITE_OPTION,
1373                                  const void*, ULONG, WS_ERROR*);
1374 HRESULT WINAPI WsAddressMessage(WS_MESSAGE*, const WS_ENDPOINT_ADDRESS*, WS_ERROR*);
1375 HRESULT WINAPI WsAlloc(WS_HEAP*, SIZE_T, void**, WS_ERROR*);
1376 HRESULT WINAPI WsCall(WS_SERVICE_PROXY*, const WS_OPERATION_DESCRIPTION*, const void**,
1377                       WS_HEAP*, const WS_CALL_PROPERTY*, const ULONG, const WS_ASYNC_CONTEXT*,
1378                       WS_ERROR*);
1379 HRESULT WINAPI WsCloseChannel(WS_CHANNEL*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1380 HRESULT WINAPI WsCloseServiceProxy(WS_SERVICE_PROXY*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1381 HRESULT WINAPI WsCombineUrl(const WS_STRING*, const WS_STRING*, ULONG, WS_HEAP*, WS_STRING*, WS_ERROR*);
1382 HRESULT WINAPI WsCopyNode(WS_XML_WRITER*, WS_XML_READER*, WS_ERROR*);
1383 HRESULT WINAPI WsCreateChannel(WS_CHANNEL_TYPE, WS_CHANNEL_BINDING, const WS_CHANNEL_PROPERTY*,
1384                                ULONG, const WS_SECURITY_DESCRIPTION*, WS_CHANNEL**, WS_ERROR*);
1385 HRESULT WINAPI WsCreateError(const WS_ERROR_PROPERTY*, ULONG, WS_ERROR**);
1386 HRESULT WINAPI WsCreateHeap(SIZE_T, SIZE_T, const WS_HEAP_PROPERTY*, ULONG, WS_HEAP**, WS_ERROR*);
1387 HRESULT WINAPI WsCreateMessage(WS_ENVELOPE_VERSION, WS_ADDRESSING_VERSION, const WS_MESSAGE_PROPERTY*,
1388                                ULONG, WS_MESSAGE**, WS_ERROR*);
1389 HRESULT WINAPI WsCreateMessageForChannel(WS_CHANNEL*, const WS_MESSAGE_PROPERTY*, ULONG, WS_MESSAGE**,
1390                                          WS_ERROR*);
1391 HRESULT WINAPI WsCreateReader(const WS_XML_READER_PROPERTY*, ULONG, WS_XML_READER**, WS_ERROR*);
1392 HRESULT WINAPI WsCreateServiceProxy(const WS_CHANNEL_TYPE, const WS_CHANNEL_BINDING,
1393                                     const WS_SECURITY_DESCRIPTION*, const WS_PROXY_PROPERTY*,
1394                                     const ULONG, const WS_CHANNEL_PROPERTY*, const ULONG,
1395                                     WS_SERVICE_PROXY**, WS_ERROR*);
1396 HRESULT WINAPI WsCreateServiceProxyFromTemplate(WS_CHANNEL_TYPE, const WS_PROXY_PROPERTY*,
1397                                                 const ULONG, WS_BINDING_TEMPLATE_TYPE,
1398                                                 void*, ULONG, const void*, ULONG,
1399                                                 WS_SERVICE_PROXY**, WS_ERROR*);
1400 HRESULT WINAPI WsCreateWriter(const WS_XML_WRITER_PROPERTY*, ULONG, WS_XML_WRITER**, WS_ERROR*);
1401 HRESULT WINAPI WsCreateXmlBuffer(WS_HEAP*, const WS_XML_BUFFER_PROPERTY*, ULONG, WS_XML_BUFFER**,
1402                                  WS_ERROR*);
1403 HRESULT WINAPI WsDateTimeToFileTime(const WS_DATETIME*, FILETIME*, WS_ERROR*);
1404 HRESULT WINAPI WsDecodeUrl(const WS_STRING*, ULONG, WS_HEAP*, WS_URL**, WS_ERROR*);
1405 HRESULT WINAPI WsEncodeUrl(const WS_URL*, ULONG, WS_HEAP*, WS_STRING*, WS_ERROR*);
1406 HRESULT WINAPI WsFileTimeToDateTime(const FILETIME*, WS_DATETIME*, WS_ERROR*);
1407 HRESULT WINAPI WsFillReader(WS_XML_READER*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1408 HRESULT WINAPI WsFindAttribute(WS_XML_READER*, const WS_XML_STRING*, const WS_XML_STRING*, BOOL,
1409                                ULONG*, WS_ERROR*);
1410 void WINAPI WsFreeChannel(WS_CHANNEL*);
1411 void WINAPI WsFreeError(WS_ERROR*);
1412 void WINAPI WsFreeHeap(WS_HEAP*);
1413 void WINAPI WsFreeMessage(WS_MESSAGE*);
1414 void WINAPI WsFreeReader(WS_XML_READER*);
1415 void WINAPI WsFreeServiceProxy(WS_SERVICE_PROXY*);
1416 void WINAPI WsFreeWriter(WS_XML_WRITER*);
1417 HRESULT WINAPI WsGetChannelProperty(WS_CHANNEL*, WS_CHANNEL_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1418 HRESULT WINAPI WsGetErrorProperty(WS_ERROR*, WS_ERROR_PROPERTY_ID, void*, ULONG);
1419 HRESULT WINAPI WsGetErrorString(WS_ERROR*, ULONG, WS_STRING*);
1420 HRESULT WINAPI WsGetHeapProperty(WS_HEAP*, WS_HEAP_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1421 HRESULT WINAPI WsGetMessageProperty(WS_MESSAGE*, WS_MESSAGE_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1422 HRESULT WINAPI WsGetNamespaceFromPrefix(WS_XML_READER*, const WS_XML_STRING*, BOOL,
1423                                         const WS_XML_STRING**, WS_ERROR*);
1424 HRESULT WINAPI WsGetPrefixFromNamespace(WS_XML_WRITER*, const WS_XML_STRING*, BOOL,
1425                                         const WS_XML_STRING**, WS_ERROR*);
1426 HRESULT WINAPI WsGetReaderNode(WS_XML_READER*, const WS_XML_NODE**, WS_ERROR*);
1427 HRESULT WINAPI WsGetReaderPosition(WS_XML_READER*, WS_XML_NODE_POSITION*, WS_ERROR*);
1428 HRESULT WINAPI WsGetReaderProperty(WS_XML_READER*, WS_XML_READER_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1429 HRESULT WINAPI WsGetServiceProxyProperty(WS_SERVICE_PROXY*, const WS_PROXY_PROPERTY_ID, void*,
1430                                          ULONG, WS_ERROR*);
1431 HRESULT WINAPI WsGetWriterPosition(WS_XML_WRITER*, WS_XML_NODE_POSITION*, WS_ERROR*);
1432 HRESULT WINAPI WsGetWriterProperty(WS_XML_WRITER*, WS_XML_WRITER_PROPERTY_ID, void*, ULONG, WS_ERROR*);
1433 HRESULT WINAPI WsGetXmlAttribute(WS_XML_READER*, const WS_XML_STRING*, WS_HEAP*, WCHAR**,
1434                                  ULONG*, WS_ERROR*);
1435 HRESULT WINAPI WsInitializeMessage(WS_MESSAGE*, WS_MESSAGE_INITIALIZATION, WS_MESSAGE*, WS_ERROR*);
1436 HRESULT WINAPI WsMoveReader(WS_XML_READER*, WS_MOVE_TO, BOOL*, WS_ERROR*);
1437 HRESULT WINAPI WsMoveWriter(WS_XML_WRITER*, WS_MOVE_TO, BOOL*, WS_ERROR*);
1438 HRESULT WINAPI WsOpenChannel(WS_CHANNEL*, const WS_ENDPOINT_ADDRESS*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1439 HRESULT WINAPI WsOpenServiceProxy(WS_SERVICE_PROXY*, const WS_ENDPOINT_ADDRESS*, const WS_ASYNC_CONTEXT*,
1440                                   WS_ERROR*);
1441 HRESULT WINAPI WsReadAttribute(WS_XML_READER*, const WS_ATTRIBUTE_DESCRIPTION*, WS_READ_OPTION,
1442                                WS_HEAP*, void*, ULONG, WS_ERROR*);
1443 HRESULT WINAPI WsReadBody(WS_MESSAGE*, const WS_ELEMENT_DESCRIPTION*, WS_READ_OPTION, WS_HEAP*, void*,
1444                           ULONG, WS_ERROR*);
1445 HRESULT WINAPI WsReadElement(WS_XML_READER*, const WS_ELEMENT_DESCRIPTION*, WS_READ_OPTION,
1446                              WS_HEAP*, void*, ULONG, WS_ERROR*);
1447 HRESULT WINAPI WsReadEndAttribute(WS_XML_READER*, WS_ERROR*);
1448 HRESULT WINAPI WsReadEndElement(WS_XML_READER*, WS_ERROR*);
1449 HRESULT WINAPI WsReadEnvelopeEnd(WS_MESSAGE*, WS_ERROR*);
1450 HRESULT WINAPI WsReadEnvelopeStart(WS_MESSAGE*, WS_XML_READER*, WS_MESSAGE_DONE_CALLBACK, void*,
1451                                    WS_ERROR*);
1452 HRESULT WINAPI WsReadNode(WS_XML_READER*, WS_ERROR*);
1453 HRESULT WINAPI WsReadStartAttribute(WS_XML_READER*, ULONG, WS_ERROR*);
1454 HRESULT WINAPI WsReadStartElement(WS_XML_READER*, WS_ERROR*);
1455 HRESULT WINAPI WsReadToStartElement(WS_XML_READER*, const WS_XML_STRING*, const WS_XML_STRING*,
1456                                     BOOL*, WS_ERROR*);
1457 HRESULT WINAPI WsReadType(WS_XML_READER*, WS_TYPE_MAPPING, WS_TYPE, const void*, WS_READ_OPTION,
1458                           WS_HEAP*, void*, ULONG, WS_ERROR*);
1459 HRESULT WINAPI WsReadValue(WS_XML_READER*, WS_VALUE_TYPE, void*, ULONG, WS_ERROR*);
1460 HRESULT WINAPI WsReceiveMessage(WS_CHANNEL*, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION**, ULONG,
1461                                 WS_RECEIVE_OPTION, WS_READ_OPTION, WS_HEAP*, void*, ULONG, ULONG*,
1462                                 const WS_ASYNC_CONTEXT*, WS_ERROR*);
1463 HRESULT WINAPI WsRemoveCustomHeader(WS_MESSAGE*, const WS_XML_STRING*, const WS_XML_STRING*,
1464                                     WS_ERROR*);
1465 HRESULT WINAPI WsRemoveHeader(WS_MESSAGE*, WS_HEADER_TYPE, WS_ERROR*);
1466 HRESULT WINAPI WsRemoveMappedHeader(WS_MESSAGE*, const WS_XML_STRING*, WS_ERROR*);
1467 HRESULT WINAPI WsRemoveNode(const WS_XML_NODE_POSITION*, WS_ERROR*);
1468 HRESULT WINAPI WsResetChannel(WS_CHANNEL*, WS_ERROR*);
1469 HRESULT WINAPI WsResetError(WS_ERROR*);
1470 HRESULT WINAPI WsResetHeap(WS_HEAP*, WS_ERROR*);
1471 HRESULT WINAPI WsResetMessage(WS_MESSAGE*, WS_ERROR*);
1472 HRESULT WINAPI WsRequestReply(WS_CHANNEL*, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION*, WS_WRITE_OPTION,
1473                               const void*, ULONG, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION*,
1474                               WS_READ_OPTION, WS_HEAP*, void*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1475 HRESULT WINAPI WsSendMessage(WS_CHANNEL*, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION*, WS_WRITE_OPTION,
1476                              const void*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1477 HRESULT WINAPI WsSendReplyMessage(WS_CHANNEL*, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION*,
1478                                   WS_WRITE_OPTION, const void*, ULONG, WS_MESSAGE*,
1479                                   const WS_ASYNC_CONTEXT*, WS_ERROR*);
1480 HRESULT WINAPI WsSetChannelProperty(WS_CHANNEL*, WS_CHANNEL_PROPERTY_ID, const void*, ULONG, WS_ERROR*);
1481 HRESULT WINAPI WsSetErrorProperty(WS_ERROR*, WS_ERROR_PROPERTY_ID, const void*, ULONG);
1482 HRESULT WINAPI WsSetHeader(WS_MESSAGE*, WS_HEADER_TYPE, WS_TYPE, WS_WRITE_OPTION, const void*, ULONG,
1483                            WS_ERROR*);
1484 HRESULT WINAPI WsSetInput(WS_XML_READER*, const WS_XML_READER_ENCODING*, const WS_XML_READER_INPUT*,
1485                           const WS_XML_READER_PROPERTY*, ULONG, WS_ERROR*);
1486 HRESULT WINAPI WsSetInputToBuffer(WS_XML_READER*, WS_XML_BUFFER*, const WS_XML_READER_PROPERTY*,
1487                                   ULONG, WS_ERROR*);
1488 HRESULT WINAPI WsSetMessageProperty(WS_MESSAGE*, WS_MESSAGE_PROPERTY_ID, const void*, ULONG, WS_ERROR*);
1489 HRESULT WINAPI WsSetOutput(WS_XML_WRITER*, const WS_XML_WRITER_ENCODING*, const WS_XML_WRITER_OUTPUT*,
1490                            const WS_XML_WRITER_PROPERTY*, ULONG, WS_ERROR*);
1491 HRESULT WINAPI WsSetOutputToBuffer(WS_XML_WRITER*, WS_XML_BUFFER*, const WS_XML_WRITER_PROPERTY*,
1492                                    ULONG, WS_ERROR*);
1493 HRESULT WINAPI WsSetReaderPosition(WS_XML_READER*, const WS_XML_NODE_POSITION*, WS_ERROR*);
1494 HRESULT WINAPI WsSetWriterPosition(WS_XML_WRITER*, const WS_XML_NODE_POSITION*, WS_ERROR*);
1495 HRESULT WINAPI WsSkipNode(WS_XML_READER*, WS_ERROR*);
1496 HRESULT WINAPI WsWriteArray(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*, WS_VALUE_TYPE,
1497                             const void*, ULONG, ULONG, ULONG, WS_ERROR*);
1498 HRESULT WINAPI WsWriteAttribute(WS_XML_WRITER*, const WS_ATTRIBUTE_DESCRIPTION*, WS_WRITE_OPTION,
1499                                 const void*, ULONG, WS_ERROR*);
1500 HRESULT WINAPI WsWriteBody(WS_MESSAGE*, const WS_ELEMENT_DESCRIPTION*, WS_WRITE_OPTION, const void*,
1501                            ULONG, WS_ERROR*);
1502 HRESULT WINAPI WsWriteElement(WS_XML_WRITER*, const WS_ELEMENT_DESCRIPTION*, WS_WRITE_OPTION,
1503                               const void*, ULONG, WS_ERROR*);
1504 HRESULT WINAPI WsWriteEndAttribute(WS_XML_WRITER*, WS_ERROR*);
1505 HRESULT WINAPI WsWriteEndCData(WS_XML_WRITER*, WS_ERROR*);
1506 HRESULT WINAPI WsWriteEndElement(WS_XML_WRITER*, WS_ERROR*);
1507 HRESULT WINAPI WsWriteEndStartElement(WS_XML_WRITER*, WS_ERROR*);
1508 HRESULT WINAPI WsWriteEnvelopeEnd(WS_MESSAGE*, WS_ERROR*);
1509 HRESULT WINAPI WsWriteEnvelopeStart(WS_MESSAGE*, WS_XML_WRITER*, WS_MESSAGE_DONE_CALLBACK, void*, WS_ERROR*);
1510 HRESULT WINAPI WsWriteMessageStart(WS_CHANNEL*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1511 HRESULT WINAPI WsWriteMessageEnd(WS_CHANNEL*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
1512 HRESULT WINAPI WsWriteNode(WS_XML_WRITER*, const WS_XML_NODE*, WS_ERROR*);
1513 HRESULT WINAPI WsWriteStartAttribute(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*,
1514                                      const WS_XML_STRING*, BOOL, WS_ERROR*);
1515 HRESULT WINAPI WsWriteStartCData(WS_XML_WRITER*, WS_ERROR*);
1516 HRESULT WINAPI WsWriteStartElement(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*,
1517                                    const WS_XML_STRING*, WS_ERROR*);
1518 HRESULT WINAPI WsWriteText(WS_XML_WRITER*, const WS_XML_TEXT*, WS_ERROR*);
1519 HRESULT WINAPI WsWriteType(WS_XML_WRITER*, WS_TYPE_MAPPING, WS_TYPE, const void*, WS_WRITE_OPTION,
1520                            const void*, ULONG, WS_ERROR*);
1521 HRESULT WINAPI WsWriteValue(WS_XML_WRITER*, WS_VALUE_TYPE, const void*, ULONG, WS_ERROR*);
1522 HRESULT WINAPI WsWriteXmlBuffer(WS_XML_WRITER*, WS_XML_BUFFER*, WS_ERROR*);
1523 HRESULT WINAPI WsWriteXmlBufferToBytes(WS_XML_WRITER*, WS_XML_BUFFER*, const WS_XML_WRITER_ENCODING*,
1524                                        const WS_XML_WRITER_PROPERTY*, ULONG, WS_HEAP*, void**,
1525                                        ULONG*, WS_ERROR*);
1526 HRESULT WINAPI WsWriteXmlnsAttribute(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*,
1527                                      BOOL, WS_ERROR*);
1528 HRESULT WINAPI WsXmlStringEquals(const WS_XML_STRING*, const WS_XML_STRING*, WS_ERROR*);
1529
1530 #define WS_S_ASYNC                          0x003d0000
1531 #define WS_S_END                            0x003d0001
1532 #define WS_E_INVALID_FORMAT                 0x803d0000
1533 #define WS_E_OBJECT_FAULTED                 0x803d0001
1534 #define WS_E_NUMERIC_OVERFLOW               0x803d0002
1535 #define WS_E_INVALID_OPERATION              0x803d0003
1536 #define WS_E_OPERATION_ABORTED              0x803d0004
1537 #define WS_E_ENDPOINT_ACCESS_DENIED         0x803d0005
1538 #define WS_E_OPERATION_TIMED_OUT            0x803d0006
1539 #define WS_E_OPERATION_ABANDONED            0x803d0007
1540 #define WS_E_QUOTA_EXCEEDED                 0x803d0008
1541 #define WS_E_NO_TRANSLATION_AVAILABLE       0x803d0009
1542 #define WS_E_SECURITY_VERIFICATION_FAILURE  0x803d000a
1543 #define WS_E_ADDRESS_IN_USE                 0x803d000b
1544 #define WS_E_ADDRESS_NOT_AVAILABLE          0x803d000c
1545 #define WS_E_ENDPOINT_NOT_FOUND             0x803d000d
1546 #define WS_E_ENDPOINT_NOT_AVAILABLE         0x803d000e
1547 #define WS_E_ENDPOINT_FAILURE               0x803d000f
1548 #define WS_E_ENDPOINT_UNREACHABLE           0x803d0010
1549 #define WS_E_ENDPOINT_ACTION_NOT_SUPPORTED  0x803d0011
1550 #define WS_E_ENDPOINT_TOO_BUSY              0x803d0012
1551 #define WS_E_ENDPOINT_FAULT_RECEIVED        0x803d0013
1552 #define WS_E_ENDPOINT_DISCONNECTED          0x803d0014
1553 #define WS_E_PROXY_FAILURE                  0x803d0015
1554 #define WS_E_PROXY_ACCESS_DENIED            0x803d0016
1555 #define WS_E_NOT_SUPPORTED                  0x803d0017
1556 #define WS_E_PROXY_REQUIRES_BASIC_AUTH      0x803d0018
1557 #define WS_E_PROXY_REQUIRES_DIGEST_AUTH     0x803d0019
1558 #define WS_E_PROXY_REQUIRES_NTLM_AUTH       0x803d001a
1559 #define WS_E_PROXY_REQUIRES_NEGOTIATE_AUTH  0x803d001b
1560 #define WS_E_SERVER_REQUIRES_BASIC_AUTH     0x803d001c
1561 #define WS_E_SERVER_REQUIRES_DIGEST_AUTH    0x803d001d
1562 #define WS_E_SERVER_REQUIRES_NTLM_AUTH      0x803d001e
1563 #define WS_E_SERVER_REQUIRES_NEGOTIATE_AUTH 0x803d001f
1564 #define WS_E_INVALID_ENDPOINT_URL           0x803d0020
1565 #define WS_E_OTHER                          0x803d0021
1566 #define WS_E_SECURITY_TOKEN_EXPIRED         0x803d0022
1567 #define WS_E_SECURITY_SYSTEM_FAILURE        0x803d0023
1568
1569 #ifdef __cplusplus
1570 }
1571 #endif  /* __cplusplus */
1572
1573 #endif /* __WINE_WEBSERVICES_H */