/*
 * Copyright 2015 Nikolay Sivov for CodeWeavers
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#ifndef __WINE_WEBSERVICES_H
#define __WINE_WEBSERVICES_H

#ifdef __cplusplus
extern "C" {
#endif  /* __cplusplus */

typedef struct _WS_ERROR WS_ERROR;
typedef struct _WS_HEAP WS_HEAP;
typedef struct _WS_XML_BUFFER WS_XML_BUFFER;
typedef struct _WS_XML_READER WS_XML_READER;
typedef struct _WS_XML_WRITER WS_XML_WRITER;
typedef struct _WS_PROXY_PROPERTY WS_PROXY_PROPERTY;
typedef struct _WS_SECURITY_DESCRIPTION WS_SECURITY_DESCRIPTION;
typedef struct _WS_CHANNEL_PROPERTY WS_CHANNEL_PROPERTY;
typedef struct _WS_SERVICE_PROXY WS_SERVICE_PROXY;
typedef struct _WS_SECURITY_BINDING_PROPERTY WS_SECURITY_BINDING_PROPERTY;
typedef struct _WS_SECURITY_PROPERTY WS_SECURITY_PROPERTY;
typedef struct _WS_SECURITY_PROPERTIES WS_SECURITY_PROPERTIES;
typedef struct _WS_SECURITY_BINDING WS_SECURITY_BINDING;
typedef struct _WS_CHANNEL WS_CHANNEL;
typedef struct _WS_MESSAGE_PROPERTY WS_MESSAGE_PROPERTY;
typedef struct _WS_MESSAGE_PROPERTIES WS_MESSAGE_PROPERTIES;
typedef struct _WS_HTTP_BINDING_TEMPLATE WS_HTTP_BINDING_TEMPLATE;
typedef struct _WS_HTTP_SSL_BINDING_TEMPLATE WS_HTTP_SSL_BINDING_TEMPLATE;
typedef struct _WS_CHANNEL_PROPERTIES WS_CHANNEL_PROPERTIES;
typedef struct _WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE;
typedef struct _WS_SECURITY_BINDING_PROPERTIES WS_SECURITY_BINDING_PROPERTIES;
typedef struct _WS_CERT_CREDENTIAL WS_CERT_CREDENTIAL;
typedef struct _WS_ENDPOINT_ADDRESS WS_ENDPOINT_ADDRESS;
typedef struct _WS_ENDPOINT_IDENTITY WS_ENDPOINT_IDENTITY;
typedef struct _WS_ENUM_DESCRIPTION WS_ENUM_DESCRIPTION;
typedef struct _WS_ENUM_VALUE WS_ENUM_VALUE;
typedef struct _WS_HTTP_POLICY_DESCRIPTION WS_HTTP_POLICY_DESCRIPTION;
typedef struct _WS_MESSAGE WS_MESSAGE;
typedef struct _WS_MESSAGE_DESCRIPTION WS_MESSAGE_DESCRIPTION;
typedef struct _WS_OPERATION_DESCRIPTION WS_OPERATION_DESCRIPTION;
typedef struct _WS_PARAMETER_DESCRIPTION WS_PARAMETER_DESCRIPTION;
typedef struct _WS_OPERATION_CONTEXT WS_OPERATION_CONTEXT;
typedef struct _WS_CALL_PROPERTY WS_CALL_PROPERTY;
typedef struct _WS_DOUBLE_DESCRIPTION WS_DOUBLE_DESCRIPTION;
typedef struct _WS_DATETIME WS_DATETIME;
typedef struct _WS_DATETIME_DESCRIPTION WS_DATETIME_DESCRIPTION;

struct _WS_STRUCT_DESCRIPTION;
struct _WS_XML_STRING;

typedef enum {
    WS_ERROR_PROPERTY_STRING_COUNT,
    WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE,
    WS_ERROR_PROPERTY_LANGID
} WS_ERROR_PROPERTY_ID;

typedef struct _WS_ERROR_PROPERTY {
    WS_ERROR_PROPERTY_ID id;
    void                *value;
    ULONG                valueSize;
} WS_ERROR_PROPERTY;

typedef enum {
    WS_HEAP_PROPERTY_MAX_SIZE,
    WS_HEAP_PROPERTY_TRIM_SIZE,
    WS_HEAP_PROPERTY_REQUESTED_SIZE,
    WS_HEAP_PROPERTY_ACTUAL_SIZE
} WS_HEAP_PROPERTY_ID;

typedef struct _WS_HEAP_PROPERTY {
    WS_HEAP_PROPERTY_ID id;
    void               *value;
    ULONG               valueSize;
} WS_HEAP_PROPERTY;

typedef ULONG WS_XML_BUFFER_PROPERTY_ID;

typedef struct _WS_XML_BUFFER_PROPERTY {
    WS_XML_BUFFER_PROPERTY_ID id;
    void                     *value;
    ULONG                     valueSize;
} WS_XML_BUFFER_PROPERTY;

typedef enum {
    WS_XML_READER_PROPERTY_MAX_DEPTH,
    WS_XML_READER_PROPERTY_ALLOW_FRAGMENT,
    WS_XML_READER_PROPERTY_MAX_ATTRIBUTES,
    WS_XML_READER_PROPERTY_READ_DECLARATION,
    WS_XML_READER_PROPERTY_CHARSET,
    WS_XML_READER_PROPERTY_ROW,
    WS_XML_READER_PROPERTY_COLUMN,
    WS_XML_READER_PROPERTY_UTF8_TRIM_SIZE,
    WS_XML_READER_PROPERTY_STREAM_BUFFER_SIZE,
    WS_XML_READER_PROPERTY_IN_ATTRIBUTE,
    WS_XML_READER_PROPERTY_STREAM_MAX_ROOT_MIME_PART_SIZE,
    WS_XML_READER_PROPERTY_STREAM_MAX_MIME_HEADERS_SIZE,
    WS_XML_READER_PROPERTY_MAX_MIME_PARTS,
    WS_XML_READER_PROPERTY_ALLOW_INVALID_CHARACTER_REFERENCES,
    WS_XML_READER_PROPERTY_MAX_NAMESPACES
} WS_XML_READER_PROPERTY_ID;

typedef struct _WS_XML_READER_PROPERTY {
    WS_XML_READER_PROPERTY_ID id;
    void                     *value;
    ULONG                     valueSize;
} WS_XML_READER_PROPERTY;

typedef enum {
    WS_XML_WRITER_PROPERTY_MAX_DEPTH,
    WS_XML_WRITER_PROPERTY_ALLOW_FRAGMENT,
    WS_XML_WRITER_PROPERTY_MAX_ATTRIBUTES,
    WS_XML_WRITER_PROPERTY_WRITE_DECLARATION,
    WS_XML_WRITER_PROPERTY_INDENT,
    WS_XML_WRITER_PROPERTY_BUFFER_TRIM_SIZE,
    WS_XML_WRITER_PROPERTY_CHARSET,
    WS_XML_WRITER_PROPERTY_BUFFERS,
    WS_XML_WRITER_PROPERTY_BUFFER_MAX_SIZE,
    WS_XML_WRITER_PROPERTY_BYTES,
    WS_XML_WRITER_PROPERTY_IN_ATTRIBUTE,
    WS_XML_WRITER_PROPERTY_MAX_MIME_PARTS_BUFFER_SIZE,
    WS_XML_WRITER_PROPERTY_INITIAL_BUFFER,
    WS_XML_WRITER_PROPERTY_ALLOW_INVALID_CHARACTER_REFERENCES,
    WS_XML_WRITER_PROPERTY_MAX_NAMESPACES,
    WS_XML_WRITER_PROPERTY_BYTES_WRITTEN,
    WS_XML_WRITER_PROPERTY_BYTES_TO_CLOSE,
    WS_XML_WRITER_PROPERTY_COMPRESS_EMPTY_ELEMENTS,
    WS_XML_WRITER_PROPERTY_EMIT_UNCOMPRESSED_EMPTY_ELEMENTS
} WS_XML_WRITER_PROPERTY_ID;

