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