typedef struct _WS_XML_WRITER_PROPERTY {
    WS_XML_WRITER_PROPERTY_ID id;
    void                     *value;
    ULONG                     valueSize;
} WS_XML_WRITER_PROPERTY;

typedef struct _WS_BYTES {
    ULONG length;
    BYTE *bytes;
} WS_BYTES;

typedef struct _WS_BUFFERS {
    ULONG bufferCount;
    WS_BYTES *buffers;
} WS_BUFFERS;

typedef enum {
    WS_XML_READER_ENCODING_TYPE_TEXT   = 1,
    WS_XML_READER_ENCODING_TYPE_BINARY = 2,
    WS_XML_READER_ENCODING_TYPE_MTOM   = 3,
    WS_XML_READER_ENCODING_TYPE_RAW    = 4
} WS_XML_READER_ENCODING_TYPE;

typedef struct _WS_XML_READER_ENCODING {
    WS_XML_READER_ENCODING_TYPE encodingType;
} WS_XML_READER_ENCODING;

typedef enum {
    WS_XML_WRITER_ENCODING_TYPE_TEXT   = 1,
    WS_XML_WRITER_ENCODING_TYPE_BINARY = 2,
    WS_XML_WRITER_ENCODING_TYPE_MTOM   = 3,
    WS_XML_WRITER_ENCODING_TYPE_RAW    = 4
} WS_XML_WRITER_ENCODING_TYPE;

typedef struct _WS_XML_WRITER_ENCODING {
    WS_XML_WRITER_ENCODING_TYPE encodingType;
} WS_XML_WRITER_ENCODING;

typedef enum {
    WS_CHARSET_AUTO,
    WS_CHARSET_UTF8,
    WS_CHARSET_UTF16LE,
    WS_CHARSET_UTF16BE
} WS_CHARSET;

typedef struct _WS_XML_READER_TEXT_ENCODING {
    WS_XML_READER_ENCODING encoding;
    WS_CHARSET charSet;
} WS_XML_READER_TEXT_ENCODING;

typedef struct _WS_XML_WRITER_TEXT_ENCODING {
    WS_XML_WRITER_ENCODING encoding;
    WS_CHARSET charSet;
} WS_XML_WRITER_TEXT_ENCODING;

typedef enum {
    WS_XML_READER_INPUT_TYPE_BUFFER = 1,
    WS_XML_READER_INPUT_TYPE_STREAM = 2
} WS_XML_READER_INPUT_TYPE;

typedef enum {
    WS_XML_WRITER_OUTPUT_TYPE_BUFFER = 1,
    WS_XML_WRITER_OUTPUT_TYPE_STREAM = 2
} WS_XML_WRITER_OUTPUT_TYPE;

typedef struct _WS_XML_READER_INPUT {
    WS_XML_READER_INPUT_TYPE inputType;
} WS_XML_READER_INPUT;

typedef struct _WS_XML_WRITER_OUTPUT {
    WS_XML_WRITER_OUTPUT_TYPE outputType;
} WS_XML_WRITER_OUTPUT;

typedef struct _WS_XML_READER_BUFFER_INPUT {
    WS_XML_READER_INPUT input;
    void *encodedData;
    ULONG encodedDataSize;
} WS_XML_READER_BUFFER_INPUT;

typedef struct _WS_XML_WRITER_BUFFER_OUTPUT {
    WS_XML_WRITER_OUTPUT output;
} WS_XML_WRITER_BUFFER_OUTPUT;

typedef enum {
    WS_SHORT_CALLBACK,
    WS_LONG_CALLBACK
} WS_CALLBACK_MODEL;

typedef void (CALLBACK *WS_ASYNC_CALLBACK)
    (HRESULT, WS_CALLBACK_MODEL, void *);

typedef struct _WS_ASYNC_CONTEXT {
    WS_ASYNC_CALLBACK callback;
    void             *callbackState;
} WS_ASYNC_CONTEXT;

typedef HRESULT (CALLBACK *WS_READ_CALLBACK)
    (void*, void*, ULONG, ULONG*, const WS_ASYNC_CONTEXT*, WS_ERROR*);

typedef struct _WS_XML_READER_STREAM_INPUT {
    WS_XML_READER_INPUT input;
    WS_READ_CALLBACK readCallback;
    void *readCallbackState;
} WS_XML_READER_STREAM_INPUT;

typedef struct _WS_XML_DICTIONARY {
    GUID                   guid;
    struct _WS_XML_STRING *strings;
    ULONG                  stringCount;
    BOOL                   isConst;
} WS_XML_DICTIONARY;

typedef struct _WS_XML_STRING {
    ULONG              length;
    BYTE              *bytes;
    WS_XML_DICTIONARY *dictionary;
    ULONG              id;
} WS_XML_STRING;

typedef enum {
    WS_ELEMENT_TYPE_MAPPING         = 1,
    WS_ATTRIBUTE_TYPE_MAPPING       = 2,
    WS_ELEMENT_CONTENT_TYPE_MAPPING = 3,
    WS_ANY_ELEMENT_TYPE_MAPPING     = 4
} WS_TYPE_MAPPING;

typedef enum {
    WS_BOOL_TYPE,
    WS_INT8_TYPE,
    WS_INT16_TYPE,
    WS_INT32_TYPE,
    WS_INT64_TYPE,
    WS_UINT8_TYPE,
    WS_UINT16_TYPE,
    WS_UINT32_TYPE,
    WS_UINT64_TYPE,
    WS_FLOAT_TYPE,
    WS_DOUBLE_TYPE,
    WS_DECIMAL_TYPE,
    WS_DATETIME_TYPE,
    WS_TIMESPAN_TYPE,
    WS_GUID_TYPE,
    WS_UNIQUE_ID_TYPE,
    WS_STRING_TYPE,
    WS_WSZ_TYPE,
    WS_BYTES_TYPE,
    WS_XML_STRING_TYPE,
    WS_XML_QNAME_TYPE,
    WS_XML_BUFFER_TYPE,
    WS_CHAR_ARRAY_TYPE,
    WS_UTF8_ARRAY_TYPE,
    WS_BYTE_ARRAY_TYPE,
    WS_DESCRIPTION_TYPE,
    WS_STRUCT_TYPE,
    WS_CUSTOM_TYPE,
    WS_ENDPOINT_ADDRESS_TYPE,
    WS_FAULT_TYPE,
    WS_VOID_TYPE,
    WS_ENUM_TYPE,
    WS_DURATION_TYPE,
    WS_UNION_TYPE,
    WS_ANY_ATTRIBUTES_TYPE
} WS_TYPE;

typedef enum {
    WS_READ_REQUIRED_VALUE   = 1,
    WS_READ_REQUIRED_POINTER = 2,
    WS_READ_OPTIONAL_POINTER = 3,
    WS_READ_NILLABLE_POINTER = 4,
    WS_READ_NILLABLE_VALUE   = 5
} WS_READ_OPTION;

typedef enum {
    WS_WRITE_REQUIRED_VALUE   = 1,
    WS_WRITE_REQUIRED_POINTER = 2,
    WS_WRITE_NILLABLE_VALUE   = 3,
    WS_WRITE_NILLABLE_POINTER = 4
} WS_WRITE_OPTION;

typedef struct _WS_BOOL_DESCRIPTION {
    BOOL value;
} WS_BOOL_DESCRIPTION;

typedef struct _WS_INT8_DESCRIPTION {
    char minValue;
    char maxValue;
} WS_INT8_DESCRIPTION;

typedef struct _WS_INT16_DESCRIPTION {
    short minValue;
    short maxValue;
} WS_INT16_DESCRIPTION;

typedef struct _WS_INT32_DESCRIPTION {
    int minValue;
    int maxValue;
} WS_INT32_DESCRIPTION;

typedef struct _WS_INT64_DESCRIPTION {
    __int64 minValue;
    __int64 maxValue;
} WS_INT64_DESCRIPTION;

typedef struct _WS_UINT8_DESCRIPTION {
    BYTE minValue;
    BYTE maxValue;
} WS_UINT8_DESCRIPTION;

typedef struct _WS_UINT16_DESCRIPTION {
    USHORT minValue;
    USHORT maxValue;
} WS_UINT16_DESCRIPTION;

typedef struct _WS_UINT32_DESCRIPTION {
    ULONG minValue;
    ULONG maxValue;
} WS_UINT32_DESCRIPTION;

typedef struct _WS_UINT64_DESCRIPTION {
    unsigned __int64 minValue;
    unsigned __int64 maxValue;
} WS_UINT64_DESCRIPTION;

typedef struct _WS_WSZ_DESCRIPTION {
    ULONG minCharCount;
    ULONG maxCharCount;
} WS_WSZ_DESCRIPTION;

struct _WS_ENUM_VALUE {
    int value;
    WS_XML_STRING *name;
};

struct _WS_ENUM_DESCRIPTION {
    WS_ENUM_VALUE *values;
    ULONG valueCount;
    ULONG maxByteCount;
    ULONG *nameIndices;
};

struct _WS_DOUBLE_DESCRIPTION {
    double minValue;
    double maxValue;
};

typedef enum {
    WS_TYPE_ATTRIBUTE_FIELD_MAPPING,
    WS_ATTRIBUTE_FIELD_MAPPING,
    WS_ELEMENT_FIELD_MAPPING,
    WS_REPEATING_ELEMENT_FIELD_MAPPING,
    WS_TEXT_FIELD_MAPPING,
    WS_NO_FIELD_MAPPING,
    WS_XML_ATTRIBUTE_FIELD_MAPPING,
    WS_ELEMENT_CHOICE_FIELD_MAPPING,
    WS_REPEATING_ELEMENT_CHOICE_FIELD_MAPPING,
    WS_ANY_ELEMENT_FIELD_MAPPING,
    WS_REPEATING_ANY_ELEMENT_FIELD_MAPPING,
    WS_ANY_CONTENT_FIELD_MAPPING,
    WS_ANY_ATTRIBUTES_FIELD_MAPPING
} WS_FIELD_MAPPING;

typedef struct _WS_DEFAULT_VALUE {
    void *value;
    ULONG valueSize;
} WS_DEFAULT_VALUE;

typedef struct _WS_ITEM_RANGE {
    ULONG minItemCount;
    ULONG maxItemCount;
} WS_ITEM_RANGE;

enum
{
    WS_FIELD_POINTER         = 0x1,
    WS_FIELD_OPTIONAL        = 0x2,
    WS_FIELD_NILLABLE        = 0x4,
    WS_FIELD_NILLABLE_ITEM   = 0x8,
    WS_FIELD_OTHER_NAMESPACE = 0x10
};

typedef struct _WS_FIELD_DESCRIPTION {
    WS_FIELD_MAPPING mapping;
    WS_XML_STRING *localName;
    WS_XML_STRING *ns;
    WS_TYPE type;
    void *typeDescription;
    ULONG offset;
    ULONG options;
    WS_DEFAULT_VALUE *defaultValue;
    ULONG countOffset;
    WS_XML_STRING *itemLocalName;
    WS_XML_STRING *itemNs;
    WS_ITEM_RANGE *itemRange;
} WS_FIELD_DESCRIPTION;

enum
{
    WS_STRUCT_ABSTRACT                        = 0x1,
    WS_STRUCT_IGNORE_TRAILING_ELEMENT_CONTENT = 0x2,
    WS_STRUCT_IGNORE_UNHANDLED_ATTRIBUTES     = 0x4
};

typedef struct _WS_STRUCT_DESCRIPTION {
    ULONG size;
    ULONG alignment;
    WS_FIELD_DESCRIPTION **fields;
    ULONG fieldCount;
    WS_XML_STRING *typeLocalName;
    WS_XML_STRING *typeNs;
    struct _WS_STRUCT_DESCRIPTION *parentType;
    struct _WS_STRUCT_DESCRIPTION **subTypes;
    ULONG subTypeCount;
    ULONG structOptions;
} WS_STRUCT_DESCRIPTION;

typedef struct _WS_ATTRIBUTE_DESCRIPTION {
    WS_XML_STRING *attributeLocalName;
    WS_XML_STRING *attributeNs;
    WS_TYPE type;
    void *typeDescription;
} WS_ATTRIBUTE_DESCRIPTION;

typedef struct _WS_ELEMENT_DESCRIPTION {
    WS_XML_STRING *elementLocalName;
    WS_XML_STRING *elementNs;
    WS_TYPE type;
    void *typeDescription;
} WS_ELEMENT_DESCRIPTION;

typedef struct _WS_STRING {
    ULONG length;
    WCHAR *chars;
} WS_STRING;

typedef enum {
    WS_XML_NODE_TYPE_ELEMENT     = 1,
    WS_XML_NODE_TYPE_TEXT        = 2,
    WS_XML_NODE_TYPE_END_ELEMENT = 3,
    WS_XML_NODE_TYPE_COMMENT     = 4,
    WS_XML_NODE_TYPE_CDATA       = 6,
    WS_XML_NODE_TYPE_END_CDATA   = 7,
    WS_XML_NODE_TYPE_EOF         = 8,
    WS_XML_NODE_TYPE_BOF         = 9
} WS_XML_NODE_TYPE;

typedef struct _WS_XML_NODE {
    WS_XML_NODE_TYPE nodeType;
} WS_XML_NODE;

typedef enum {
    WS_MOVE_TO_ROOT_ELEMENT,
    WS_MOVE_TO_NEXT_ELEMENT,
    WS_MOVE_TO_PREVIOUS_ELEMENT,
    WS_MOVE_TO_CHILD_ELEMENT,
    WS_MOVE_TO_END_ELEMENT,
    WS_MOVE_TO_PARENT_ELEMENT,
    WS_MOVE_TO_NEXT_NODE,
    WS_MOVE_TO_PREVIOUS_NODE,
    WS_MOVE_TO_FIRST_NODE,
    WS_MOVE_TO_BOF,
    WS_MOVE_TO_EOF,
    WS_MOVE_TO_CHILD_NODE
} WS_MOVE_TO;

typedef enum {
    WS_XML_TEXT_TYPE_UTF8      = 1,
    WS_XML_TEXT_TYPE_UTF16     = 2,
    WS_XML_TEXT_TYPE_BASE64    = 3,
    WS_XML_TEXT_TYPE_BOOL      = 4,
    WS_XML_TEXT_TYPE_INT32     = 5,
    WS_XML_TEXT_TYPE_INT64     = 6,
    WS_XML_TEXT_TYPE_UINT64    = 7,
    WS_XML_TEXT_TYPE_FLOAT     = 8,
    WS_XML_TEXT_TYPE_DOUBLE    = 9,
    WS_XML_TEXT_TYPE_DECIMAL   = 10,
    WS_XML_TEXT_TYPE_GUID      = 11,
    WS_XML_TEXT_TYPE_UNIQUE_ID = 12,
    WS_XML_TEXT_TYPE_DATETIME  = 13,
    WS_XML_TEXT_TYPE_TIMESPAN  = 14,
    WS_XML_TEXT_TYPE_QNAME     = 15,
    WS_XML_TEXT_TYPE_LIST      = 16
} WS_XML_TEXT_TYPE;

typedef struct _WS_XML_TEXT {
    WS_XML_TEXT_TYPE textType;
} WS_XML_TEXT;

typedef struct _WS_XML_UTF8_TEXT {
    WS_XML_TEXT text;
    WS_XML_STRING value;
} WS_XML_UTF8_TEXT;

typedef enum {
    WS_BOOL_VALUE_TYPE,
    WS_INT8_VALUE_TYPE,
    WS_INT16_VALUE_TYPE,
    WS_INT32_VALUE_TYPE,
    WS_INT64_VALUE_TYPE,
    WS_UINT8_VALUE_TYPE,
    WS_UINT16_VALUE_TYPE,
    WS_UINT32_VALUE_TYPE,
    WS_UINT64_VALUE_TYPE,
    WS_FLOAT_VALUE_TYPE,
    WS_DOUBLE_VALUE_TYPE,
    WS_DECIMAL_VALUE_TYPE,
    WS_DATETIME_VALUE_TYPE,
    WS_TIMESPAN_VALUE_TYPE,
    WS_GUID_VALUE_TYPE,
    WS_DURATION_VALUE_TYPE
} WS_VALUE_TYPE;

typedef struct _WS_XML_ATTRIBUTE {
    BYTE singleQuote;
    BYTE isXmlNs;
    WS_XML_STRING *prefix;
    WS_XML_STRING *localName;
    WS_XML_STRING *ns;
    WS_XML_TEXT *value;
} WS_XML_ATTRIBUTE;

typedef struct _WS_XML_ELEMENT_NODE {
    WS_XML_NODE node;
    WS_XML_STRING *prefix;
    WS_XML_STRING *localName;
    WS_XML_STRING *ns;
    ULONG attributeCount;
    WS_XML_ATTRIBUTE **attributes;
    BOOL isEmpty;
} WS_XML_ELEMENT_NODE;

typedef struct _WS_XML_TEXT_NODE {
    WS_XML_NODE node;
    WS_XML_TEXT *text;
} WS_XML_TEXT_NODE;

typedef struct _WS_XML_COMMENT_NODE {
    WS_XML_NODE node;
    WS_XML_STRING value;
} WS_XML_COMMENT_NODE;

typedef struct _WS_XML_NODE_POSITION {
    WS_XML_BUFFER *buffer;
    void *node;
} WS_XML_NODE_POSITION;

typedef enum {
    WS_SERVICE_PROXY_STATE_CREATED,
    WS_SERVICE_PROXY_STATE_OPENING,
    WS_SERVICE_PROXY_STATE_OPEN,
    WS_SERVICE_PROXY_STATE_CLOSING,
    WS_SERVICE_PROXY_STATE_CLOSED,
    WS_SERVICE_PROXY_STATE_FAULTED
} WS_SERVICE_PROXY_STATE;

typedef enum {
    WS_PROXY_PROPERTY_CALL_TIMEOUT,
    WS_PROXY_PROPERTY_MESSAGE_PROPERTIES,
    WS_PROXY_PROPERTY_MAX_CALL_POOL_SIZE,
    WS_PROXY_PROPERTY_STATE,
    WS_PROXY_PROPERTY_MAX_PENDING_CALLS,
    WS_PROXY_PROPERTY_MAX_CLOSE_TIMEOUT,
    WS_PROXY_FAULT_LANG_ID
} WS_PROXY_PROPERTY_ID;

struct _WS_PROXY_PROPERTY {
    WS_PROXY_PROPERTY_ID id;
    void *value;
    ULONG valueSize;
};

typedef enum {
    WS_CHANNEL_TYPE_INPUT           = 0x1,
    WS_CHANNEL_TYPE_OUTPUT          = 0x2,
    WS_CHANNEL_TYPE_SESSION         = 0x4,
    WS_CHANNEL_TYPE_INPUT_SESSION   = (WS_CHANNEL_TYPE_INPUT  | WS_CHANNEL_TYPE_SESSION),
    WS_CHANNEL_TYPE_OUTPUT_SESSION  = (WS_CHANNEL_TYPE_OUTPUT | WS_CHANNEL_TYPE_SESSION),
    WS_CHANNEL_TYPE_DUPLEX          = (WS_CHANNEL_TYPE_INPUT  | WS_CHANNEL_TYPE_OUTPUT),
    WS_CHANNEL_TYPE_DUPLEX_SESSION  = (WS_CHANNEL_TYPE_INPUT  | WS_CHANNEL_TYPE_OUTPUT | WS_CHANNEL_TYPE_SESSION),
    WS_CHANNEL_TYPE_REQUEST         = 0x8,
    WS_CHANNEL_TYPE_REPLY           = 0x10
} WS_CHANNEL_TYPE;

typedef enum {
    WS_ENCODING_XML_BINARY_1,
    WS_ENCODING_XML_BINARY_SESSION_1,
    WS_ENCODING_XML_MTOM_UTF8,
    WS_ENCODING_XML_MTOM_UTF16BE,
    WS_ENCODING_XML_MTOM_UTF16LE,
    WS_ENCODING_XML_UTF8,
    WS_ENCODING_XML_UTF16BE,
    WS_ENCODING_XML_UTF16LE,
    WS_ENCODING_RAW
} WS_ENCODING;

typedef enum {
    WS_CHANNEL_STATE_CREATED,
    WS_CHANNEL_STATE_OPENING,
    WS_CHANNEL_STATE_ACCEPTING,
    WS_CHANNEL_STATE_OPEN,
    WS_CHANNEL_STATE_FAULTED,
    WS_CHANNEL_STATE_CLOSING,
    WS_CHANNEL_STATE_CLOSED
} WS_CHANNEL_STATE;

typedef enum {
    WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE               = 0,
    WS_CHANNEL_PROPERTY_MAX_STREAMED_MESSAGE_SIZE               = 1,
    WS_CHANNEL_PROPERTY_MAX_STREAMED_START_SIZE                 = 2,
    WS_CHANNEL_PROPERTY_MAX_STREAMED_FLUSH_SIZE                 = 3,
    WS_CHANNEL_PROPERTY_ENCODING                                = 4,
    WS_CHANNEL_PROPERTY_ENVELOPE_VERSION                        = 5,
    WS_CHANNEL_PROPERTY_ADDRESSING_VERSION                      = 6,
    WS_CHANNEL_PROPERTY_MAX_SESSION_DICTIONARY_SIZE             = 7,
    WS_CHANNEL_PROPERTY_STATE                                   = 8,
    WS_CHANNEL_PROPERTY_ASYNC_CALLBACK_MODEL                    = 9,
    WS_CHANNEL_PROPERTY_IP_VERSION                              = 10,
    WS_CHANNEL_PROPERTY_RESOLVE_TIMEOUT                         = 11,
    WS_CHANNEL_PROPERTY_CONNECT_TIMEOUT                         = 12,
    WS_CHANNEL_PROPERTY_SEND_TIMEOUT                            = 13,
    WS_CHANNEL_PROPERTY_RECEIVE_RESPONSE_TIMEOUT                = 14,
    WS_CHANNEL_PROPERTY_RECEIVE_TIMEOUT                         = 15,
    WS_CHANNEL_PROPERTY_CLOSE_TIMEOUT                           = 16,
    WS_CHANNEL_PROPERTY_ENABLE_TIMEOUTS                         = 17,
    WS_CHANNEL_PROPERTY_TRANSFER_MODE                           = 18,
    WS_CHANNEL_PROPERTY_MULTICAST_INTERFACE                     = 19,
    WS_CHANNEL_PROPERTY_MULTICAST_HOPS                          = 20,
    WS_CHANNEL_PROPERTY_REMOTE_ADDRESS                          = 21,
    WS_CHANNEL_PROPERTY_REMOTE_IP_ADDRESS                       = 22,
    WS_CHANNEL_PROPERTY_HTTP_CONNECTION_ID                      = 23,
    WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_CALLBACKS                = 24,
    WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_PARAMETERS               = 25,
    WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_INSTANCE                 = 26,
    WS_CHANNEL_PROPERTY_TRANSPORT_URL                           = 27,
    WS_CHANNEL_PROPERTY_NO_DELAY                                = 28,
    WS_CHANNEL_PROPERTY_SEND_KEEP_ALIVES                        = 29,
    WS_CHANNEL_PROPERTY_KEEP_ALIVE_TIME                         = 30,
    WS_CHANNEL_PROPERTY_KEEP_ALIVE_INTERVAL                     = 31,
    WS_CHANNEL_PROPERTY_MAX_HTTP_SERVER_CONNECTIONS             = 32,
    WS_CHANNEL_PROPERTY_IS_SESSION_SHUT_DOWN                    = 33,
    WS_CHANNEL_PROPERTY_CHANNEL_TYPE                            = 34,
    WS_CHANNEL_PROPERTY_TRIM_BUFFERED_MESSAGE_SIZE              = 35,
    WS_CHANNEL_PROPERTY_ENCODER                                 = 36,
    WS_CHANNEL_PROPERTY_DECODER                                 = 37,
    WS_CHANNEL_PROPERTY_PROTECTION_LEVEL                        = 38,
    WS_CHANNEL_PROPERTY_COOKIE_MODE                             = 39,
    WS_CHANNEL_PROPERTY_HTTP_PROXY_SETTING_MODE                 = 40,
    WS_CHANNEL_PROPERTY_CUSTOM_HTTP_PROXY                       = 41,
    WS_CHANNEL_PROPERTY_HTTP_MESSAGE_MAPPING                    = 42,
    WS_CHANNEL_PROPERTY_ENABLE_HTTP_REDIRECT                    = 43,
    WS_CHANNEL_PROPERTY_HTTP_REDIRECT_CALLBACK_CONTEXT          = 44,
    WS_CHANNEL_PROPERTY_FAULTS_AS_ERRORS                        = 45,
    WS_CHANNEL_PROPERTY_ALLOW_UNSECURED_FAULTS                  = 46,
    WS_CHANNEL_PROPERTY_HTTP_SERVER_SPN                         = 47,
    WS_CHANNEL_PROPERTY_HTTP_PROXY_SPN                          = 48,
    WS_CHANNEL_PROPERTY_MAX_HTTP_REQUEST_HEADERS_BUFFER_SIZE    = 49
} WS_CHANNEL_PROPERTY_ID;

struct _WS_CHANNEL_PROPERTY {
    WS_CHANNEL_PROPERTY_ID id;
    void *value;
    ULONG valueSize;
};

struct _WS_CHANNEL_PROPERTIES {
    WS_CHANNEL_PROPERTY *properties;
    ULONG propertyCount;
};

typedef enum {
    WS_HTTP_CHANNEL_BINDING,
    WS_TCP_CHANNEL_BINDING,
    WS_UDP_CHANNEL_BINDING,
    WS_CUSTOM_CHANNEL_BINDING,
    WS_NAMEDPIPE_CHANNEL_BINDING
} WS_CHANNEL_BINDING;

typedef enum {
    WS_SSL_TRANSPORT_SECURITY_BINDING_TYPE,
    WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TYPE,
    WS_HTTP_HEADER_AUTH_SECURITY_BINDING_TYPE,
    WS_USERNAME_MESSAGE_SECURITY_BINDING_TYPE,
    WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TYPE,
    WS_XML_TOKEN_MESSAGE_SECURITY_BINDING_TYPE,
    WS_SAML_MESSAGE_SECURITY_BINDING_TYPE,
    WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_TYPE,
    WS_NAMEDPIPE_SSPI_TRANSPORT_SECURITY_BINDING_TYPE
} WS_SECURITY_BINDING_TYPE;

typedef enum {
    WS_SECURITY_BINDING_PROPERTY_REQUIRE_SSL_CLIENT_CERT                    = 1,
    WS_SECURITY_BINDING_PROPERTY_WINDOWS_INTEGRATED_AUTH_PACKAGE            = 2,
    WS_SECURITY_BINDING_PROPERTY_REQUIRE_SERVER_AUTH                        = 3,
    WS_SECURITY_BINDING_PROPERTY_ALLOW_ANONYMOUS_CLIENTS                    = 4,
    WS_SECURITY_BINDING_PROPERTY_ALLOWED_IMPERSONATION_LEVEL                = 5,
    WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_SCHEME                    = 6,
    WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_TARGET                    = 7,
    WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_BASIC_REALM               = 8,
    WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_DIGEST_REALM              = 9,
    WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_DIGEST_DOMAIN             = 10,
    WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_KEY_SIZE                  = 11,
    WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_KEY_ENTROPY_MODE          = 12,
    WS_SECURITY_BINDING_PROPERTY_MESSAGE_PROPERTIES                         = 13,
    WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_MAX_PENDING_CONTEXTS      = 14,
    WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_MAX_ACTIVE_CONTEXTS       = 15,
    WS_SECURITY_BINDING_PROPERTY_SECURE_CONVERSATION_VERSION                = 16,
    WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_SUPPORT_RENEW             = 17,
    WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_RENEWAL_INTERVAL          = 18,
    WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_ROLLOVER_INTERVAL         = 19,
    WS_SECURITY_BINDING_PROPERTY_CERT_FAILURES_TO_IGNORE                    = 20,
    WS_SECURITY_BINDING_PROPERTY_DISABLE_CERT_REVOCATION_CHECK              = 21,
    WS_SECURITY_BINDING_PROPERTY_DISALLOWED_SECURE_PROTOCOLS                = 22,
    WS_SECURITY_BINDING_PROPERTY_CERTIFICATE_VALIDATION_CALLBACK_CONTEXT    = 23
} WS_SECURITY_BINDING_PROPERTY_ID;

struct _WS_SECURITY_BINDING_PROPERTY {
    WS_SECURITY_BINDING_PROPERTY_ID id;
    void *value;
    ULONG valueSize;
};

struct _WS_SECURITY_BINDING_PROPERTIES {
    WS_SECURITY_BINDING_PROPERTY *properties;
    ULONG propertyCount;
};

struct _WS_SECURITY_BINDING {
    WS_SECURITY_BINDING_TYPE bindingType;
    WS_SECURITY_BINDING_PROPERTY *properties;
    ULONG propertyCount;
};

typedef enum {
    WS_SECURITY_PROPERTY_TRANSPORT_PROTECTION_LEVEL     = 1,
    WS_SECURITY_PROPERTY_ALGORITHM_SUITE                = 2,
    WS_SECURITY_PROPERTY_ALGORITHM_SUITE_NAME           = 3,
    WS_SECURITY_PROPERTY_MAX_ALLOWED_LATENCY            = 4,
    WS_SECURITY_PROPERTY_TIMESTAMP_VALIDITY_DURATION    = 5,
    WS_SECURITY_PROPERTY_MAX_ALLOWED_CLOCK_SKEW         = 6,
    WS_SECURITY_PROPERTY_TIMESTAMP_USAGE                = 7,
    WS_SECURITY_PROPERTY_SECURITY_HEADER_LAYOUT         = 8,
    WS_SECURITY_PROPERTY_SECURITY_HEADER_VERSION        = 9,
    WS_SECURITY_PROPERTY_EXTENDED_PROTECTION_POLICY     = 10,
    WS_SECURITY_PROPERTY_EXTENDED_PROTECTION_SCENARIO   = 11,
    WS_SECURITY_PROPERTY_SERVICE_IDENTITIES             = 12
} WS_SECURITY_PROPERTY_ID;

struct _WS_SECURITY_PROPERTY {
    WS_SECURITY_PROPERTY_ID id;
    void *value;
    ULONG valueSize;
};

struct _WS_SECURITY_PROPERTIES {
    WS_SECURITY_PROPERTY *properties;
    ULONG propertyCount;
};

struct _WS_SECURITY_DESCRIPTION {
    WS_SECURITY_BINDING **securityBindings;
    ULONG securityBindingCount;
    WS_SECURITY_PROPERTY *properties;
    ULONG propertyCount;
};

typedef enum {
    WS_HTTP_BINDING_TEMPLATE_TYPE,
    WS_HTTP_SSL_BINDING_TEMPLATE_TYPE,
    WS_HTTP_HEADER_AUTH_BINDING_TEMPLATE_TYPE,
    WS_HTTP_SSL_HEADER_AUTH_BINDING_TEMPLATE_TYPE,
    WS_HTTP_SSL_USERNAME_BINDING_TEMPLATE_TYPE,
    WS_HTTP_SSL_KERBEROS_APREQ_BINDING_TEMPLATE_TYPE,
    WS_TCP_BINDING_TEMPLATE_TYPE,
    WS_TCP_SSPI_BINDING_TEMPLATE_TYPE,
    WS_TCP_SSPI_USERNAME_BINDING_TEMPLATE_TYPE,
    WS_TCP_SSPI_KERBEROS_APREQ_BINDING_TEMPLATE_TYPE,
    WS_HTTP_SSL_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE,
    WS_HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE,
    WS_TCP_SSPI_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE,
    WS_TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE
} WS_BINDING_TEMPLATE_TYPE;

typedef enum {
    WS_SUBJECT_NAME_CERT_CREDENTIAL_TYPE    = 1,
    WS_THUMBPRINT_CERT_CREDENTIAL_TYPE      = 2,
    WS_CUSTOM_CERT_CREDENTIAL_TYPE          = 3
} WS_CERT_CREDENTIAL_TYPE;

struct _WS_CERT_CREDENTIAL {
    WS_CERT_CREDENTIAL_TYPE credentialType;
};

struct _WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE {
    WS_SECURITY_BINDING_PROPERTIES securityBindingProperties;
    WS_CERT_CREDENTIAL *localCertCredential;
};

struct _WS_HTTP_BINDING_TEMPLATE {
    WS_CHANNEL_PROPERTIES channelProperties;
};

struct _WS_HTTP_SSL_BINDING_TEMPLATE {
    WS_CHANNEL_PROPERTIES channelProperties;
    WS_SECURITY_PROPERTIES securityProperties;
    WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE sslTransportSecurityBinding;
};

typedef enum {
    WS_ADDRESSING_VERSION_0_9       = 1,
    WS_ADDRESSING_VERSION_1_0       = 2,
    WS_ADDRESSING_VERSION_TRANSPORT = 3
} WS_ADDRESSING_VERSION;

typedef enum {
    WS_ENVELOPE_VERSION_SOAP_1_1    = 1,
    WS_ENVELOPE_VERSION_SOAP_1_2    = 2,
    WS_ENVELOPE_VERSION_NONE        = 3
} WS_ENVELOPE_VERSION;

typedef enum {
    WS_MESSAGE_PROPERTY_STATE,
    WS_MESSAGE_PROPERTY_HEAP,
    WS_MESSAGE_PROPERTY_ENVELOPE_VERSION,
    WS_MESSAGE_PROPERTY_ADDRESSING_VERSION,
    WS_MESSAGE_PROPERTY_HEADER_BUFFER,
    WS_MESSAGE_PROPERTY_HEADER_POSITION,
    WS_MESSAGE_PROPERTY_BODY_READER,
    WS_MESSAGE_PROPERTY_BODY_WRITER,
    WS_MESSAGE_PROPERTY_IS_ADDRESSED,
    WS_MESSAGE_PROPERTY_HEAP_PROPERTIES,
    WS_MESSAGE_PROPERTY_XML_READER_PROPERTIES,
    WS_MESSAGE_PROPERTY_XML_WRITER_PROPERTIES,
    WS_MESSAGE_PROPERTY_IS_FAULT,
    WS_MESSAGE_PROPERTY_MAX_PROCESSED_HEADERS,
    WS_MESSAGE_PROPERTY_USERNAME,
    WS_MESSAGE_PROPERTY_ENCODED_CERT,
    WS_MESSAGE_PROPERTY_TRANSPORT_SECURITY_WINDOWS_TOKEN,
    WS_MESSAGE_PROPERTY_HTTP_HEADER_AUTH_WINDOWS_TOKEN,
    WS_MESSAGE_PROPERTY_MESSAGE_SECURITY_WINDOWS_TOKEN,
    WS_MESSAGE_PROPERTY_SAML_ASSERTION,
    WS_MESSAGE_PROPERTY_SECURITY_CONTEXT,
    WS_MESSAGE_PROPERTY_PROTECTION_LEVEL
} WS_MESSAGE_PROPERTY_ID;

struct _WS_MESSAGE_PROPERTY {
    WS_MESSAGE_PROPERTY_ID id;
    void *value;
    ULONG valueSize;
};

struct _WS_MESSAGE_PROPERTIES {
    WS_MESSAGE_PROPERTY *properties;
    ULONG propertyCount;
};

typedef enum {
    WS_MESSAGE_STATE_EMPTY          = 1,
    WS_MESSAGE_STATE_INITIALIZED    = 2,
    WS_MESSAGE_STATE_READING        = 3,
    WS_MESSAGE_STATE_WRITING        = 4,
    WS_MESSAGE_STATE_DONE           = 5
} WS_MESSAGE_STATE;

typedef enum {
    WS_BLANK_MESSAGE,
    WS_DUPLICATE_MESSAGE,
    WS_REQUEST_MESSAGE,
    WS_REPLY_MESSAGE,
    WS_FAULT_MESSAGE
} WS_MESSAGE_INITIALIZATION;

typedef enum {
    WS_DNS_ENDPOINT_IDENTITY_TYPE       = 1,
    WS_UPN_ENDPOINT_IDENTITY_TYPE       = 2,
    WS_SPN_ENDPOINT_IDENTITY_TYPE       = 3,
    WS_RSA_ENDPOINT_IDENTITY_TYPE       = 4,
    WS_CERT_ENDPOINT_IDENTITY_TYPE      = 5,
    WS_UNKNOWN_ENDPOINT_IDENTITY_TYPE   = 6
} WS_ENDPOINT_IDENTITY_TYPE;

struct _WS_ENDPOINT_IDENTITY {
    WS_ENDPOINT_IDENTITY_TYPE identityType;
};

struct _WS_ENDPOINT_ADDRESS {
    WS_STRING url;
    WS_XML_BUFFER *headers;
    WS_XML_BUFFER *extensions;
    WS_ENDPOINT_IDENTITY *identity;
};

struct _WS_HTTP_POLICY_DESCRIPTION {
    WS_CHANNEL_PROPERTIES channelProperties;
};

struct _WS_MESSAGE_DESCRIPTION {
    WS_XML_STRING *action;
    WS_ELEMENT_DESCRIPTION *bodyElementDescription;
};

typedef enum {
    WS_PARAMETER_TYPE_NORMAL,
    WS_PARAMETER_TYPE_ARRAY,
    WS_PARAMETER_TYPE_ARRAY_COUNT,
    WS_PARAMETER_TYPE_MESSAGES
} WS_PARAMETER_TYPE;

struct _WS_PARAMETER_DESCRIPTION {
    WS_PARAMETER_TYPE parameterType;
    USHORT inputMessageIndex;
    USHORT outputMessageIndex;
};

typedef HRESULT (CALLBACK *WS_SERVICE_STUB_CALLBACK)(
    const WS_OPERATION_CONTEXT *context,
    void *frame,
    const void *callback,
    const WS_ASYNC_CONTEXT *asyncContext,
    WS_ERROR *error );

typedef enum {
    WS_NON_RPC_LITERAL_OPERATION,
    WS_RPC_LITERAL_OPERATION
} WS_OPERATION_STYLE;

struct _WS_OPERATION_DESCRIPTION {
    ULONG versionInfo;
    WS_MESSAGE_DESCRIPTION *inputMessageDescription;
    WS_MESSAGE_DESCRIPTION *outputMessageDescription;
    ULONG inputMessageOptions;
    ULONG outputMessageOptions;
    USHORT parameterCount;
    WS_PARAMETER_DESCRIPTION *parameterDescription;
    WS_SERVICE_STUB_CALLBACK stubCallback;
    WS_OPERATION_STYLE style;
};

typedef enum {
    WS_CALL_PROPERTY_CHECK_MUST_UNDERSTAND,
    WS_CALL_PROPERTY_SEND_MESSAGE_CONTEXT,
    WS_CALL_PROPERTY_RECEIVE_MESSAGE_CONTEXT,
    WS_CALL_PROPERTY_CALL_ID
} WS_CALL_PROPERTY_ID;

struct _WS_CALL_PROPERTY {
    WS_CALL_PROPERTY_ID id;
    void *value;
    ULONG valueSize;
};

typedef enum {
    WS_DATETIME_FORMAT_UTC,
    WS_DATETIME_FORMAT_LOCAL,
    WS_DATETIME_FORMAT_NONE
} WS_DATETIME_FORMAT;

struct _WS_DATETIME {
    unsigned __int64 ticks;
    WS_DATETIME_FORMAT format;
};

struct _WS_DATETIME_DESCRIPTION {
    WS_DATETIME minValue;
    WS_DATETIME maxValue;
};

HRESULT WINAPI WsAlloc(WS_HEAP*, SIZE_T, void**, WS_ERROR*);
HRESULT WINAPI WsCall(WS_SERVICE_PROXY*, const WS_OPERATION_DESCRIPTION*, const void**,
                      WS_HEAP*, const WS_CALL_PROPERTY*, const ULONG, const WS_ASYNC_CONTEXT*,
                      WS_ERROR*);
HRESULT WINAPI WsCloseChannel(WS_CHANNEL*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
HRESULT WINAPI WsCloseServiceProxy(WS_SERVICE_PROXY*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
HRESULT WINAPI WsCreateChannel(WS_CHANNEL_TYPE, WS_CHANNEL_BINDING, const WS_CHANNEL_PROPERTY*,
                               ULONG, const WS_SECURITY_DESCRIPTION*, WS_CHANNEL**, WS_ERROR*);
HRESULT WINAPI WsCreateError(const WS_ERROR_PROPERTY*, ULONG, WS_ERROR**);
HRESULT WINAPI WsCreateHeap(SIZE_T, SIZE_T, const WS_HEAP_PROPERTY*, ULONG, WS_HEAP**, WS_ERROR*);
HRESULT WINAPI WsCreateMessage(WS_ENVELOPE_VERSION, WS_ADDRESSING_VERSION, const WS_MESSAGE_PROPERTY*,
                               ULONG, WS_MESSAGE**, WS_ERROR*);
HRESULT WINAPI WsCreateMessageForChannel(WS_CHANNEL*, const WS_MESSAGE_PROPERTY*, ULONG, WS_MESSAGE**,
                                         WS_ERROR*);
HRESULT WINAPI WsCreateReader(const WS_XML_READER_PROPERTY*, ULONG, WS_XML_READER**, WS_ERROR*);
HRESULT WINAPI WsCreateServiceProxy(const WS_CHANNEL_TYPE, const WS_CHANNEL_BINDING,
                                    const WS_SECURITY_DESCRIPTION*, const WS_PROXY_PROPERTY*,
                                    const ULONG, const WS_CHANNEL_PROPERTY*, const ULONG,
                                    WS_SERVICE_PROXY**, WS_ERROR*);
HRESULT WINAPI WsCreateServiceProxyFromTemplate(WS_CHANNEL_TYPE, const WS_PROXY_PROPERTY*,
                                                const ULONG, WS_BINDING_TEMPLATE_TYPE,
                                                void*, ULONG, const void*, ULONG,
                                                WS_SERVICE_PROXY**, WS_ERROR*);
HRESULT WINAPI WsCreateWriter(const WS_XML_WRITER_PROPERTY*, ULONG, WS_XML_WRITER**, WS_ERROR*);
HRESULT WINAPI WsCreateXmlBuffer(WS_HEAP*, const WS_XML_BUFFER_PROPERTY*, ULONG, WS_XML_BUFFER**,
                                 WS_ERROR*);
HRESULT WINAPI WsDateTimeToFileTime(const WS_DATETIME*, FILETIME*, WS_ERROR*);
HRESULT WINAPI WsFileTimeToDateTime(const FILETIME*, WS_DATETIME*, WS_ERROR*);
HRESULT WINAPI WsFillReader(WS_XML_READER*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*);
HRESULT WINAPI WsFindAttribute(WS_XML_READER*, const WS_XML_STRING*, const WS_XML_STRING*, BOOL,
                               ULONG*, WS_ERROR*);
void WINAPI WsFreeChannel(WS_CHANNEL*);
void WINAPI WsFreeError(WS_ERROR*);
void WINAPI WsFreeHeap(WS_HEAP*);
void WINAPI WsFreeMessage(WS_MESSAGE*);
void WINAPI WsFreeReader(WS_XML_READER*);
void WINAPI WsFreeServiceProxy(WS_SERVICE_PROXY*);
void WINAPI WsFreeWriter(WS_XML_WRITER*);
HRESULT WINAPI WsGetChannelProperty(WS_CHANNEL*, WS_CHANNEL_PROPERTY_ID, void*, ULONG, WS_ERROR*);
HRESULT WINAPI WsGetErrorProperty(WS_ERROR*, WS_ERROR_PROPERTY_ID, void*, ULONG);
HRESULT WINAPI WsGetErrorString(WS_ERROR*, ULONG, WS_STRING*);
HRESULT WINAPI WsGetHeapProperty(WS_HEAP*, WS_HEAP_PROPERTY_ID, void*, ULONG, WS_ERROR*);
HRESULT WINAPI WsGetNamespaceFromPrefix(WS_XML_READER*, const WS_XML_STRING*, BOOL,
                                        const WS_XML_STRING**, WS_ERROR*);
HRESULT WINAPI WsGetPrefixFromNamespace(WS_XML_WRITER*, const WS_XML_STRING*, BOOL,
                                        const WS_XML_STRING**, WS_ERROR*);
HRESULT WINAPI WsGetReaderNode(WS_XML_READER*, const WS_XML_NODE**, WS_ERROR*);
HRESULT WINAPI WsGetReaderPosition(WS_XML_READER*, WS_XML_NODE_POSITION*, WS_ERROR*);
HRESULT WINAPI WsGetReaderProperty(WS_XML_READER*, WS_XML_READER_PROPERTY_ID, void*, ULONG, WS_ERROR*);
HRESULT WINAPI WsGetServiceProxyProperty(WS_SERVICE_PROXY*, const WS_PROXY_PROPERTY_ID, void*,
                                         ULONG, WS_ERROR*);
HRESULT WINAPI WsGetWriterProperty(WS_XML_WRITER*, WS_XML_WRITER_PROPERTY_ID, void*, ULONG, WS_ERROR*);
HRESULT WINAPI WsGetXmlAttribute(WS_XML_READER*, const WS_XML_STRING*, WS_HEAP*, WCHAR**,
                                 ULONG*, WS_ERROR*);
HRESULT WINAPI WsInitializeMessage(WS_MESSAGE*, WS_MESSAGE_INITIALIZATION, WS_MESSAGE*, WS_ERROR*);
HRESULT WINAPI WsMoveReader(WS_XML_READER*, WS_MOVE_TO, BOOL*, WS_ERROR*);
HRESULT WINAPI WsMoveWriter(WS_XML_WRITER*, WS_MOVE_TO, BOOL*, WS_ERROR*);
HRESULT WINAPI WsOpenChannel(WS_CHANNEL*, const WS_ENDPOINT_ADDRESS*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
HRESULT WINAPI WsOpenServiceProxy(WS_SERVICE_PROXY*, const WS_ENDPOINT_ADDRESS*, const WS_ASYNC_CONTEXT*,
                                  WS_ERROR*);
HRESULT WINAPI WsReadAttribute(WS_XML_READER*, const WS_ATTRIBUTE_DESCRIPTION*, WS_READ_OPTION,
                               WS_HEAP*, void*, ULONG, WS_ERROR*);
HRESULT WINAPI WsReadEndAttribute(WS_XML_READER*, WS_ERROR*);
HRESULT WINAPI WsReadEndElement(WS_XML_READER*, WS_ERROR*);
HRESULT WINAPI WsReadNode(WS_XML_READER*, WS_ERROR*);
HRESULT WINAPI WsReadStartAttribute(WS_XML_READER*, ULONG, WS_ERROR*);
HRESULT WINAPI WsReadStartElement(WS_XML_READER*, WS_ERROR*);
HRESULT WINAPI WsReadToStartElement(WS_XML_READER*, const WS_XML_STRING*, const WS_XML_STRING*,
                                    BOOL*, WS_ERROR*);
HRESULT WINAPI WsReadType(WS_XML_READER*, WS_TYPE_MAPPING, WS_TYPE, const void*, WS_READ_OPTION,
                          WS_HEAP*, void*, ULONG, WS_ERROR*);
HRESULT WINAPI WsResetHeap(WS_HEAP*, WS_ERROR*);
HRESULT WINAPI WsSendMessage(WS_CHANNEL*, WS_MESSAGE*, const WS_MESSAGE_DESCRIPTION*, WS_WRITE_OPTION,
                             const void*, ULONG, const WS_ASYNC_CONTEXT*, WS_ERROR*);
HRESULT WINAPI WsSetChannelProperty(WS_CHANNEL*, WS_CHANNEL_PROPERTY_ID, const void*, ULONG, WS_ERROR*);
HRESULT WINAPI WsSetErrorProperty(WS_ERROR*, WS_ERROR_PROPERTY_ID, const void*, ULONG);
HRESULT WINAPI WsSetInput(WS_XML_READER*, const WS_XML_READER_ENCODING*, const WS_XML_READER_INPUT*,
                          const WS_XML_READER_PROPERTY*, ULONG, WS_ERROR*);
HRESULT WINAPI WsSetInputToBuffer(WS_XML_READER*, WS_XML_BUFFER*, const WS_XML_READER_PROPERTY*,
                                  ULONG, WS_ERROR*);
HRESULT WINAPI WsSetOutput(WS_XML_WRITER*, const WS_XML_WRITER_ENCODING*, const WS_XML_WRITER_OUTPUT*,
                           const WS_XML_WRITER_PROPERTY*, ULONG, WS_ERROR*);
HRESULT WINAPI WsSetOutputToBuffer(WS_XML_WRITER*, WS_XML_BUFFER*, const WS_XML_WRITER_PROPERTY*,
                                   ULONG, WS_ERROR*);
HRESULT WINAPI WsSkipNode(WS_XML_READER*, WS_ERROR*);
HRESULT WINAPI WsWriteAttribute(WS_XML_WRITER*, const WS_ATTRIBUTE_DESCRIPTION*, WS_WRITE_OPTION,
                                const void*, ULONG, WS_ERROR*);
HRESULT WINAPI WsWriteElement(WS_XML_WRITER*, const WS_ELEMENT_DESCRIPTION*, WS_WRITE_OPTION,
                              const void*, ULONG, WS_ERROR*);
HRESULT WINAPI WsWriteEndAttribute(WS_XML_WRITER*, WS_ERROR*);
HRESULT WINAPI WsWriteEndCData(WS_XML_WRITER*, WS_ERROR*);
HRESULT WINAPI WsWriteEndElement(WS_XML_WRITER*, WS_ERROR*);
HRESULT WINAPI WsWriteEndStartElement(WS_XML_WRITER*, WS_ERROR*);
HRESULT WINAPI WsWriteMessageStart(WS_CHANNEL*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
HRESULT WINAPI WsWriteMessageEnd(WS_CHANNEL*, WS_MESSAGE*, const WS_ASYNC_CONTEXT*, WS_ERROR*);
HRESULT WINAPI WsWriteStartAttribute(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*,
                                     const WS_XML_STRING*, BOOL, WS_ERROR*);
HRESULT WINAPI WsWriteStartCData(WS_XML_WRITER*, WS_ERROR*);
HRESULT WINAPI WsWriteStartElement(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*,
                                   const WS_XML_STRING*, WS_ERROR*);
HRESULT WINAPI WsWriteText(WS_XML_WRITER*, const WS_XML_TEXT*, WS_ERROR*);
HRESULT WINAPI WsWriteType(WS_XML_WRITER*, WS_TYPE_MAPPING, WS_TYPE, const void*, WS_WRITE_OPTION,
                           const void*, ULONG, WS_ERROR*);
HRESULT WINAPI WsWriteValue(WS_XML_WRITER*, WS_VALUE_TYPE, const void*, ULONG, WS_ERROR*);
HRESULT WINAPI WsWriteXmlBuffer(WS_XML_WRITER*, WS_XML_BUFFER*, WS_ERROR*);
HRESULT WINAPI WsWriteXmlBufferToBytes(WS_XML_WRITER*, WS_XML_BUFFER*, const WS_XML_WRITER_ENCODING*,
                                       const WS_XML_WRITER_PROPERTY*, ULONG, WS_HEAP*, void**,
                                       ULONG*, WS_ERROR*);
HRESULT WINAPI WsWriteXmlnsAttribute(WS_XML_WRITER*, const WS_XML_STRING*, const WS_XML_STRING*,
                                     BOOL, WS_ERROR*);
HRESULT WINAPI WsXmlStringEquals(const WS_XML_STRING*, const WS_XML_STRING*, WS_ERROR*);

#define WS_S_ASYNC                          0x003d0000
#define WS_S_END                            0x003d0001
#define WS_E_INVALID_FORMAT                 0x803d0000
#define WS_E_OBJECT_FAULTED                 0x803d0001
#define WS_E_NUMERIC_OVERFLOW               0x803d0002
#define WS_E_INVALID_OPERATION              0x803d0003
#define WS_E_OPERATION_ABORTED              0x803d0004
#define WS_E_ENDPOINT_ACCESS_DENIED         0x803d0005
#define WS_E_OPERATION_TIMED_OUT            0x803d0006
#define WS_E_OPERATION_ABANDONED            0x803d0007
#define WS_E_QUOTA_EXCEEDED                 0x803d0008
#define WS_E_NO_TRANSLATION_AVAILABLE       0x803d0009
#define WS_E_SECURITY_VERIFICATION_FAILURE  0x803d000a
#define WS_E_ADDRESS_IN_USE                 0x803d000b
#define WS_E_ADDRESS_NOT_AVAILABLE          0x803d000c
#define WS_E_ENDPOINT_NOT_FOUND             0x803d000d
#define WS_E_ENDPOINT_NOT_AVAILABLE         0x803d000e
#define WS_E_ENDPOINT_FAILURE               0x803d000f
#define WS_E_ENDPOINT_UNREACHABLE           0x803d0010
#define WS_E_ENDPOINT_ACTION_NOT_SUPPORTED  0x803d0011
#define WS_E_ENDPOINT_TOO_BUSY              0x803d0012
#define WS_E_ENDPOINT_FAULT_RECEIVED        0x803d0013
#define WS_E_ENDPOINT_DISCONNECTED          0x803d0014
#define WS_E_PROXY_FAILURE                  0x803d0015
#define WS_E_PROXY_ACCESS_DENIED            0x803d0016
#define WS_E_NOT_SUPPORTED                  0x803d0017
#define WS_E_PROXY_REQUIRES_BASIC_AUTH      0x803d0018
#define WS_E_PROXY_REQUIRES_DIGEST_AUTH     0x803d0019
#define WS_E_PROXY_REQUIRES_NTLM_AUTH       0x803d001a
#define WS_E_PROXY_REQUIRES_NEGOTIATE_AUTH  0x803d001b
#define WS_E_SERVER_REQUIRES_BASIC_AUTH     0x803d001c
#define WS_E_SERVER_REQUIRES_DIGEST_AUTH    0x803d001d
#define WS_E_SERVER_REQUIRES_NTLM_AUTH      0x803d001e
#define WS_E_SERVER_REQUIRES_NEGOTIATE_AUTH 0x803d001f
#define WS_E_INVALID_ENDPOINT_URL           0x803d0020
#define WS_E_OTHER                          0x803d0021
#define WS_E_SECURITY_TOKEN_EXPIRED         0x803d0022
#define WS_E_SECURITY_SYSTEM_FAILURE        0x803d0023

#ifdef __cplusplus
}
#endif  /* __cplusplus */

#endif /* __WINE_WEBSERVICES_H */