6684 lines
257 KiB
Zig
6684 lines
257 KiB
Zig
//! NOTE: this file is autogenerated, DO NOT MODIFY
|
|
//--------------------------------------------------------------------------------
|
|
// Section: Constants (138)
|
|
//--------------------------------------------------------------------------------
|
|
pub const WEBAUTHN_API_VERSION_1 = @as(u32, 1);
|
|
pub const WEBAUTHN_API_VERSION_2 = @as(u32, 2);
|
|
pub const WEBAUTHN_API_VERSION_3 = @as(u32, 3);
|
|
pub const WEBAUTHN_API_CURRENT_VERSION = @as(u32, 3);
|
|
pub const WEBAUTHN_RP_ENTITY_INFORMATION_CURRENT_VERSION = @as(u32, 1);
|
|
pub const WEBAUTHN_MAX_USER_ID_LENGTH = @as(u32, 64);
|
|
pub const WEBAUTHN_USER_ENTITY_INFORMATION_CURRENT_VERSION = @as(u32, 1);
|
|
pub const WEBAUTHN_HASH_ALGORITHM_SHA_256 = "SHA-256";
|
|
pub const WEBAUTHN_HASH_ALGORITHM_SHA_384 = "SHA-384";
|
|
pub const WEBAUTHN_HASH_ALGORITHM_SHA_512 = "SHA-512";
|
|
pub const WEBAUTHN_CLIENT_DATA_CURRENT_VERSION = @as(u32, 1);
|
|
pub const WEBAUTHN_CREDENTIAL_TYPE_PUBLIC_KEY = "public-key";
|
|
pub const WEBAUTHN_COSE_ALGORITHM_ECDSA_P256_WITH_SHA256 = @as(i32, -7);
|
|
pub const WEBAUTHN_COSE_ALGORITHM_ECDSA_P384_WITH_SHA384 = @as(i32, -35);
|
|
pub const WEBAUTHN_COSE_ALGORITHM_ECDSA_P521_WITH_SHA512 = @as(i32, -36);
|
|
pub const WEBAUTHN_COSE_ALGORITHM_RSASSA_PKCS1_V1_5_WITH_SHA256 = @as(i32, -257);
|
|
pub const WEBAUTHN_COSE_ALGORITHM_RSASSA_PKCS1_V1_5_WITH_SHA384 = @as(i32, -258);
|
|
pub const WEBAUTHN_COSE_ALGORITHM_RSASSA_PKCS1_V1_5_WITH_SHA512 = @as(i32, -259);
|
|
pub const WEBAUTHN_COSE_ALGORITHM_RSA_PSS_WITH_SHA256 = @as(i32, -37);
|
|
pub const WEBAUTHN_COSE_ALGORITHM_RSA_PSS_WITH_SHA384 = @as(i32, -38);
|
|
pub const WEBAUTHN_COSE_ALGORITHM_RSA_PSS_WITH_SHA512 = @as(i32, -39);
|
|
pub const WEBAUTHN_COSE_CREDENTIAL_PARAMETER_CURRENT_VERSION = @as(u32, 1);
|
|
pub const WEBAUTHN_CREDENTIAL_CURRENT_VERSION = @as(u32, 1);
|
|
pub const WEBAUTHN_CTAP_TRANSPORT_USB = @as(u32, 1);
|
|
pub const WEBAUTHN_CTAP_TRANSPORT_NFC = @as(u32, 2);
|
|
pub const WEBAUTHN_CTAP_TRANSPORT_BLE = @as(u32, 4);
|
|
pub const WEBAUTHN_CTAP_TRANSPORT_TEST = @as(u32, 8);
|
|
pub const WEBAUTHN_CTAP_TRANSPORT_INTERNAL = @as(u32, 16);
|
|
pub const WEBAUTHN_CTAP_TRANSPORT_FLAGS_MASK = @as(u32, 31);
|
|
pub const WEBAUTHN_CREDENTIAL_EX_CURRENT_VERSION = @as(u32, 1);
|
|
pub const WEBAUTHN_EXTENSIONS_IDENTIFIER_HMAC_SECRET = "hmac-secret";
|
|
pub const WEBAUTHN_USER_VERIFICATION_ANY = @as(u32, 0);
|
|
pub const WEBAUTHN_USER_VERIFICATION_OPTIONAL = @as(u32, 1);
|
|
pub const WEBAUTHN_USER_VERIFICATION_OPTIONAL_WITH_CREDENTIAL_ID_LIST = @as(u32, 2);
|
|
pub const WEBAUTHN_USER_VERIFICATION_REQUIRED = @as(u32, 3);
|
|
pub const WEBAUTHN_EXTENSIONS_IDENTIFIER_CRED_PROTECT = "credProtect";
|
|
pub const WEBAUTHN_EXTENSIONS_IDENTIFIER_CRED_BLOB = "credBlob";
|
|
pub const WEBAUTHN_EXTENSIONS_IDENTIFIER_MIN_PIN_LENGTH = "minPinLength";
|
|
pub const WEBAUTHN_AUTHENTICATOR_ATTACHMENT_ANY = @as(u32, 0);
|
|
pub const WEBAUTHN_AUTHENTICATOR_ATTACHMENT_PLATFORM = @as(u32, 1);
|
|
pub const WEBAUTHN_AUTHENTICATOR_ATTACHMENT_CROSS_PLATFORM = @as(u32, 2);
|
|
pub const WEBAUTHN_AUTHENTICATOR_ATTACHMENT_CROSS_PLATFORM_U2F_V2 = @as(u32, 3);
|
|
pub const WEBAUTHN_USER_VERIFICATION_REQUIREMENT_ANY = @as(u32, 0);
|
|
pub const WEBAUTHN_USER_VERIFICATION_REQUIREMENT_REQUIRED = @as(u32, 1);
|
|
pub const WEBAUTHN_USER_VERIFICATION_REQUIREMENT_PREFERRED = @as(u32, 2);
|
|
pub const WEBAUTHN_USER_VERIFICATION_REQUIREMENT_DISCOURAGED = @as(u32, 3);
|
|
pub const WEBAUTHN_ATTESTATION_CONVEYANCE_PREFERENCE_ANY = @as(u32, 0);
|
|
pub const WEBAUTHN_ATTESTATION_CONVEYANCE_PREFERENCE_NONE = @as(u32, 1);
|
|
pub const WEBAUTHN_ATTESTATION_CONVEYANCE_PREFERENCE_INDIRECT = @as(u32, 2);
|
|
pub const WEBAUTHN_ATTESTATION_CONVEYANCE_PREFERENCE_DIRECT = @as(u32, 3);
|
|
pub const WEBAUTHN_ENTERPRISE_ATTESTATION_NONE = @as(u32, 0);
|
|
pub const WEBAUTHN_ENTERPRISE_ATTESTATION_VENDOR_FACILITATED = @as(u32, 1);
|
|
pub const WEBAUTHN_ENTERPRISE_ATTESTATION_PLATFORM_MANAGED = @as(u32, 2);
|
|
pub const WEBAUTHN_LARGE_BLOB_SUPPORT_NONE = @as(u32, 0);
|
|
pub const WEBAUTHN_LARGE_BLOB_SUPPORT_REQUIRED = @as(u32, 1);
|
|
pub const WEBAUTHN_LARGE_BLOB_SUPPORT_PREFERRED = @as(u32, 2);
|
|
pub const WEBAUTHN_AUTHENTICATOR_MAKE_CREDENTIAL_OPTIONS_VERSION_1 = @as(u32, 1);
|
|
pub const WEBAUTHN_AUTHENTICATOR_MAKE_CREDENTIAL_OPTIONS_VERSION_2 = @as(u32, 2);
|
|
pub const WEBAUTHN_AUTHENTICATOR_MAKE_CREDENTIAL_OPTIONS_VERSION_3 = @as(u32, 3);
|
|
pub const WEBAUTHN_AUTHENTICATOR_MAKE_CREDENTIAL_OPTIONS_VERSION_4 = @as(u32, 4);
|
|
pub const WEBAUTHN_AUTHENTICATOR_MAKE_CREDENTIAL_OPTIONS_CURRENT_VERSION = @as(u32, 4);
|
|
pub const WEBAUTHN_CRED_LARGE_BLOB_OPERATION_NONE = @as(u32, 0);
|
|
pub const WEBAUTHN_CRED_LARGE_BLOB_OPERATION_GET = @as(u32, 1);
|
|
pub const WEBAUTHN_CRED_LARGE_BLOB_OPERATION_SET = @as(u32, 2);
|
|
pub const WEBAUTHN_CRED_LARGE_BLOB_OPERATION_DELETE = @as(u32, 3);
|
|
pub const WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS_VERSION_1 = @as(u32, 1);
|
|
pub const WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS_VERSION_2 = @as(u32, 2);
|
|
pub const WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS_VERSION_3 = @as(u32, 3);
|
|
pub const WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS_VERSION_4 = @as(u32, 4);
|
|
pub const WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS_VERSION_5 = @as(u32, 5);
|
|
pub const WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS_CURRENT_VERSION = @as(u32, 5);
|
|
pub const WEBAUTHN_ATTESTATION_DECODE_NONE = @as(u32, 0);
|
|
pub const WEBAUTHN_ATTESTATION_DECODE_COMMON = @as(u32, 1);
|
|
pub const WEBAUTHN_ATTESTATION_VER_TPM_2_0 = "2.0";
|
|
pub const WEBAUTHN_COMMON_ATTESTATION_CURRENT_VERSION = @as(u32, 1);
|
|
pub const WEBAUTHN_ATTESTATION_TYPE_PACKED = "packed";
|
|
pub const WEBAUTHN_ATTESTATION_TYPE_U2F = "fido-u2f";
|
|
pub const WEBAUTHN_ATTESTATION_TYPE_TPM = "tpm";
|
|
pub const WEBAUTHN_ATTESTATION_TYPE_NONE = "none";
|
|
pub const WEBAUTHN_CREDENTIAL_ATTESTATION_VERSION_1 = @as(u32, 1);
|
|
pub const WEBAUTHN_CREDENTIAL_ATTESTATION_VERSION_2 = @as(u32, 2);
|
|
pub const WEBAUTHN_CREDENTIAL_ATTESTATION_VERSION_3 = @as(u32, 3);
|
|
pub const WEBAUTHN_CREDENTIAL_ATTESTATION_VERSION_4 = @as(u32, 4);
|
|
pub const WEBAUTHN_CREDENTIAL_ATTESTATION_CURRENT_VERSION = @as(u32, 4);
|
|
pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_NONE = @as(u32, 0);
|
|
pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_SUCCESS = @as(u32, 1);
|
|
pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_NOT_SUPPORTED = @as(u32, 2);
|
|
pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_INVALID_DATA = @as(u32, 3);
|
|
pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_INVALID_PARAMETER = @as(u32, 4);
|
|
pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_NOT_FOUND = @as(u32, 5);
|
|
pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_MULTIPLE_CREDENTIALS = @as(u32, 6);
|
|
pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_LACK_OF_SPACE = @as(u32, 7);
|
|
pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_PLATFORM_ERROR = @as(u32, 8);
|
|
pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_AUTHENTICATOR_ERROR = @as(u32, 9);
|
|
pub const WEBAUTHN_ASSERTION_VERSION_1 = @as(u32, 1);
|
|
pub const WEBAUTHN_ASSERTION_VERSION_2 = @as(u32, 2);
|
|
pub const WEBAUTHN_ASSERTION_CURRENT_VERSION = @as(u32, 2);
|
|
pub const WS_HTTP_HEADER_MAPPING_COMMA_SEPARATOR = @as(i32, 1);
|
|
pub const WS_HTTP_HEADER_MAPPING_SEMICOLON_SEPARATOR = @as(i32, 2);
|
|
pub const WS_HTTP_HEADER_MAPPING_QUOTED_VALUE = @as(i32, 4);
|
|
pub const WS_HTTP_RESPONSE_MAPPING_STATUS_CODE = @as(i32, 1);
|
|
pub const WS_HTTP_RESPONSE_MAPPING_STATUS_TEXT = @as(i32, 2);
|
|
pub const WS_HTTP_REQUEST_MAPPING_VERB = @as(i32, 2);
|
|
pub const WS_MATCH_URL_DNS_HOST = @as(i32, 1);
|
|
pub const WS_MATCH_URL_DNS_FULLY_QUALIFIED_HOST = @as(i32, 2);
|
|
pub const WS_MATCH_URL_NETBIOS_HOST = @as(i32, 4);
|
|
pub const WS_MATCH_URL_LOCAL_HOST = @as(i32, 8);
|
|
pub const WS_MATCH_URL_HOST_ADDRESSES = @as(i32, 16);
|
|
pub const WS_MATCH_URL_THIS_HOST = @as(i32, 31);
|
|
pub const WS_MATCH_URL_PORT = @as(i32, 32);
|
|
pub const WS_MATCH_URL_EXACT_PATH = @as(i32, 64);
|
|
pub const WS_MATCH_URL_PREFIX_PATH = @as(i32, 128);
|
|
pub const WS_MATCH_URL_NO_QUERY = @as(i32, 256);
|
|
pub const WS_MUST_UNDERSTAND_HEADER_ATTRIBUTE = @as(i32, 1);
|
|
pub const WS_RELAY_HEADER_ATTRIBUTE = @as(i32, 2);
|
|
pub const WS_HTTP_HEADER_AUTH_SCHEME_NONE = @as(i32, 1);
|
|
pub const WS_HTTP_HEADER_AUTH_SCHEME_BASIC = @as(i32, 2);
|
|
pub const WS_HTTP_HEADER_AUTH_SCHEME_DIGEST = @as(i32, 4);
|
|
pub const WS_HTTP_HEADER_AUTH_SCHEME_NTLM = @as(i32, 8);
|
|
pub const WS_HTTP_HEADER_AUTH_SCHEME_NEGOTIATE = @as(i32, 16);
|
|
pub const WS_HTTP_HEADER_AUTH_SCHEME_PASSPORT = @as(i32, 32);
|
|
pub const WS_CERT_FAILURE_CN_MISMATCH = @as(i32, 1);
|
|
pub const WS_CERT_FAILURE_INVALID_DATE = @as(i32, 2);
|
|
pub const WS_CERT_FAILURE_UNTRUSTED_ROOT = @as(i32, 4);
|
|
pub const WS_CERT_FAILURE_WRONG_USAGE = @as(i32, 8);
|
|
pub const WS_CERT_FAILURE_REVOCATION_OFFLINE = @as(i32, 16);
|
|
pub const WS_STRUCT_ABSTRACT = @as(i32, 1);
|
|
pub const WS_STRUCT_IGNORE_TRAILING_ELEMENT_CONTENT = @as(i32, 2);
|
|
pub const WS_STRUCT_IGNORE_UNHANDLED_ATTRIBUTES = @as(i32, 4);
|
|
pub const WS_FIELD_POINTER = @as(i32, 1);
|
|
pub const WS_FIELD_OPTIONAL = @as(i32, 2);
|
|
pub const WS_FIELD_NILLABLE = @as(i32, 4);
|
|
pub const WS_FIELD_NILLABLE_ITEM = @as(i32, 8);
|
|
pub const WS_FIELD_OTHER_NAMESPACE = @as(i32, 16);
|
|
pub const WS_SERVICE_OPERATION_MESSAGE_NILLABLE_ELEMENT = @as(i32, 1);
|
|
pub const WS_URL_FLAGS_ALLOW_HOST_WILDCARDS = @as(i32, 1);
|
|
pub const WS_URL_FLAGS_NO_PATH_COLLAPSE = @as(i32, 2);
|
|
pub const WS_URL_FLAGS_ZERO_TERMINATE = @as(i32, 4);
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// Section: Types (451)
|
|
//--------------------------------------------------------------------------------
|
|
pub const WS_XML_READER = extern struct {
|
|
placeholder: usize, // TODO: why is this type empty?
|
|
};
|
|
|
|
pub const WS_XML_WRITER = extern struct {
|
|
placeholder: usize, // TODO: why is this type empty?
|
|
};
|
|
|
|
pub const WS_XML_BUFFER = extern struct {
|
|
placeholder: usize, // TODO: why is this type empty?
|
|
};
|
|
|
|
pub const WS_CHANNEL = extern struct {
|
|
placeholder: usize, // TODO: why is this type empty?
|
|
};
|
|
|
|
pub const WS_OPERATION_CONTEXT = extern struct {
|
|
placeholder: usize, // TODO: why is this type empty?
|
|
};
|
|
|
|
pub const WS_ERROR = extern struct {
|
|
placeholder: usize, // TODO: why is this type empty?
|
|
};
|
|
|
|
pub const WS_HEAP = extern struct {
|
|
placeholder: usize, // TODO: why is this type empty?
|
|
};
|
|
|
|
pub const WS_LISTENER = extern struct {
|
|
placeholder: usize, // TODO: why is this type empty?
|
|
};
|
|
|
|
pub const WS_MESSAGE = extern struct {
|
|
placeholder: usize, // TODO: why is this type empty?
|
|
};
|
|
|
|
pub const WS_SECURITY_TOKEN = extern struct {
|
|
placeholder: usize, // TODO: why is this type empty?
|
|
};
|
|
|
|
pub const WS_SECURITY_CONTEXT = extern struct {
|
|
placeholder: usize, // TODO: why is this type empty?
|
|
};
|
|
|
|
pub const WS_SERVICE_HOST = extern struct {
|
|
placeholder: usize, // TODO: why is this type empty?
|
|
};
|
|
|
|
pub const WS_SERVICE_PROXY = extern struct {
|
|
placeholder: usize, // TODO: why is this type empty?
|
|
};
|
|
|
|
pub const WS_METADATA = extern struct {
|
|
placeholder: usize, // TODO: why is this type empty?
|
|
};
|
|
|
|
pub const WS_POLICY = extern struct {
|
|
placeholder: usize, // TODO: why is this type empty?
|
|
};
|
|
|
|
pub const WS_XML_READER_PROPERTY_ID = enum(i32) {
|
|
MAX_DEPTH = 0,
|
|
ALLOW_FRAGMENT = 1,
|
|
MAX_ATTRIBUTES = 2,
|
|
READ_DECLARATION = 3,
|
|
CHARSET = 4,
|
|
ROW = 5,
|
|
COLUMN = 6,
|
|
UTF8_TRIM_SIZE = 7,
|
|
STREAM_BUFFER_SIZE = 8,
|
|
IN_ATTRIBUTE = 9,
|
|
STREAM_MAX_ROOT_MIME_PART_SIZE = 10,
|
|
STREAM_MAX_MIME_HEADERS_SIZE = 11,
|
|
MAX_MIME_PARTS = 12,
|
|
ALLOW_INVALID_CHARACTER_REFERENCES = 13,
|
|
MAX_NAMESPACES = 14,
|
|
};
|
|
pub const WS_XML_READER_PROPERTY_MAX_DEPTH = WS_XML_READER_PROPERTY_ID.MAX_DEPTH;
|
|
pub const WS_XML_READER_PROPERTY_ALLOW_FRAGMENT = WS_XML_READER_PROPERTY_ID.ALLOW_FRAGMENT;
|
|
pub const WS_XML_READER_PROPERTY_MAX_ATTRIBUTES = WS_XML_READER_PROPERTY_ID.MAX_ATTRIBUTES;
|
|
pub const WS_XML_READER_PROPERTY_READ_DECLARATION = WS_XML_READER_PROPERTY_ID.READ_DECLARATION;
|
|
pub const WS_XML_READER_PROPERTY_CHARSET = WS_XML_READER_PROPERTY_ID.CHARSET;
|
|
pub const WS_XML_READER_PROPERTY_ROW = WS_XML_READER_PROPERTY_ID.ROW;
|
|
pub const WS_XML_READER_PROPERTY_COLUMN = WS_XML_READER_PROPERTY_ID.COLUMN;
|
|
pub const WS_XML_READER_PROPERTY_UTF8_TRIM_SIZE = WS_XML_READER_PROPERTY_ID.UTF8_TRIM_SIZE;
|
|
pub const WS_XML_READER_PROPERTY_STREAM_BUFFER_SIZE = WS_XML_READER_PROPERTY_ID.STREAM_BUFFER_SIZE;
|
|
pub const WS_XML_READER_PROPERTY_IN_ATTRIBUTE = WS_XML_READER_PROPERTY_ID.IN_ATTRIBUTE;
|
|
pub const WS_XML_READER_PROPERTY_STREAM_MAX_ROOT_MIME_PART_SIZE = WS_XML_READER_PROPERTY_ID.STREAM_MAX_ROOT_MIME_PART_SIZE;
|
|
pub const WS_XML_READER_PROPERTY_STREAM_MAX_MIME_HEADERS_SIZE = WS_XML_READER_PROPERTY_ID.STREAM_MAX_MIME_HEADERS_SIZE;
|
|
pub const WS_XML_READER_PROPERTY_MAX_MIME_PARTS = WS_XML_READER_PROPERTY_ID.MAX_MIME_PARTS;
|
|
pub const WS_XML_READER_PROPERTY_ALLOW_INVALID_CHARACTER_REFERENCES = WS_XML_READER_PROPERTY_ID.ALLOW_INVALID_CHARACTER_REFERENCES;
|
|
pub const WS_XML_READER_PROPERTY_MAX_NAMESPACES = WS_XML_READER_PROPERTY_ID.MAX_NAMESPACES;
|
|
|
|
pub const WS_XML_CANONICALIZATION_ALGORITHM = enum(i32) {
|
|
EXCLUSIVE_XML_CANONICALIZATION_ALGORITHM = 0,
|
|
EXCLUSIVE_WITH_COMMENTS_XML_CANONICALIZATION_ALGORITHM = 1,
|
|
INCLUSIVE_XML_CANONICALIZATION_ALGORITHM = 2,
|
|
INCLUSIVE_WITH_COMMENTS_XML_CANONICALIZATION_ALGORITHM = 3,
|
|
};
|
|
pub const WS_EXCLUSIVE_XML_CANONICALIZATION_ALGORITHM = WS_XML_CANONICALIZATION_ALGORITHM.EXCLUSIVE_XML_CANONICALIZATION_ALGORITHM;
|
|
pub const WS_EXCLUSIVE_WITH_COMMENTS_XML_CANONICALIZATION_ALGORITHM = WS_XML_CANONICALIZATION_ALGORITHM.EXCLUSIVE_WITH_COMMENTS_XML_CANONICALIZATION_ALGORITHM;
|
|
pub const WS_INCLUSIVE_XML_CANONICALIZATION_ALGORITHM = WS_XML_CANONICALIZATION_ALGORITHM.INCLUSIVE_XML_CANONICALIZATION_ALGORITHM;
|
|
pub const WS_INCLUSIVE_WITH_COMMENTS_XML_CANONICALIZATION_ALGORITHM = WS_XML_CANONICALIZATION_ALGORITHM.INCLUSIVE_WITH_COMMENTS_XML_CANONICALIZATION_ALGORITHM;
|
|
|
|
pub const WS_XML_CANONICALIZATION_PROPERTY_ID = enum(i32) {
|
|
ALGORITHM = 0,
|
|
INCLUSIVE_PREFIXES = 1,
|
|
OMITTED_ELEMENT = 2,
|
|
OUTPUT_BUFFER_SIZE = 3,
|
|
};
|
|
pub const WS_XML_CANONICALIZATION_PROPERTY_ALGORITHM = WS_XML_CANONICALIZATION_PROPERTY_ID.ALGORITHM;
|
|
pub const WS_XML_CANONICALIZATION_PROPERTY_INCLUSIVE_PREFIXES = WS_XML_CANONICALIZATION_PROPERTY_ID.INCLUSIVE_PREFIXES;
|
|
pub const WS_XML_CANONICALIZATION_PROPERTY_OMITTED_ELEMENT = WS_XML_CANONICALIZATION_PROPERTY_ID.OMITTED_ELEMENT;
|
|
pub const WS_XML_CANONICALIZATION_PROPERTY_OUTPUT_BUFFER_SIZE = WS_XML_CANONICALIZATION_PROPERTY_ID.OUTPUT_BUFFER_SIZE;
|
|
|
|
pub const WS_XML_WRITER_PROPERTY_ID = enum(i32) {
|
|
MAX_DEPTH = 0,
|
|
ALLOW_FRAGMENT = 1,
|
|
MAX_ATTRIBUTES = 2,
|
|
WRITE_DECLARATION = 3,
|
|
INDENT = 4,
|
|
BUFFER_TRIM_SIZE = 5,
|
|
CHARSET = 6,
|
|
BUFFERS = 7,
|
|
BUFFER_MAX_SIZE = 8,
|
|
BYTES = 9,
|
|
IN_ATTRIBUTE = 10,
|
|
MAX_MIME_PARTS_BUFFER_SIZE = 11,
|
|
INITIAL_BUFFER = 12,
|
|
ALLOW_INVALID_CHARACTER_REFERENCES = 13,
|
|
MAX_NAMESPACES = 14,
|
|
BYTES_WRITTEN = 15,
|
|
BYTES_TO_CLOSE = 16,
|
|
COMPRESS_EMPTY_ELEMENTS = 17,
|
|
EMIT_UNCOMPRESSED_EMPTY_ELEMENTS = 18,
|
|
};
|
|
pub const WS_XML_WRITER_PROPERTY_MAX_DEPTH = WS_XML_WRITER_PROPERTY_ID.MAX_DEPTH;
|
|
pub const WS_XML_WRITER_PROPERTY_ALLOW_FRAGMENT = WS_XML_WRITER_PROPERTY_ID.ALLOW_FRAGMENT;
|
|
pub const WS_XML_WRITER_PROPERTY_MAX_ATTRIBUTES = WS_XML_WRITER_PROPERTY_ID.MAX_ATTRIBUTES;
|
|
pub const WS_XML_WRITER_PROPERTY_WRITE_DECLARATION = WS_XML_WRITER_PROPERTY_ID.WRITE_DECLARATION;
|
|
pub const WS_XML_WRITER_PROPERTY_INDENT = WS_XML_WRITER_PROPERTY_ID.INDENT;
|
|
pub const WS_XML_WRITER_PROPERTY_BUFFER_TRIM_SIZE = WS_XML_WRITER_PROPERTY_ID.BUFFER_TRIM_SIZE;
|
|
pub const WS_XML_WRITER_PROPERTY_CHARSET = WS_XML_WRITER_PROPERTY_ID.CHARSET;
|
|
pub const WS_XML_WRITER_PROPERTY_BUFFERS = WS_XML_WRITER_PROPERTY_ID.BUFFERS;
|
|
pub const WS_XML_WRITER_PROPERTY_BUFFER_MAX_SIZE = WS_XML_WRITER_PROPERTY_ID.BUFFER_MAX_SIZE;
|
|
pub const WS_XML_WRITER_PROPERTY_BYTES = WS_XML_WRITER_PROPERTY_ID.BYTES;
|
|
pub const WS_XML_WRITER_PROPERTY_IN_ATTRIBUTE = WS_XML_WRITER_PROPERTY_ID.IN_ATTRIBUTE;
|
|
pub const WS_XML_WRITER_PROPERTY_MAX_MIME_PARTS_BUFFER_SIZE = WS_XML_WRITER_PROPERTY_ID.MAX_MIME_PARTS_BUFFER_SIZE;
|
|
pub const WS_XML_WRITER_PROPERTY_INITIAL_BUFFER = WS_XML_WRITER_PROPERTY_ID.INITIAL_BUFFER;
|
|
pub const WS_XML_WRITER_PROPERTY_ALLOW_INVALID_CHARACTER_REFERENCES = WS_XML_WRITER_PROPERTY_ID.ALLOW_INVALID_CHARACTER_REFERENCES;
|
|
pub const WS_XML_WRITER_PROPERTY_MAX_NAMESPACES = WS_XML_WRITER_PROPERTY_ID.MAX_NAMESPACES;
|
|
pub const WS_XML_WRITER_PROPERTY_BYTES_WRITTEN = WS_XML_WRITER_PROPERTY_ID.BYTES_WRITTEN;
|
|
pub const WS_XML_WRITER_PROPERTY_BYTES_TO_CLOSE = WS_XML_WRITER_PROPERTY_ID.BYTES_TO_CLOSE;
|
|
pub const WS_XML_WRITER_PROPERTY_COMPRESS_EMPTY_ELEMENTS = WS_XML_WRITER_PROPERTY_ID.COMPRESS_EMPTY_ELEMENTS;
|
|
pub const WS_XML_WRITER_PROPERTY_EMIT_UNCOMPRESSED_EMPTY_ELEMENTS = WS_XML_WRITER_PROPERTY_ID.EMIT_UNCOMPRESSED_EMPTY_ELEMENTS;
|
|
|
|
pub const WS_XML_BUFFER_PROPERTY_ID = enum(i32) {
|
|
_
|
|
};
|
|
|
|
pub const WS_XML_TEXT_TYPE = enum(i32) {
|
|
UTF8 = 1,
|
|
UTF16 = 2,
|
|
BASE64 = 3,
|
|
BOOL = 4,
|
|
INT32 = 5,
|
|
INT64 = 6,
|
|
UINT64 = 7,
|
|
FLOAT = 8,
|
|
DOUBLE = 9,
|
|
DECIMAL = 10,
|
|
GUID = 11,
|
|
UNIQUE_ID = 12,
|
|
DATETIME = 13,
|
|
TIMESPAN = 14,
|
|
QNAME = 15,
|
|
LIST = 16,
|
|
};
|
|
pub const WS_XML_TEXT_TYPE_UTF8 = WS_XML_TEXT_TYPE.UTF8;
|
|
pub const WS_XML_TEXT_TYPE_UTF16 = WS_XML_TEXT_TYPE.UTF16;
|
|
pub const WS_XML_TEXT_TYPE_BASE64 = WS_XML_TEXT_TYPE.BASE64;
|
|
pub const WS_XML_TEXT_TYPE_BOOL = WS_XML_TEXT_TYPE.BOOL;
|
|
pub const WS_XML_TEXT_TYPE_INT32 = WS_XML_TEXT_TYPE.INT32;
|
|
pub const WS_XML_TEXT_TYPE_INT64 = WS_XML_TEXT_TYPE.INT64;
|
|
pub const WS_XML_TEXT_TYPE_UINT64 = WS_XML_TEXT_TYPE.UINT64;
|
|
pub const WS_XML_TEXT_TYPE_FLOAT = WS_XML_TEXT_TYPE.FLOAT;
|
|
pub const WS_XML_TEXT_TYPE_DOUBLE = WS_XML_TEXT_TYPE.DOUBLE;
|
|
pub const WS_XML_TEXT_TYPE_DECIMAL = WS_XML_TEXT_TYPE.DECIMAL;
|
|
pub const WS_XML_TEXT_TYPE_GUID = WS_XML_TEXT_TYPE.GUID;
|
|
pub const WS_XML_TEXT_TYPE_UNIQUE_ID = WS_XML_TEXT_TYPE.UNIQUE_ID;
|
|
pub const WS_XML_TEXT_TYPE_DATETIME = WS_XML_TEXT_TYPE.DATETIME;
|
|
pub const WS_XML_TEXT_TYPE_TIMESPAN = WS_XML_TEXT_TYPE.TIMESPAN;
|
|
pub const WS_XML_TEXT_TYPE_QNAME = WS_XML_TEXT_TYPE.QNAME;
|
|
pub const WS_XML_TEXT_TYPE_LIST = WS_XML_TEXT_TYPE.LIST;
|
|
|
|
pub const WS_XML_NODE_TYPE = enum(i32) {
|
|
ELEMENT = 1,
|
|
TEXT = 2,
|
|
END_ELEMENT = 3,
|
|
COMMENT = 4,
|
|
CDATA = 6,
|
|
END_CDATA = 7,
|
|
EOF = 8,
|
|
BOF = 9,
|
|
};
|
|
pub const WS_XML_NODE_TYPE_ELEMENT = WS_XML_NODE_TYPE.ELEMENT;
|
|
pub const WS_XML_NODE_TYPE_TEXT = WS_XML_NODE_TYPE.TEXT;
|
|
pub const WS_XML_NODE_TYPE_END_ELEMENT = WS_XML_NODE_TYPE.END_ELEMENT;
|
|
pub const WS_XML_NODE_TYPE_COMMENT = WS_XML_NODE_TYPE.COMMENT;
|
|
pub const WS_XML_NODE_TYPE_CDATA = WS_XML_NODE_TYPE.CDATA;
|
|
pub const WS_XML_NODE_TYPE_END_CDATA = WS_XML_NODE_TYPE.END_CDATA;
|
|
pub const WS_XML_NODE_TYPE_EOF = WS_XML_NODE_TYPE.EOF;
|
|
pub const WS_XML_NODE_TYPE_BOF = WS_XML_NODE_TYPE.BOF;
|
|
|
|
pub const WS_MOVE_TO = enum(i32) {
|
|
ROOT_ELEMENT = 0,
|
|
NEXT_ELEMENT = 1,
|
|
PREVIOUS_ELEMENT = 2,
|
|
CHILD_ELEMENT = 3,
|
|
END_ELEMENT = 4,
|
|
PARENT_ELEMENT = 5,
|
|
NEXT_NODE = 6,
|
|
PREVIOUS_NODE = 7,
|
|
FIRST_NODE = 8,
|
|
BOF = 9,
|
|
EOF = 10,
|
|
CHILD_NODE = 11,
|
|
};
|
|
pub const WS_MOVE_TO_ROOT_ELEMENT = WS_MOVE_TO.ROOT_ELEMENT;
|
|
pub const WS_MOVE_TO_NEXT_ELEMENT = WS_MOVE_TO.NEXT_ELEMENT;
|
|
pub const WS_MOVE_TO_PREVIOUS_ELEMENT = WS_MOVE_TO.PREVIOUS_ELEMENT;
|
|
pub const WS_MOVE_TO_CHILD_ELEMENT = WS_MOVE_TO.CHILD_ELEMENT;
|
|
pub const WS_MOVE_TO_END_ELEMENT = WS_MOVE_TO.END_ELEMENT;
|
|
pub const WS_MOVE_TO_PARENT_ELEMENT = WS_MOVE_TO.PARENT_ELEMENT;
|
|
pub const WS_MOVE_TO_NEXT_NODE = WS_MOVE_TO.NEXT_NODE;
|
|
pub const WS_MOVE_TO_PREVIOUS_NODE = WS_MOVE_TO.PREVIOUS_NODE;
|
|
pub const WS_MOVE_TO_FIRST_NODE = WS_MOVE_TO.FIRST_NODE;
|
|
pub const WS_MOVE_TO_BOF = WS_MOVE_TO.BOF;
|
|
pub const WS_MOVE_TO_EOF = WS_MOVE_TO.EOF;
|
|
pub const WS_MOVE_TO_CHILD_NODE = WS_MOVE_TO.CHILD_NODE;
|
|
|
|
pub const WS_VALUE_TYPE = enum(i32) {
|
|
BOOL_VALUE_TYPE = 0,
|
|
INT8_VALUE_TYPE = 1,
|
|
INT16_VALUE_TYPE = 2,
|
|
INT32_VALUE_TYPE = 3,
|
|
INT64_VALUE_TYPE = 4,
|
|
UINT8_VALUE_TYPE = 5,
|
|
UINT16_VALUE_TYPE = 6,
|
|
UINT32_VALUE_TYPE = 7,
|
|
UINT64_VALUE_TYPE = 8,
|
|
FLOAT_VALUE_TYPE = 9,
|
|
DOUBLE_VALUE_TYPE = 10,
|
|
DECIMAL_VALUE_TYPE = 11,
|
|
DATETIME_VALUE_TYPE = 12,
|
|
TIMESPAN_VALUE_TYPE = 13,
|
|
GUID_VALUE_TYPE = 14,
|
|
DURATION_VALUE_TYPE = 15,
|
|
};
|
|
pub const WS_BOOL_VALUE_TYPE = WS_VALUE_TYPE.BOOL_VALUE_TYPE;
|
|
pub const WS_INT8_VALUE_TYPE = WS_VALUE_TYPE.INT8_VALUE_TYPE;
|
|
pub const WS_INT16_VALUE_TYPE = WS_VALUE_TYPE.INT16_VALUE_TYPE;
|
|
pub const WS_INT32_VALUE_TYPE = WS_VALUE_TYPE.INT32_VALUE_TYPE;
|
|
pub const WS_INT64_VALUE_TYPE = WS_VALUE_TYPE.INT64_VALUE_TYPE;
|
|
pub const WS_UINT8_VALUE_TYPE = WS_VALUE_TYPE.UINT8_VALUE_TYPE;
|
|
pub const WS_UINT16_VALUE_TYPE = WS_VALUE_TYPE.UINT16_VALUE_TYPE;
|
|
pub const WS_UINT32_VALUE_TYPE = WS_VALUE_TYPE.UINT32_VALUE_TYPE;
|
|
pub const WS_UINT64_VALUE_TYPE = WS_VALUE_TYPE.UINT64_VALUE_TYPE;
|
|
pub const WS_FLOAT_VALUE_TYPE = WS_VALUE_TYPE.FLOAT_VALUE_TYPE;
|
|
pub const WS_DOUBLE_VALUE_TYPE = WS_VALUE_TYPE.DOUBLE_VALUE_TYPE;
|
|
pub const WS_DECIMAL_VALUE_TYPE = WS_VALUE_TYPE.DECIMAL_VALUE_TYPE;
|
|
pub const WS_DATETIME_VALUE_TYPE = WS_VALUE_TYPE.DATETIME_VALUE_TYPE;
|
|
pub const WS_TIMESPAN_VALUE_TYPE = WS_VALUE_TYPE.TIMESPAN_VALUE_TYPE;
|
|
pub const WS_GUID_VALUE_TYPE = WS_VALUE_TYPE.GUID_VALUE_TYPE;
|
|
pub const WS_DURATION_VALUE_TYPE = WS_VALUE_TYPE.DURATION_VALUE_TYPE;
|
|
|
|
pub const WS_XML_READER_INPUT_TYPE = enum(i32) {
|
|
BUFFER = 1,
|
|
STREAM = 2,
|
|
};
|
|
pub const WS_XML_READER_INPUT_TYPE_BUFFER = WS_XML_READER_INPUT_TYPE.BUFFER;
|
|
pub const WS_XML_READER_INPUT_TYPE_STREAM = WS_XML_READER_INPUT_TYPE.STREAM;
|
|
|
|
pub const WS_XML_READER_ENCODING_TYPE = enum(i32) {
|
|
TEXT = 1,
|
|
BINARY = 2,
|
|
MTOM = 3,
|
|
RAW = 4,
|
|
};
|
|
pub const WS_XML_READER_ENCODING_TYPE_TEXT = WS_XML_READER_ENCODING_TYPE.TEXT;
|
|
pub const WS_XML_READER_ENCODING_TYPE_BINARY = WS_XML_READER_ENCODING_TYPE.BINARY;
|
|
pub const WS_XML_READER_ENCODING_TYPE_MTOM = WS_XML_READER_ENCODING_TYPE.MTOM;
|
|
pub const WS_XML_READER_ENCODING_TYPE_RAW = WS_XML_READER_ENCODING_TYPE.RAW;
|
|
|
|
pub const WS_CHARSET = enum(i32) {
|
|
AUTO = 0,
|
|
UTF8 = 1,
|
|
UTF16LE = 2,
|
|
UTF16BE = 3,
|
|
};
|
|
pub const WS_CHARSET_AUTO = WS_CHARSET.AUTO;
|
|
pub const WS_CHARSET_UTF8 = WS_CHARSET.UTF8;
|
|
pub const WS_CHARSET_UTF16LE = WS_CHARSET.UTF16LE;
|
|
pub const WS_CHARSET_UTF16BE = WS_CHARSET.UTF16BE;
|
|
|
|
pub const WS_XML_WRITER_ENCODING_TYPE = enum(i32) {
|
|
TEXT = 1,
|
|
BINARY = 2,
|
|
MTOM = 3,
|
|
RAW = 4,
|
|
};
|
|
pub const WS_XML_WRITER_ENCODING_TYPE_TEXT = WS_XML_WRITER_ENCODING_TYPE.TEXT;
|
|
pub const WS_XML_WRITER_ENCODING_TYPE_BINARY = WS_XML_WRITER_ENCODING_TYPE.BINARY;
|
|
pub const WS_XML_WRITER_ENCODING_TYPE_MTOM = WS_XML_WRITER_ENCODING_TYPE.MTOM;
|
|
pub const WS_XML_WRITER_ENCODING_TYPE_RAW = WS_XML_WRITER_ENCODING_TYPE.RAW;
|
|
|
|
pub const WS_XML_WRITER_OUTPUT_TYPE = enum(i32) {
|
|
BUFFER = 1,
|
|
STREAM = 2,
|
|
};
|
|
pub const WS_XML_WRITER_OUTPUT_TYPE_BUFFER = WS_XML_WRITER_OUTPUT_TYPE.BUFFER;
|
|
pub const WS_XML_WRITER_OUTPUT_TYPE_STREAM = WS_XML_WRITER_OUTPUT_TYPE.STREAM;
|
|
|
|
pub const WS_CALLBACK_MODEL = enum(i32) {
|
|
SHORT_CALLBACK = 0,
|
|
LONG_CALLBACK = 1,
|
|
};
|
|
pub const WS_SHORT_CALLBACK = WS_CALLBACK_MODEL.SHORT_CALLBACK;
|
|
pub const WS_LONG_CALLBACK = WS_CALLBACK_MODEL.LONG_CALLBACK;
|
|
|
|
pub const WS_ENCODING = enum(i32) {
|
|
XML_BINARY_1 = 0,
|
|
XML_BINARY_SESSION_1 = 1,
|
|
XML_MTOM_UTF8 = 2,
|
|
XML_MTOM_UTF16BE = 3,
|
|
XML_MTOM_UTF16LE = 4,
|
|
XML_UTF8 = 5,
|
|
XML_UTF16BE = 6,
|
|
XML_UTF16LE = 7,
|
|
RAW = 8,
|
|
};
|
|
pub const WS_ENCODING_XML_BINARY_1 = WS_ENCODING.XML_BINARY_1;
|
|
pub const WS_ENCODING_XML_BINARY_SESSION_1 = WS_ENCODING.XML_BINARY_SESSION_1;
|
|
pub const WS_ENCODING_XML_MTOM_UTF8 = WS_ENCODING.XML_MTOM_UTF8;
|
|
pub const WS_ENCODING_XML_MTOM_UTF16BE = WS_ENCODING.XML_MTOM_UTF16BE;
|
|
pub const WS_ENCODING_XML_MTOM_UTF16LE = WS_ENCODING.XML_MTOM_UTF16LE;
|
|
pub const WS_ENCODING_XML_UTF8 = WS_ENCODING.XML_UTF8;
|
|
pub const WS_ENCODING_XML_UTF16BE = WS_ENCODING.XML_UTF16BE;
|
|
pub const WS_ENCODING_XML_UTF16LE = WS_ENCODING.XML_UTF16LE;
|
|
pub const WS_ENCODING_RAW = WS_ENCODING.RAW;
|
|
|
|
pub const WS_CHANNEL_STATE = enum(i32) {
|
|
CREATED = 0,
|
|
OPENING = 1,
|
|
ACCEPTING = 2,
|
|
OPEN = 3,
|
|
FAULTED = 4,
|
|
CLOSING = 5,
|
|
CLOSED = 6,
|
|
};
|
|
pub const WS_CHANNEL_STATE_CREATED = WS_CHANNEL_STATE.CREATED;
|
|
pub const WS_CHANNEL_STATE_OPENING = WS_CHANNEL_STATE.OPENING;
|
|
pub const WS_CHANNEL_STATE_ACCEPTING = WS_CHANNEL_STATE.ACCEPTING;
|
|
pub const WS_CHANNEL_STATE_OPEN = WS_CHANNEL_STATE.OPEN;
|
|
pub const WS_CHANNEL_STATE_FAULTED = WS_CHANNEL_STATE.FAULTED;
|
|
pub const WS_CHANNEL_STATE_CLOSING = WS_CHANNEL_STATE.CLOSING;
|
|
pub const WS_CHANNEL_STATE_CLOSED = WS_CHANNEL_STATE.CLOSED;
|
|
|
|
pub const WS_RECEIVE_OPTION = enum(i32) {
|
|
REQUIRED_MESSAGE = 1,
|
|
OPTIONAL_MESSAGE = 2,
|
|
};
|
|
pub const WS_RECEIVE_REQUIRED_MESSAGE = WS_RECEIVE_OPTION.REQUIRED_MESSAGE;
|
|
pub const WS_RECEIVE_OPTIONAL_MESSAGE = WS_RECEIVE_OPTION.OPTIONAL_MESSAGE;
|
|
|
|
pub const WS_CHANNEL_BINDING = enum(i32) {
|
|
HTTP_CHANNEL_BINDING = 0,
|
|
TCP_CHANNEL_BINDING = 1,
|
|
UDP_CHANNEL_BINDING = 2,
|
|
CUSTOM_CHANNEL_BINDING = 3,
|
|
NAMEDPIPE_CHANNEL_BINDING = 4,
|
|
};
|
|
pub const WS_HTTP_CHANNEL_BINDING = WS_CHANNEL_BINDING.HTTP_CHANNEL_BINDING;
|
|
pub const WS_TCP_CHANNEL_BINDING = WS_CHANNEL_BINDING.TCP_CHANNEL_BINDING;
|
|
pub const WS_UDP_CHANNEL_BINDING = WS_CHANNEL_BINDING.UDP_CHANNEL_BINDING;
|
|
pub const WS_CUSTOM_CHANNEL_BINDING = WS_CHANNEL_BINDING.CUSTOM_CHANNEL_BINDING;
|
|
pub const WS_NAMEDPIPE_CHANNEL_BINDING = WS_CHANNEL_BINDING.NAMEDPIPE_CHANNEL_BINDING;
|
|
|
|
pub const WS_CHANNEL_TYPE = enum(i32) {
|
|
INPUT = 1,
|
|
OUTPUT = 2,
|
|
SESSION = 4,
|
|
INPUT_SESSION = 5,
|
|
OUTPUT_SESSION = 6,
|
|
DUPLEX = 3,
|
|
DUPLEX_SESSION = 7,
|
|
REQUEST = 8,
|
|
REPLY = 16,
|
|
};
|
|
pub const WS_CHANNEL_TYPE_INPUT = WS_CHANNEL_TYPE.INPUT;
|
|
pub const WS_CHANNEL_TYPE_OUTPUT = WS_CHANNEL_TYPE.OUTPUT;
|
|
pub const WS_CHANNEL_TYPE_SESSION = WS_CHANNEL_TYPE.SESSION;
|
|
pub const WS_CHANNEL_TYPE_INPUT_SESSION = WS_CHANNEL_TYPE.INPUT_SESSION;
|
|
pub const WS_CHANNEL_TYPE_OUTPUT_SESSION = WS_CHANNEL_TYPE.OUTPUT_SESSION;
|
|
pub const WS_CHANNEL_TYPE_DUPLEX = WS_CHANNEL_TYPE.DUPLEX;
|
|
pub const WS_CHANNEL_TYPE_DUPLEX_SESSION = WS_CHANNEL_TYPE.DUPLEX_SESSION;
|
|
pub const WS_CHANNEL_TYPE_REQUEST = WS_CHANNEL_TYPE.REQUEST;
|
|
pub const WS_CHANNEL_TYPE_REPLY = WS_CHANNEL_TYPE.REPLY;
|
|
|
|
pub const WS_TRANSFER_MODE = enum(i32) {
|
|
STREAMED_INPUT_TRANSFER_MODE = 1,
|
|
STREAMED_OUTPUT_TRANSFER_MODE = 2,
|
|
BUFFERED_TRANSFER_MODE = 0,
|
|
STREAMED_TRANSFER_MODE = 3,
|
|
};
|
|
pub const WS_STREAMED_INPUT_TRANSFER_MODE = WS_TRANSFER_MODE.STREAMED_INPUT_TRANSFER_MODE;
|
|
pub const WS_STREAMED_OUTPUT_TRANSFER_MODE = WS_TRANSFER_MODE.STREAMED_OUTPUT_TRANSFER_MODE;
|
|
pub const WS_BUFFERED_TRANSFER_MODE = WS_TRANSFER_MODE.BUFFERED_TRANSFER_MODE;
|
|
pub const WS_STREAMED_TRANSFER_MODE = WS_TRANSFER_MODE.STREAMED_TRANSFER_MODE;
|
|
|
|
pub const WS_HTTP_PROXY_SETTING_MODE = enum(i32) {
|
|
AUTO = 1,
|
|
NONE = 2,
|
|
CUSTOM = 3,
|
|
};
|
|
pub const WS_HTTP_PROXY_SETTING_MODE_AUTO = WS_HTTP_PROXY_SETTING_MODE.AUTO;
|
|
pub const WS_HTTP_PROXY_SETTING_MODE_NONE = WS_HTTP_PROXY_SETTING_MODE.NONE;
|
|
pub const WS_HTTP_PROXY_SETTING_MODE_CUSTOM = WS_HTTP_PROXY_SETTING_MODE.CUSTOM;
|
|
|
|
pub const WS_CHANNEL_PROPERTY_ID = enum(i32) {
|
|
MAX_BUFFERED_MESSAGE_SIZE = 0,
|
|
MAX_STREAMED_MESSAGE_SIZE = 1,
|
|
MAX_STREAMED_START_SIZE = 2,
|
|
MAX_STREAMED_FLUSH_SIZE = 3,
|
|
ENCODING = 4,
|
|
ENVELOPE_VERSION = 5,
|
|
ADDRESSING_VERSION = 6,
|
|
MAX_SESSION_DICTIONARY_SIZE = 7,
|
|
STATE = 8,
|
|
ASYNC_CALLBACK_MODEL = 9,
|
|
IP_VERSION = 10,
|
|
RESOLVE_TIMEOUT = 11,
|
|
CONNECT_TIMEOUT = 12,
|
|
SEND_TIMEOUT = 13,
|
|
RECEIVE_RESPONSE_TIMEOUT = 14,
|
|
RECEIVE_TIMEOUT = 15,
|
|
CLOSE_TIMEOUT = 16,
|
|
ENABLE_TIMEOUTS = 17,
|
|
TRANSFER_MODE = 18,
|
|
MULTICAST_INTERFACE = 19,
|
|
MULTICAST_HOPS = 20,
|
|
REMOTE_ADDRESS = 21,
|
|
REMOTE_IP_ADDRESS = 22,
|
|
HTTP_CONNECTION_ID = 23,
|
|
CUSTOM_CHANNEL_CALLBACKS = 24,
|
|
CUSTOM_CHANNEL_PARAMETERS = 25,
|
|
CUSTOM_CHANNEL_INSTANCE = 26,
|
|
TRANSPORT_URL = 27,
|
|
NO_DELAY = 28,
|
|
SEND_KEEP_ALIVES = 29,
|
|
KEEP_ALIVE_TIME = 30,
|
|
KEEP_ALIVE_INTERVAL = 31,
|
|
MAX_HTTP_SERVER_CONNECTIONS = 32,
|
|
IS_SESSION_SHUT_DOWN = 33,
|
|
CHANNEL_TYPE = 34,
|
|
TRIM_BUFFERED_MESSAGE_SIZE = 35,
|
|
ENCODER = 36,
|
|
DECODER = 37,
|
|
PROTECTION_LEVEL = 38,
|
|
COOKIE_MODE = 39,
|
|
HTTP_PROXY_SETTING_MODE = 40,
|
|
CUSTOM_HTTP_PROXY = 41,
|
|
HTTP_MESSAGE_MAPPING = 42,
|
|
ENABLE_HTTP_REDIRECT = 43,
|
|
HTTP_REDIRECT_CALLBACK_CONTEXT = 44,
|
|
FAULTS_AS_ERRORS = 45,
|
|
ALLOW_UNSECURED_FAULTS = 46,
|
|
HTTP_SERVER_SPN = 47,
|
|
HTTP_PROXY_SPN = 48,
|
|
MAX_HTTP_REQUEST_HEADERS_BUFFER_SIZE = 49,
|
|
};
|
|
pub const WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE = WS_CHANNEL_PROPERTY_ID.MAX_BUFFERED_MESSAGE_SIZE;
|
|
pub const WS_CHANNEL_PROPERTY_MAX_STREAMED_MESSAGE_SIZE = WS_CHANNEL_PROPERTY_ID.MAX_STREAMED_MESSAGE_SIZE;
|
|
pub const WS_CHANNEL_PROPERTY_MAX_STREAMED_START_SIZE = WS_CHANNEL_PROPERTY_ID.MAX_STREAMED_START_SIZE;
|
|
pub const WS_CHANNEL_PROPERTY_MAX_STREAMED_FLUSH_SIZE = WS_CHANNEL_PROPERTY_ID.MAX_STREAMED_FLUSH_SIZE;
|
|
pub const WS_CHANNEL_PROPERTY_ENCODING = WS_CHANNEL_PROPERTY_ID.ENCODING;
|
|
pub const WS_CHANNEL_PROPERTY_ENVELOPE_VERSION = WS_CHANNEL_PROPERTY_ID.ENVELOPE_VERSION;
|
|
pub const WS_CHANNEL_PROPERTY_ADDRESSING_VERSION = WS_CHANNEL_PROPERTY_ID.ADDRESSING_VERSION;
|
|
pub const WS_CHANNEL_PROPERTY_MAX_SESSION_DICTIONARY_SIZE = WS_CHANNEL_PROPERTY_ID.MAX_SESSION_DICTIONARY_SIZE;
|
|
pub const WS_CHANNEL_PROPERTY_STATE = WS_CHANNEL_PROPERTY_ID.STATE;
|
|
pub const WS_CHANNEL_PROPERTY_ASYNC_CALLBACK_MODEL = WS_CHANNEL_PROPERTY_ID.ASYNC_CALLBACK_MODEL;
|
|
pub const WS_CHANNEL_PROPERTY_IP_VERSION = WS_CHANNEL_PROPERTY_ID.IP_VERSION;
|
|
pub const WS_CHANNEL_PROPERTY_RESOLVE_TIMEOUT = WS_CHANNEL_PROPERTY_ID.RESOLVE_TIMEOUT;
|
|
pub const WS_CHANNEL_PROPERTY_CONNECT_TIMEOUT = WS_CHANNEL_PROPERTY_ID.CONNECT_TIMEOUT;
|
|
pub const WS_CHANNEL_PROPERTY_SEND_TIMEOUT = WS_CHANNEL_PROPERTY_ID.SEND_TIMEOUT;
|
|
pub const WS_CHANNEL_PROPERTY_RECEIVE_RESPONSE_TIMEOUT = WS_CHANNEL_PROPERTY_ID.RECEIVE_RESPONSE_TIMEOUT;
|
|
pub const WS_CHANNEL_PROPERTY_RECEIVE_TIMEOUT = WS_CHANNEL_PROPERTY_ID.RECEIVE_TIMEOUT;
|
|
pub const WS_CHANNEL_PROPERTY_CLOSE_TIMEOUT = WS_CHANNEL_PROPERTY_ID.CLOSE_TIMEOUT;
|
|
pub const WS_CHANNEL_PROPERTY_ENABLE_TIMEOUTS = WS_CHANNEL_PROPERTY_ID.ENABLE_TIMEOUTS;
|
|
pub const WS_CHANNEL_PROPERTY_TRANSFER_MODE = WS_CHANNEL_PROPERTY_ID.TRANSFER_MODE;
|
|
pub const WS_CHANNEL_PROPERTY_MULTICAST_INTERFACE = WS_CHANNEL_PROPERTY_ID.MULTICAST_INTERFACE;
|
|
pub const WS_CHANNEL_PROPERTY_MULTICAST_HOPS = WS_CHANNEL_PROPERTY_ID.MULTICAST_HOPS;
|
|
pub const WS_CHANNEL_PROPERTY_REMOTE_ADDRESS = WS_CHANNEL_PROPERTY_ID.REMOTE_ADDRESS;
|
|
pub const WS_CHANNEL_PROPERTY_REMOTE_IP_ADDRESS = WS_CHANNEL_PROPERTY_ID.REMOTE_IP_ADDRESS;
|
|
pub const WS_CHANNEL_PROPERTY_HTTP_CONNECTION_ID = WS_CHANNEL_PROPERTY_ID.HTTP_CONNECTION_ID;
|
|
pub const WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_CALLBACKS = WS_CHANNEL_PROPERTY_ID.CUSTOM_CHANNEL_CALLBACKS;
|
|
pub const WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_PARAMETERS = WS_CHANNEL_PROPERTY_ID.CUSTOM_CHANNEL_PARAMETERS;
|
|
pub const WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_INSTANCE = WS_CHANNEL_PROPERTY_ID.CUSTOM_CHANNEL_INSTANCE;
|
|
pub const WS_CHANNEL_PROPERTY_TRANSPORT_URL = WS_CHANNEL_PROPERTY_ID.TRANSPORT_URL;
|
|
pub const WS_CHANNEL_PROPERTY_NO_DELAY = WS_CHANNEL_PROPERTY_ID.NO_DELAY;
|
|
pub const WS_CHANNEL_PROPERTY_SEND_KEEP_ALIVES = WS_CHANNEL_PROPERTY_ID.SEND_KEEP_ALIVES;
|
|
pub const WS_CHANNEL_PROPERTY_KEEP_ALIVE_TIME = WS_CHANNEL_PROPERTY_ID.KEEP_ALIVE_TIME;
|
|
pub const WS_CHANNEL_PROPERTY_KEEP_ALIVE_INTERVAL = WS_CHANNEL_PROPERTY_ID.KEEP_ALIVE_INTERVAL;
|
|
pub const WS_CHANNEL_PROPERTY_MAX_HTTP_SERVER_CONNECTIONS = WS_CHANNEL_PROPERTY_ID.MAX_HTTP_SERVER_CONNECTIONS;
|
|
pub const WS_CHANNEL_PROPERTY_IS_SESSION_SHUT_DOWN = WS_CHANNEL_PROPERTY_ID.IS_SESSION_SHUT_DOWN;
|
|
pub const WS_CHANNEL_PROPERTY_CHANNEL_TYPE = WS_CHANNEL_PROPERTY_ID.CHANNEL_TYPE;
|
|
pub const WS_CHANNEL_PROPERTY_TRIM_BUFFERED_MESSAGE_SIZE = WS_CHANNEL_PROPERTY_ID.TRIM_BUFFERED_MESSAGE_SIZE;
|
|
pub const WS_CHANNEL_PROPERTY_ENCODER = WS_CHANNEL_PROPERTY_ID.ENCODER;
|
|
pub const WS_CHANNEL_PROPERTY_DECODER = WS_CHANNEL_PROPERTY_ID.DECODER;
|
|
pub const WS_CHANNEL_PROPERTY_PROTECTION_LEVEL = WS_CHANNEL_PROPERTY_ID.PROTECTION_LEVEL;
|
|
pub const WS_CHANNEL_PROPERTY_COOKIE_MODE = WS_CHANNEL_PROPERTY_ID.COOKIE_MODE;
|
|
pub const WS_CHANNEL_PROPERTY_HTTP_PROXY_SETTING_MODE = WS_CHANNEL_PROPERTY_ID.HTTP_PROXY_SETTING_MODE;
|
|
pub const WS_CHANNEL_PROPERTY_CUSTOM_HTTP_PROXY = WS_CHANNEL_PROPERTY_ID.CUSTOM_HTTP_PROXY;
|
|
pub const WS_CHANNEL_PROPERTY_HTTP_MESSAGE_MAPPING = WS_CHANNEL_PROPERTY_ID.HTTP_MESSAGE_MAPPING;
|
|
pub const WS_CHANNEL_PROPERTY_ENABLE_HTTP_REDIRECT = WS_CHANNEL_PROPERTY_ID.ENABLE_HTTP_REDIRECT;
|
|
pub const WS_CHANNEL_PROPERTY_HTTP_REDIRECT_CALLBACK_CONTEXT = WS_CHANNEL_PROPERTY_ID.HTTP_REDIRECT_CALLBACK_CONTEXT;
|
|
pub const WS_CHANNEL_PROPERTY_FAULTS_AS_ERRORS = WS_CHANNEL_PROPERTY_ID.FAULTS_AS_ERRORS;
|
|
pub const WS_CHANNEL_PROPERTY_ALLOW_UNSECURED_FAULTS = WS_CHANNEL_PROPERTY_ID.ALLOW_UNSECURED_FAULTS;
|
|
pub const WS_CHANNEL_PROPERTY_HTTP_SERVER_SPN = WS_CHANNEL_PROPERTY_ID.HTTP_SERVER_SPN;
|
|
pub const WS_CHANNEL_PROPERTY_HTTP_PROXY_SPN = WS_CHANNEL_PROPERTY_ID.HTTP_PROXY_SPN;
|
|
pub const WS_CHANNEL_PROPERTY_MAX_HTTP_REQUEST_HEADERS_BUFFER_SIZE = WS_CHANNEL_PROPERTY_ID.MAX_HTTP_REQUEST_HEADERS_BUFFER_SIZE;
|
|
|
|
pub const WS_COOKIE_MODE = enum(i32) {
|
|
MANUAL_COOKIE_MODE = 1,
|
|
AUTO_COOKIE_MODE = 2,
|
|
};
|
|
pub const WS_MANUAL_COOKIE_MODE = WS_COOKIE_MODE.MANUAL_COOKIE_MODE;
|
|
pub const WS_AUTO_COOKIE_MODE = WS_COOKIE_MODE.AUTO_COOKIE_MODE;
|
|
|
|
pub const WS_OPERATION_CONTEXT_PROPERTY_ID = enum(i32) {
|
|
CHANNEL = 0,
|
|
CONTRACT_DESCRIPTION = 1,
|
|
HOST_USER_STATE = 2,
|
|
CHANNEL_USER_STATE = 3,
|
|
INPUT_MESSAGE = 4,
|
|
OUTPUT_MESSAGE = 5,
|
|
HEAP = 6,
|
|
LISTENER = 7,
|
|
ENDPOINT_ADDRESS = 8,
|
|
};
|
|
pub const WS_OPERATION_CONTEXT_PROPERTY_CHANNEL = WS_OPERATION_CONTEXT_PROPERTY_ID.CHANNEL;
|
|
pub const WS_OPERATION_CONTEXT_PROPERTY_CONTRACT_DESCRIPTION = WS_OPERATION_CONTEXT_PROPERTY_ID.CONTRACT_DESCRIPTION;
|
|
pub const WS_OPERATION_CONTEXT_PROPERTY_HOST_USER_STATE = WS_OPERATION_CONTEXT_PROPERTY_ID.HOST_USER_STATE;
|
|
pub const WS_OPERATION_CONTEXT_PROPERTY_CHANNEL_USER_STATE = WS_OPERATION_CONTEXT_PROPERTY_ID.CHANNEL_USER_STATE;
|
|
pub const WS_OPERATION_CONTEXT_PROPERTY_INPUT_MESSAGE = WS_OPERATION_CONTEXT_PROPERTY_ID.INPUT_MESSAGE;
|
|
pub const WS_OPERATION_CONTEXT_PROPERTY_OUTPUT_MESSAGE = WS_OPERATION_CONTEXT_PROPERTY_ID.OUTPUT_MESSAGE;
|
|
pub const WS_OPERATION_CONTEXT_PROPERTY_HEAP = WS_OPERATION_CONTEXT_PROPERTY_ID.HEAP;
|
|
pub const WS_OPERATION_CONTEXT_PROPERTY_LISTENER = WS_OPERATION_CONTEXT_PROPERTY_ID.LISTENER;
|
|
pub const WS_OPERATION_CONTEXT_PROPERTY_ENDPOINT_ADDRESS = WS_OPERATION_CONTEXT_PROPERTY_ID.ENDPOINT_ADDRESS;
|
|
|
|
pub const WS_ENDPOINT_IDENTITY_TYPE = enum(i32) {
|
|
DNS_ENDPOINT_IDENTITY_TYPE = 1,
|
|
UPN_ENDPOINT_IDENTITY_TYPE = 2,
|
|
SPN_ENDPOINT_IDENTITY_TYPE = 3,
|
|
RSA_ENDPOINT_IDENTITY_TYPE = 4,
|
|
CERT_ENDPOINT_IDENTITY_TYPE = 5,
|
|
UNKNOWN_ENDPOINT_IDENTITY_TYPE = 6,
|
|
};
|
|
pub const WS_DNS_ENDPOINT_IDENTITY_TYPE = WS_ENDPOINT_IDENTITY_TYPE.DNS_ENDPOINT_IDENTITY_TYPE;
|
|
pub const WS_UPN_ENDPOINT_IDENTITY_TYPE = WS_ENDPOINT_IDENTITY_TYPE.UPN_ENDPOINT_IDENTITY_TYPE;
|
|
pub const WS_SPN_ENDPOINT_IDENTITY_TYPE = WS_ENDPOINT_IDENTITY_TYPE.SPN_ENDPOINT_IDENTITY_TYPE;
|
|
pub const WS_RSA_ENDPOINT_IDENTITY_TYPE = WS_ENDPOINT_IDENTITY_TYPE.RSA_ENDPOINT_IDENTITY_TYPE;
|
|
pub const WS_CERT_ENDPOINT_IDENTITY_TYPE = WS_ENDPOINT_IDENTITY_TYPE.CERT_ENDPOINT_IDENTITY_TYPE;
|
|
pub const WS_UNKNOWN_ENDPOINT_IDENTITY_TYPE = WS_ENDPOINT_IDENTITY_TYPE.UNKNOWN_ENDPOINT_IDENTITY_TYPE;
|
|
|
|
pub const WS_ENDPOINT_ADDRESS_EXTENSION_TYPE = enum(i32) {
|
|
S = 1,
|
|
};
|
|
pub const WS_ENDPOINT_ADDRESS_EXTENSION_METADATA_ADDRESS = WS_ENDPOINT_ADDRESS_EXTENSION_TYPE.S;
|
|
|
|
pub const WS_ERROR_PROPERTY_ID = enum(i32) {
|
|
STRING_COUNT = 0,
|
|
ORIGINAL_ERROR_CODE = 1,
|
|
LANGID = 2,
|
|
};
|
|
pub const WS_ERROR_PROPERTY_STRING_COUNT = WS_ERROR_PROPERTY_ID.STRING_COUNT;
|
|
pub const WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE = WS_ERROR_PROPERTY_ID.ORIGINAL_ERROR_CODE;
|
|
pub const WS_ERROR_PROPERTY_LANGID = WS_ERROR_PROPERTY_ID.LANGID;
|
|
|
|
pub const WS_EXCEPTION_CODE = enum(i32) {
|
|
USAGE_FAILURE = -1069744128,
|
|
INTERNAL_FAILURE = -1069744127,
|
|
};
|
|
pub const WS_EXCEPTION_CODE_USAGE_FAILURE = WS_EXCEPTION_CODE.USAGE_FAILURE;
|
|
pub const WS_EXCEPTION_CODE_INTERNAL_FAILURE = WS_EXCEPTION_CODE.INTERNAL_FAILURE;
|
|
|
|
pub const WS_FAULT_ERROR_PROPERTY_ID = enum(i32) {
|
|
FAULT = 0,
|
|
ACTION = 1,
|
|
HEADER = 2,
|
|
};
|
|
pub const WS_FAULT_ERROR_PROPERTY_FAULT = WS_FAULT_ERROR_PROPERTY_ID.FAULT;
|
|
pub const WS_FAULT_ERROR_PROPERTY_ACTION = WS_FAULT_ERROR_PROPERTY_ID.ACTION;
|
|
pub const WS_FAULT_ERROR_PROPERTY_HEADER = WS_FAULT_ERROR_PROPERTY_ID.HEADER;
|
|
|
|
pub const WS_FAULT_DISCLOSURE = enum(i32) {
|
|
MINIMAL_FAULT_DISCLOSURE = 0,
|
|
FULL_FAULT_DISCLOSURE = 1,
|
|
};
|
|
pub const WS_MINIMAL_FAULT_DISCLOSURE = WS_FAULT_DISCLOSURE.MINIMAL_FAULT_DISCLOSURE;
|
|
pub const WS_FULL_FAULT_DISCLOSURE = WS_FAULT_DISCLOSURE.FULL_FAULT_DISCLOSURE;
|
|
|
|
pub const WS_HEAP_PROPERTY_ID = enum(i32) {
|
|
MAX_SIZE = 0,
|
|
TRIM_SIZE = 1,
|
|
REQUESTED_SIZE = 2,
|
|
ACTUAL_SIZE = 3,
|
|
};
|
|
pub const WS_HEAP_PROPERTY_MAX_SIZE = WS_HEAP_PROPERTY_ID.MAX_SIZE;
|
|
pub const WS_HEAP_PROPERTY_TRIM_SIZE = WS_HEAP_PROPERTY_ID.TRIM_SIZE;
|
|
pub const WS_HEAP_PROPERTY_REQUESTED_SIZE = WS_HEAP_PROPERTY_ID.REQUESTED_SIZE;
|
|
pub const WS_HEAP_PROPERTY_ACTUAL_SIZE = WS_HEAP_PROPERTY_ID.ACTUAL_SIZE;
|
|
|
|
pub const WS_LISTENER_STATE = enum(i32) {
|
|
CREATED = 0,
|
|
OPENING = 1,
|
|
OPEN = 2,
|
|
FAULTED = 3,
|
|
CLOSING = 4,
|
|
CLOSED = 5,
|
|
};
|
|
pub const WS_LISTENER_STATE_CREATED = WS_LISTENER_STATE.CREATED;
|
|
pub const WS_LISTENER_STATE_OPENING = WS_LISTENER_STATE.OPENING;
|
|
pub const WS_LISTENER_STATE_OPEN = WS_LISTENER_STATE.OPEN;
|
|
pub const WS_LISTENER_STATE_FAULTED = WS_LISTENER_STATE.FAULTED;
|
|
pub const WS_LISTENER_STATE_CLOSING = WS_LISTENER_STATE.CLOSING;
|
|
pub const WS_LISTENER_STATE_CLOSED = WS_LISTENER_STATE.CLOSED;
|
|
|
|
pub const WS_LISTENER_PROPERTY_ID = enum(i32) {
|
|
LISTEN_BACKLOG = 0,
|
|
IP_VERSION = 1,
|
|
STATE = 2,
|
|
ASYNC_CALLBACK_MODEL = 3,
|
|
CHANNEL_TYPE = 4,
|
|
CHANNEL_BINDING = 5,
|
|
CONNECT_TIMEOUT = 6,
|
|
IS_MULTICAST = 7,
|
|
MULTICAST_INTERFACES = 8,
|
|
MULTICAST_LOOPBACK = 9,
|
|
CLOSE_TIMEOUT = 10,
|
|
TO_HEADER_MATCHING_OPTIONS = 11,
|
|
TRANSPORT_URL_MATCHING_OPTIONS = 12,
|
|
CUSTOM_LISTENER_CALLBACKS = 13,
|
|
CUSTOM_LISTENER_PARAMETERS = 14,
|
|
CUSTOM_LISTENER_INSTANCE = 15,
|
|
DISALLOWED_USER_AGENT = 16,
|
|
};
|
|
pub const WS_LISTENER_PROPERTY_LISTEN_BACKLOG = WS_LISTENER_PROPERTY_ID.LISTEN_BACKLOG;
|
|
pub const WS_LISTENER_PROPERTY_IP_VERSION = WS_LISTENER_PROPERTY_ID.IP_VERSION;
|
|
pub const WS_LISTENER_PROPERTY_STATE = WS_LISTENER_PROPERTY_ID.STATE;
|
|
pub const WS_LISTENER_PROPERTY_ASYNC_CALLBACK_MODEL = WS_LISTENER_PROPERTY_ID.ASYNC_CALLBACK_MODEL;
|
|
pub const WS_LISTENER_PROPERTY_CHANNEL_TYPE = WS_LISTENER_PROPERTY_ID.CHANNEL_TYPE;
|
|
pub const WS_LISTENER_PROPERTY_CHANNEL_BINDING = WS_LISTENER_PROPERTY_ID.CHANNEL_BINDING;
|
|
pub const WS_LISTENER_PROPERTY_CONNECT_TIMEOUT = WS_LISTENER_PROPERTY_ID.CONNECT_TIMEOUT;
|
|
pub const WS_LISTENER_PROPERTY_IS_MULTICAST = WS_LISTENER_PROPERTY_ID.IS_MULTICAST;
|
|
pub const WS_LISTENER_PROPERTY_MULTICAST_INTERFACES = WS_LISTENER_PROPERTY_ID.MULTICAST_INTERFACES;
|
|
pub const WS_LISTENER_PROPERTY_MULTICAST_LOOPBACK = WS_LISTENER_PROPERTY_ID.MULTICAST_LOOPBACK;
|
|
pub const WS_LISTENER_PROPERTY_CLOSE_TIMEOUT = WS_LISTENER_PROPERTY_ID.CLOSE_TIMEOUT;
|
|
pub const WS_LISTENER_PROPERTY_TO_HEADER_MATCHING_OPTIONS = WS_LISTENER_PROPERTY_ID.TO_HEADER_MATCHING_OPTIONS;
|
|
pub const WS_LISTENER_PROPERTY_TRANSPORT_URL_MATCHING_OPTIONS = WS_LISTENER_PROPERTY_ID.TRANSPORT_URL_MATCHING_OPTIONS;
|
|
pub const WS_LISTENER_PROPERTY_CUSTOM_LISTENER_CALLBACKS = WS_LISTENER_PROPERTY_ID.CUSTOM_LISTENER_CALLBACKS;
|
|
pub const WS_LISTENER_PROPERTY_CUSTOM_LISTENER_PARAMETERS = WS_LISTENER_PROPERTY_ID.CUSTOM_LISTENER_PARAMETERS;
|
|
pub const WS_LISTENER_PROPERTY_CUSTOM_LISTENER_INSTANCE = WS_LISTENER_PROPERTY_ID.CUSTOM_LISTENER_INSTANCE;
|
|
pub const WS_LISTENER_PROPERTY_DISALLOWED_USER_AGENT = WS_LISTENER_PROPERTY_ID.DISALLOWED_USER_AGENT;
|
|
|
|
pub const WS_IP_VERSION = enum(i32) {
|
|
@"4" = 1,
|
|
@"6" = 2,
|
|
AUTO = 3,
|
|
};
|
|
pub const WS_IP_VERSION_4 = WS_IP_VERSION.@"4";
|
|
pub const WS_IP_VERSION_6 = WS_IP_VERSION.@"6";
|
|
pub const WS_IP_VERSION_AUTO = WS_IP_VERSION.AUTO;
|
|
|
|
pub const WS_MESSAGE_STATE = enum(i32) {
|
|
EMPTY = 1,
|
|
INITIALIZED = 2,
|
|
READING = 3,
|
|
WRITING = 4,
|
|
DONE = 5,
|
|
};
|
|
pub const WS_MESSAGE_STATE_EMPTY = WS_MESSAGE_STATE.EMPTY;
|
|
pub const WS_MESSAGE_STATE_INITIALIZED = WS_MESSAGE_STATE.INITIALIZED;
|
|
pub const WS_MESSAGE_STATE_READING = WS_MESSAGE_STATE.READING;
|
|
pub const WS_MESSAGE_STATE_WRITING = WS_MESSAGE_STATE.WRITING;
|
|
pub const WS_MESSAGE_STATE_DONE = WS_MESSAGE_STATE.DONE;
|
|
|
|
pub const WS_MESSAGE_INITIALIZATION = enum(i32) {
|
|
BLANK_MESSAGE = 0,
|
|
DUPLICATE_MESSAGE = 1,
|
|
REQUEST_MESSAGE = 2,
|
|
REPLY_MESSAGE = 3,
|
|
FAULT_MESSAGE = 4,
|
|
};
|
|
pub const WS_BLANK_MESSAGE = WS_MESSAGE_INITIALIZATION.BLANK_MESSAGE;
|
|
pub const WS_DUPLICATE_MESSAGE = WS_MESSAGE_INITIALIZATION.DUPLICATE_MESSAGE;
|
|
pub const WS_REQUEST_MESSAGE = WS_MESSAGE_INITIALIZATION.REQUEST_MESSAGE;
|
|
pub const WS_REPLY_MESSAGE = WS_MESSAGE_INITIALIZATION.REPLY_MESSAGE;
|
|
pub const WS_FAULT_MESSAGE = WS_MESSAGE_INITIALIZATION.FAULT_MESSAGE;
|
|
|
|
pub const WS_REPEATING_HEADER_OPTION = enum(i32) {
|
|
REPEATING_HEADER = 1,
|
|
SINGLETON_HEADER = 2,
|
|
};
|
|
pub const WS_REPEATING_HEADER = WS_REPEATING_HEADER_OPTION.REPEATING_HEADER;
|
|
pub const WS_SINGLETON_HEADER = WS_REPEATING_HEADER_OPTION.SINGLETON_HEADER;
|
|
|
|
pub const WS_HEADER_TYPE = enum(i32) {
|
|
ACTION_HEADER = 1,
|
|
TO_HEADER = 2,
|
|
MESSAGE_ID_HEADER = 3,
|
|
RELATES_TO_HEADER = 4,
|
|
FROM_HEADER = 5,
|
|
REPLY_TO_HEADER = 6,
|
|
FAULT_TO_HEADER = 7,
|
|
};
|
|
pub const WS_ACTION_HEADER = WS_HEADER_TYPE.ACTION_HEADER;
|
|
pub const WS_TO_HEADER = WS_HEADER_TYPE.TO_HEADER;
|
|
pub const WS_MESSAGE_ID_HEADER = WS_HEADER_TYPE.MESSAGE_ID_HEADER;
|
|
pub const WS_RELATES_TO_HEADER = WS_HEADER_TYPE.RELATES_TO_HEADER;
|
|
pub const WS_FROM_HEADER = WS_HEADER_TYPE.FROM_HEADER;
|
|
pub const WS_REPLY_TO_HEADER = WS_HEADER_TYPE.REPLY_TO_HEADER;
|
|
pub const WS_FAULT_TO_HEADER = WS_HEADER_TYPE.FAULT_TO_HEADER;
|
|
|
|
pub const WS_ADDRESSING_VERSION = enum(i32) {
|
|
@"0_9" = 1,
|
|
@"1_0" = 2,
|
|
TRANSPORT = 3,
|
|
};
|
|
pub const WS_ADDRESSING_VERSION_0_9 = WS_ADDRESSING_VERSION.@"0_9";
|
|
pub const WS_ADDRESSING_VERSION_1_0 = WS_ADDRESSING_VERSION.@"1_0";
|
|
pub const WS_ADDRESSING_VERSION_TRANSPORT = WS_ADDRESSING_VERSION.TRANSPORT;
|
|
|
|
pub const WS_ENVELOPE_VERSION = enum(i32) {
|
|
SOAP_1_1 = 1,
|
|
SOAP_1_2 = 2,
|
|
NONE = 3,
|
|
};
|
|
pub const WS_ENVELOPE_VERSION_SOAP_1_1 = WS_ENVELOPE_VERSION.SOAP_1_1;
|
|
pub const WS_ENVELOPE_VERSION_SOAP_1_2 = WS_ENVELOPE_VERSION.SOAP_1_2;
|
|
pub const WS_ENVELOPE_VERSION_NONE = WS_ENVELOPE_VERSION.NONE;
|
|
|
|
pub const WS_MESSAGE_PROPERTY_ID = enum(i32) {
|
|
STATE = 0,
|
|
HEAP = 1,
|
|
ENVELOPE_VERSION = 2,
|
|
ADDRESSING_VERSION = 3,
|
|
HEADER_BUFFER = 4,
|
|
HEADER_POSITION = 5,
|
|
BODY_READER = 6,
|
|
BODY_WRITER = 7,
|
|
IS_ADDRESSED = 8,
|
|
HEAP_PROPERTIES = 9,
|
|
XML_READER_PROPERTIES = 10,
|
|
XML_WRITER_PROPERTIES = 11,
|
|
IS_FAULT = 12,
|
|
MAX_PROCESSED_HEADERS = 13,
|
|
USERNAME = 14,
|
|
ENCODED_CERT = 15,
|
|
TRANSPORT_SECURITY_WINDOWS_TOKEN = 16,
|
|
HTTP_HEADER_AUTH_WINDOWS_TOKEN = 17,
|
|
MESSAGE_SECURITY_WINDOWS_TOKEN = 18,
|
|
SAML_ASSERTION = 19,
|
|
SECURITY_CONTEXT = 20,
|
|
PROTECTION_LEVEL = 21,
|
|
};
|
|
pub const WS_MESSAGE_PROPERTY_STATE = WS_MESSAGE_PROPERTY_ID.STATE;
|
|
pub const WS_MESSAGE_PROPERTY_HEAP = WS_MESSAGE_PROPERTY_ID.HEAP;
|
|
pub const WS_MESSAGE_PROPERTY_ENVELOPE_VERSION = WS_MESSAGE_PROPERTY_ID.ENVELOPE_VERSION;
|
|
pub const WS_MESSAGE_PROPERTY_ADDRESSING_VERSION = WS_MESSAGE_PROPERTY_ID.ADDRESSING_VERSION;
|
|
pub const WS_MESSAGE_PROPERTY_HEADER_BUFFER = WS_MESSAGE_PROPERTY_ID.HEADER_BUFFER;
|
|
pub const WS_MESSAGE_PROPERTY_HEADER_POSITION = WS_MESSAGE_PROPERTY_ID.HEADER_POSITION;
|
|
pub const WS_MESSAGE_PROPERTY_BODY_READER = WS_MESSAGE_PROPERTY_ID.BODY_READER;
|
|
pub const WS_MESSAGE_PROPERTY_BODY_WRITER = WS_MESSAGE_PROPERTY_ID.BODY_WRITER;
|
|
pub const WS_MESSAGE_PROPERTY_IS_ADDRESSED = WS_MESSAGE_PROPERTY_ID.IS_ADDRESSED;
|
|
pub const WS_MESSAGE_PROPERTY_HEAP_PROPERTIES = WS_MESSAGE_PROPERTY_ID.HEAP_PROPERTIES;
|
|
pub const WS_MESSAGE_PROPERTY_XML_READER_PROPERTIES = WS_MESSAGE_PROPERTY_ID.XML_READER_PROPERTIES;
|
|
pub const WS_MESSAGE_PROPERTY_XML_WRITER_PROPERTIES = WS_MESSAGE_PROPERTY_ID.XML_WRITER_PROPERTIES;
|
|
pub const WS_MESSAGE_PROPERTY_IS_FAULT = WS_MESSAGE_PROPERTY_ID.IS_FAULT;
|
|
pub const WS_MESSAGE_PROPERTY_MAX_PROCESSED_HEADERS = WS_MESSAGE_PROPERTY_ID.MAX_PROCESSED_HEADERS;
|
|
pub const WS_MESSAGE_PROPERTY_USERNAME = WS_MESSAGE_PROPERTY_ID.USERNAME;
|
|
pub const WS_MESSAGE_PROPERTY_ENCODED_CERT = WS_MESSAGE_PROPERTY_ID.ENCODED_CERT;
|
|
pub const WS_MESSAGE_PROPERTY_TRANSPORT_SECURITY_WINDOWS_TOKEN = WS_MESSAGE_PROPERTY_ID.TRANSPORT_SECURITY_WINDOWS_TOKEN;
|
|
pub const WS_MESSAGE_PROPERTY_HTTP_HEADER_AUTH_WINDOWS_TOKEN = WS_MESSAGE_PROPERTY_ID.HTTP_HEADER_AUTH_WINDOWS_TOKEN;
|
|
pub const WS_MESSAGE_PROPERTY_MESSAGE_SECURITY_WINDOWS_TOKEN = WS_MESSAGE_PROPERTY_ID.MESSAGE_SECURITY_WINDOWS_TOKEN;
|
|
pub const WS_MESSAGE_PROPERTY_SAML_ASSERTION = WS_MESSAGE_PROPERTY_ID.SAML_ASSERTION;
|
|
pub const WS_MESSAGE_PROPERTY_SECURITY_CONTEXT = WS_MESSAGE_PROPERTY_ID.SECURITY_CONTEXT;
|
|
pub const WS_MESSAGE_PROPERTY_PROTECTION_LEVEL = WS_MESSAGE_PROPERTY_ID.PROTECTION_LEVEL;
|
|
|
|
pub const WS_SECURITY_BINDING_TYPE = enum(i32) {
|
|
SSL_TRANSPORT_SECURITY_BINDING_TYPE = 1,
|
|
TCP_SSPI_TRANSPORT_SECURITY_BINDING_TYPE = 2,
|
|
HTTP_HEADER_AUTH_SECURITY_BINDING_TYPE = 3,
|
|
USERNAME_MESSAGE_SECURITY_BINDING_TYPE = 4,
|
|
KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TYPE = 5,
|
|
XML_TOKEN_MESSAGE_SECURITY_BINDING_TYPE = 6,
|
|
SAML_MESSAGE_SECURITY_BINDING_TYPE = 7,
|
|
SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_TYPE = 8,
|
|
NAMEDPIPE_SSPI_TRANSPORT_SECURITY_BINDING_TYPE = 9,
|
|
};
|
|
pub const WS_SSL_TRANSPORT_SECURITY_BINDING_TYPE = WS_SECURITY_BINDING_TYPE.SSL_TRANSPORT_SECURITY_BINDING_TYPE;
|
|
pub const WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TYPE = WS_SECURITY_BINDING_TYPE.TCP_SSPI_TRANSPORT_SECURITY_BINDING_TYPE;
|
|
pub const WS_HTTP_HEADER_AUTH_SECURITY_BINDING_TYPE = WS_SECURITY_BINDING_TYPE.HTTP_HEADER_AUTH_SECURITY_BINDING_TYPE;
|
|
pub const WS_USERNAME_MESSAGE_SECURITY_BINDING_TYPE = WS_SECURITY_BINDING_TYPE.USERNAME_MESSAGE_SECURITY_BINDING_TYPE;
|
|
pub const WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TYPE = WS_SECURITY_BINDING_TYPE.KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TYPE;
|
|
pub const WS_XML_TOKEN_MESSAGE_SECURITY_BINDING_TYPE = WS_SECURITY_BINDING_TYPE.XML_TOKEN_MESSAGE_SECURITY_BINDING_TYPE;
|
|
pub const WS_SAML_MESSAGE_SECURITY_BINDING_TYPE = WS_SECURITY_BINDING_TYPE.SAML_MESSAGE_SECURITY_BINDING_TYPE;
|
|
pub const WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_TYPE = WS_SECURITY_BINDING_TYPE.SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_TYPE;
|
|
pub const WS_NAMEDPIPE_SSPI_TRANSPORT_SECURITY_BINDING_TYPE = WS_SECURITY_BINDING_TYPE.NAMEDPIPE_SSPI_TRANSPORT_SECURITY_BINDING_TYPE;
|
|
|
|
pub const WS_HTTP_HEADER_AUTH_TARGET = enum(i32) {
|
|
SERVICE = 1,
|
|
PROXY = 2,
|
|
};
|
|
pub const WS_HTTP_HEADER_AUTH_TARGET_SERVICE = WS_HTTP_HEADER_AUTH_TARGET.SERVICE;
|
|
pub const WS_HTTP_HEADER_AUTH_TARGET_PROXY = WS_HTTP_HEADER_AUTH_TARGET.PROXY;
|
|
|
|
pub const WS_WINDOWS_INTEGRATED_AUTH_PACKAGE = enum(i32) {
|
|
KERBEROS = 1,
|
|
NTLM = 2,
|
|
SPNEGO = 3,
|
|
};
|
|
pub const WS_WINDOWS_INTEGRATED_AUTH_PACKAGE_KERBEROS = WS_WINDOWS_INTEGRATED_AUTH_PACKAGE.KERBEROS;
|
|
pub const WS_WINDOWS_INTEGRATED_AUTH_PACKAGE_NTLM = WS_WINDOWS_INTEGRATED_AUTH_PACKAGE.NTLM;
|
|
pub const WS_WINDOWS_INTEGRATED_AUTH_PACKAGE_SPNEGO = WS_WINDOWS_INTEGRATED_AUTH_PACKAGE.SPNEGO;
|
|
|
|
pub const WS_SECURITY_HEADER_VERSION = enum(i32) {
|
|
@"0" = 1,
|
|
@"1" = 2,
|
|
};
|
|
pub const WS_SECURITY_HEADER_VERSION_1_0 = WS_SECURITY_HEADER_VERSION.@"0";
|
|
pub const WS_SECURITY_HEADER_VERSION_1_1 = WS_SECURITY_HEADER_VERSION.@"1";
|
|
|
|
pub const WS_TRUST_VERSION = enum(i32) {
|
|
FEBRUARY_2005 = 1,
|
|
@"1_3" = 2,
|
|
};
|
|
pub const WS_TRUST_VERSION_FEBRUARY_2005 = WS_TRUST_VERSION.FEBRUARY_2005;
|
|
pub const WS_TRUST_VERSION_1_3 = WS_TRUST_VERSION.@"1_3";
|
|
|
|
pub const WS_REQUEST_SECURITY_TOKEN_ACTION = enum(i32) {
|
|
ISSUE = 1,
|
|
NEW_CONTEXT = 2,
|
|
RENEW_CONTEXT = 3,
|
|
};
|
|
pub const WS_REQUEST_SECURITY_TOKEN_ACTION_ISSUE = WS_REQUEST_SECURITY_TOKEN_ACTION.ISSUE;
|
|
pub const WS_REQUEST_SECURITY_TOKEN_ACTION_NEW_CONTEXT = WS_REQUEST_SECURITY_TOKEN_ACTION.NEW_CONTEXT;
|
|
pub const WS_REQUEST_SECURITY_TOKEN_ACTION_RENEW_CONTEXT = WS_REQUEST_SECURITY_TOKEN_ACTION.RENEW_CONTEXT;
|
|
|
|
pub const WS_SECURE_CONVERSATION_VERSION = enum(i32) {
|
|
FEBRUARY_2005 = 1,
|
|
@"1_3" = 2,
|
|
};
|
|
pub const WS_SECURE_CONVERSATION_VERSION_FEBRUARY_2005 = WS_SECURE_CONVERSATION_VERSION.FEBRUARY_2005;
|
|
pub const WS_SECURE_CONVERSATION_VERSION_1_3 = WS_SECURE_CONVERSATION_VERSION.@"1_3";
|
|
|
|
pub const WS_SECURE_PROTOCOL = enum(i32) {
|
|
SSL2 = 1,
|
|
SSL3 = 2,
|
|
TLS1_0 = 4,
|
|
TLS1_1 = 8,
|
|
TLS1_2 = 16,
|
|
};
|
|
pub const WS_SECURE_PROTOCOL_SSL2 = WS_SECURE_PROTOCOL.SSL2;
|
|
pub const WS_SECURE_PROTOCOL_SSL3 = WS_SECURE_PROTOCOL.SSL3;
|
|
pub const WS_SECURE_PROTOCOL_TLS1_0 = WS_SECURE_PROTOCOL.TLS1_0;
|
|
pub const WS_SECURE_PROTOCOL_TLS1_1 = WS_SECURE_PROTOCOL.TLS1_1;
|
|
pub const WS_SECURE_PROTOCOL_TLS1_2 = WS_SECURE_PROTOCOL.TLS1_2;
|
|
|
|
pub const WS_SECURITY_TIMESTAMP_USAGE = enum(i32) {
|
|
ALWAYS = 1,
|
|
NEVER = 2,
|
|
REQUESTS_ONLY = 3,
|
|
};
|
|
pub const WS_SECURITY_TIMESTAMP_USAGE_ALWAYS = WS_SECURITY_TIMESTAMP_USAGE.ALWAYS;
|
|
pub const WS_SECURITY_TIMESTAMP_USAGE_NEVER = WS_SECURITY_TIMESTAMP_USAGE.NEVER;
|
|
pub const WS_SECURITY_TIMESTAMP_USAGE_REQUESTS_ONLY = WS_SECURITY_TIMESTAMP_USAGE.REQUESTS_ONLY;
|
|
|
|
pub const WS_SECURITY_HEADER_LAYOUT = enum(i32) {
|
|
STRICT = 1,
|
|
LAX = 2,
|
|
LAX_WITH_TIMESTAMP_FIRST = 3,
|
|
LAX_WITH_TIMESTAMP_LAST = 4,
|
|
};
|
|
pub const WS_SECURITY_HEADER_LAYOUT_STRICT = WS_SECURITY_HEADER_LAYOUT.STRICT;
|
|
pub const WS_SECURITY_HEADER_LAYOUT_LAX = WS_SECURITY_HEADER_LAYOUT.LAX;
|
|
pub const WS_SECURITY_HEADER_LAYOUT_LAX_WITH_TIMESTAMP_FIRST = WS_SECURITY_HEADER_LAYOUT.LAX_WITH_TIMESTAMP_FIRST;
|
|
pub const WS_SECURITY_HEADER_LAYOUT_LAX_WITH_TIMESTAMP_LAST = WS_SECURITY_HEADER_LAYOUT.LAX_WITH_TIMESTAMP_LAST;
|
|
|
|
pub const WS_SECURITY_ALGORITHM_PROPERTY_ID = enum(i32) {
|
|
_
|
|
};
|
|
|
|
pub const WS_SECURITY_ALGORITHM_ID = enum(i32) {
|
|
DEFAULT = 0,
|
|
CANONICALIZATION_EXCLUSIVE = 1,
|
|
CANONICALIZATION_EXCLUSIVE_WITH_COMMENTS = 2,
|
|
DIGEST_SHA1 = 3,
|
|
DIGEST_SHA_256 = 4,
|
|
DIGEST_SHA_384 = 5,
|
|
DIGEST_SHA_512 = 6,
|
|
SYMMETRIC_SIGNATURE_HMAC_SHA1 = 7,
|
|
SYMMETRIC_SIGNATURE_HMAC_SHA_256 = 8,
|
|
SYMMETRIC_SIGNATURE_HMAC_SHA_384 = 9,
|
|
SYMMETRIC_SIGNATURE_HMAC_SHA_512 = 10,
|
|
ASYMMETRIC_SIGNATURE_RSA_SHA1 = 11,
|
|
ASYMMETRIC_SIGNATURE_DSA_SHA1 = 12,
|
|
ASYMMETRIC_SIGNATURE_RSA_SHA_256 = 13,
|
|
ASYMMETRIC_SIGNATURE_RSA_SHA_384 = 14,
|
|
ASYMMETRIC_SIGNATURE_RSA_SHA_512 = 15,
|
|
ASYMMETRIC_KEYWRAP_RSA_1_5 = 16,
|
|
ASYMMETRIC_KEYWRAP_RSA_OAEP = 17,
|
|
KEY_DERIVATION_P_SHA1 = 18,
|
|
};
|
|
pub const WS_SECURITY_ALGORITHM_DEFAULT = WS_SECURITY_ALGORITHM_ID.DEFAULT;
|
|
pub const WS_SECURITY_ALGORITHM_CANONICALIZATION_EXCLUSIVE = WS_SECURITY_ALGORITHM_ID.CANONICALIZATION_EXCLUSIVE;
|
|
pub const WS_SECURITY_ALGORITHM_CANONICALIZATION_EXCLUSIVE_WITH_COMMENTS = WS_SECURITY_ALGORITHM_ID.CANONICALIZATION_EXCLUSIVE_WITH_COMMENTS;
|
|
pub const WS_SECURITY_ALGORITHM_DIGEST_SHA1 = WS_SECURITY_ALGORITHM_ID.DIGEST_SHA1;
|
|
pub const WS_SECURITY_ALGORITHM_DIGEST_SHA_256 = WS_SECURITY_ALGORITHM_ID.DIGEST_SHA_256;
|
|
pub const WS_SECURITY_ALGORITHM_DIGEST_SHA_384 = WS_SECURITY_ALGORITHM_ID.DIGEST_SHA_384;
|
|
pub const WS_SECURITY_ALGORITHM_DIGEST_SHA_512 = WS_SECURITY_ALGORITHM_ID.DIGEST_SHA_512;
|
|
pub const WS_SECURITY_ALGORITHM_SYMMETRIC_SIGNATURE_HMAC_SHA1 = WS_SECURITY_ALGORITHM_ID.SYMMETRIC_SIGNATURE_HMAC_SHA1;
|
|
pub const WS_SECURITY_ALGORITHM_SYMMETRIC_SIGNATURE_HMAC_SHA_256 = WS_SECURITY_ALGORITHM_ID.SYMMETRIC_SIGNATURE_HMAC_SHA_256;
|
|
pub const WS_SECURITY_ALGORITHM_SYMMETRIC_SIGNATURE_HMAC_SHA_384 = WS_SECURITY_ALGORITHM_ID.SYMMETRIC_SIGNATURE_HMAC_SHA_384;
|
|
pub const WS_SECURITY_ALGORITHM_SYMMETRIC_SIGNATURE_HMAC_SHA_512 = WS_SECURITY_ALGORITHM_ID.SYMMETRIC_SIGNATURE_HMAC_SHA_512;
|
|
pub const WS_SECURITY_ALGORITHM_ASYMMETRIC_SIGNATURE_RSA_SHA1 = WS_SECURITY_ALGORITHM_ID.ASYMMETRIC_SIGNATURE_RSA_SHA1;
|
|
pub const WS_SECURITY_ALGORITHM_ASYMMETRIC_SIGNATURE_DSA_SHA1 = WS_SECURITY_ALGORITHM_ID.ASYMMETRIC_SIGNATURE_DSA_SHA1;
|
|
pub const WS_SECURITY_ALGORITHM_ASYMMETRIC_SIGNATURE_RSA_SHA_256 = WS_SECURITY_ALGORITHM_ID.ASYMMETRIC_SIGNATURE_RSA_SHA_256;
|
|
pub const WS_SECURITY_ALGORITHM_ASYMMETRIC_SIGNATURE_RSA_SHA_384 = WS_SECURITY_ALGORITHM_ID.ASYMMETRIC_SIGNATURE_RSA_SHA_384;
|
|
pub const WS_SECURITY_ALGORITHM_ASYMMETRIC_SIGNATURE_RSA_SHA_512 = WS_SECURITY_ALGORITHM_ID.ASYMMETRIC_SIGNATURE_RSA_SHA_512;
|
|
pub const WS_SECURITY_ALGORITHM_ASYMMETRIC_KEYWRAP_RSA_1_5 = WS_SECURITY_ALGORITHM_ID.ASYMMETRIC_KEYWRAP_RSA_1_5;
|
|
pub const WS_SECURITY_ALGORITHM_ASYMMETRIC_KEYWRAP_RSA_OAEP = WS_SECURITY_ALGORITHM_ID.ASYMMETRIC_KEYWRAP_RSA_OAEP;
|
|
pub const WS_SECURITY_ALGORITHM_KEY_DERIVATION_P_SHA1 = WS_SECURITY_ALGORITHM_ID.KEY_DERIVATION_P_SHA1;
|
|
|
|
pub const WS_PROTECTION_LEVEL = enum(i32) {
|
|
NONE = 1,
|
|
SIGN = 2,
|
|
SIGN_AND_ENCRYPT = 3,
|
|
};
|
|
pub const WS_PROTECTION_LEVEL_NONE = WS_PROTECTION_LEVEL.NONE;
|
|
pub const WS_PROTECTION_LEVEL_SIGN = WS_PROTECTION_LEVEL.SIGN;
|
|
pub const WS_PROTECTION_LEVEL_SIGN_AND_ENCRYPT = WS_PROTECTION_LEVEL.SIGN_AND_ENCRYPT;
|
|
|
|
pub const WS_SECURITY_PROPERTY_ID = enum(i32) {
|
|
TRANSPORT_PROTECTION_LEVEL = 1,
|
|
ALGORITHM_SUITE = 2,
|
|
ALGORITHM_SUITE_NAME = 3,
|
|
MAX_ALLOWED_LATENCY = 4,
|
|
TIMESTAMP_VALIDITY_DURATION = 5,
|
|
MAX_ALLOWED_CLOCK_SKEW = 6,
|
|
TIMESTAMP_USAGE = 7,
|
|
SECURITY_HEADER_LAYOUT = 8,
|
|
SECURITY_HEADER_VERSION = 9,
|
|
EXTENDED_PROTECTION_POLICY = 10,
|
|
EXTENDED_PROTECTION_SCENARIO = 11,
|
|
SERVICE_IDENTITIES = 12,
|
|
};
|
|
pub const WS_SECURITY_PROPERTY_TRANSPORT_PROTECTION_LEVEL = WS_SECURITY_PROPERTY_ID.TRANSPORT_PROTECTION_LEVEL;
|
|
pub const WS_SECURITY_PROPERTY_ALGORITHM_SUITE = WS_SECURITY_PROPERTY_ID.ALGORITHM_SUITE;
|
|
pub const WS_SECURITY_PROPERTY_ALGORITHM_SUITE_NAME = WS_SECURITY_PROPERTY_ID.ALGORITHM_SUITE_NAME;
|
|
pub const WS_SECURITY_PROPERTY_MAX_ALLOWED_LATENCY = WS_SECURITY_PROPERTY_ID.MAX_ALLOWED_LATENCY;
|
|
pub const WS_SECURITY_PROPERTY_TIMESTAMP_VALIDITY_DURATION = WS_SECURITY_PROPERTY_ID.TIMESTAMP_VALIDITY_DURATION;
|
|
pub const WS_SECURITY_PROPERTY_MAX_ALLOWED_CLOCK_SKEW = WS_SECURITY_PROPERTY_ID.MAX_ALLOWED_CLOCK_SKEW;
|
|
pub const WS_SECURITY_PROPERTY_TIMESTAMP_USAGE = WS_SECURITY_PROPERTY_ID.TIMESTAMP_USAGE;
|
|
pub const WS_SECURITY_PROPERTY_SECURITY_HEADER_LAYOUT = WS_SECURITY_PROPERTY_ID.SECURITY_HEADER_LAYOUT;
|
|
pub const WS_SECURITY_PROPERTY_SECURITY_HEADER_VERSION = WS_SECURITY_PROPERTY_ID.SECURITY_HEADER_VERSION;
|
|
pub const WS_SECURITY_PROPERTY_EXTENDED_PROTECTION_POLICY = WS_SECURITY_PROPERTY_ID.EXTENDED_PROTECTION_POLICY;
|
|
pub const WS_SECURITY_PROPERTY_EXTENDED_PROTECTION_SCENARIO = WS_SECURITY_PROPERTY_ID.EXTENDED_PROTECTION_SCENARIO;
|
|
pub const WS_SECURITY_PROPERTY_SERVICE_IDENTITIES = WS_SECURITY_PROPERTY_ID.SERVICE_IDENTITIES;
|
|
|
|
pub const WS_SECURITY_KEY_TYPE = enum(i32) {
|
|
NONE = 1,
|
|
SYMMETRIC = 2,
|
|
ASYMMETRIC = 3,
|
|
};
|
|
pub const WS_SECURITY_KEY_TYPE_NONE = WS_SECURITY_KEY_TYPE.NONE;
|
|
pub const WS_SECURITY_KEY_TYPE_SYMMETRIC = WS_SECURITY_KEY_TYPE.SYMMETRIC;
|
|
pub const WS_SECURITY_KEY_TYPE_ASYMMETRIC = WS_SECURITY_KEY_TYPE.ASYMMETRIC;
|
|
|
|
pub const WS_SECURITY_ALGORITHM_SUITE_NAME = enum(i32) {
|
|
@"256" = 1,
|
|
@"192" = 2,
|
|
@"128" = 3,
|
|
@"256_RSA15" = 4,
|
|
@"192_RSA15" = 5,
|
|
@"128_RSA15" = 6,
|
|
@"256_SHA256" = 7,
|
|
@"192_SHA256" = 8,
|
|
@"128_SHA256" = 9,
|
|
@"256_SHA256_RSA15" = 10,
|
|
@"192_SHA256_RSA15" = 11,
|
|
@"128_SHA256_RSA15" = 12,
|
|
};
|
|
pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC256 = WS_SECURITY_ALGORITHM_SUITE_NAME.@"256";
|
|
pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC192 = WS_SECURITY_ALGORITHM_SUITE_NAME.@"192";
|
|
pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC128 = WS_SECURITY_ALGORITHM_SUITE_NAME.@"128";
|
|
pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC256_RSA15 = WS_SECURITY_ALGORITHM_SUITE_NAME.@"256_RSA15";
|
|
pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC192_RSA15 = WS_SECURITY_ALGORITHM_SUITE_NAME.@"192_RSA15";
|
|
pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC128_RSA15 = WS_SECURITY_ALGORITHM_SUITE_NAME.@"128_RSA15";
|
|
pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC256_SHA256 = WS_SECURITY_ALGORITHM_SUITE_NAME.@"256_SHA256";
|
|
pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC192_SHA256 = WS_SECURITY_ALGORITHM_SUITE_NAME.@"192_SHA256";
|
|
pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC128_SHA256 = WS_SECURITY_ALGORITHM_SUITE_NAME.@"128_SHA256";
|
|
pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC256_SHA256_RSA15 = WS_SECURITY_ALGORITHM_SUITE_NAME.@"256_SHA256_RSA15";
|
|
pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC192_SHA256_RSA15 = WS_SECURITY_ALGORITHM_SUITE_NAME.@"192_SHA256_RSA15";
|
|
pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC128_SHA256_RSA15 = WS_SECURITY_ALGORITHM_SUITE_NAME.@"128_SHA256_RSA15";
|
|
|
|
pub const WS_SECURITY_TOKEN_REFERENCE_MODE = enum(i32) {
|
|
LOCAL_ID = 1,
|
|
XML_BUFFER = 2,
|
|
CERT_THUMBPRINT = 3,
|
|
SECURITY_CONTEXT_ID = 4,
|
|
SAML_ASSERTION_ID = 5,
|
|
};
|
|
pub const WS_SECURITY_TOKEN_REFERENCE_MODE_LOCAL_ID = WS_SECURITY_TOKEN_REFERENCE_MODE.LOCAL_ID;
|
|
pub const WS_SECURITY_TOKEN_REFERENCE_MODE_XML_BUFFER = WS_SECURITY_TOKEN_REFERENCE_MODE.XML_BUFFER;
|
|
pub const WS_SECURITY_TOKEN_REFERENCE_MODE_CERT_THUMBPRINT = WS_SECURITY_TOKEN_REFERENCE_MODE.CERT_THUMBPRINT;
|
|
pub const WS_SECURITY_TOKEN_REFERENCE_MODE_SECURITY_CONTEXT_ID = WS_SECURITY_TOKEN_REFERENCE_MODE.SECURITY_CONTEXT_ID;
|
|
pub const WS_SECURITY_TOKEN_REFERENCE_MODE_SAML_ASSERTION_ID = WS_SECURITY_TOKEN_REFERENCE_MODE.SAML_ASSERTION_ID;
|
|
|
|
pub const WS_SECURITY_KEY_ENTROPY_MODE = enum(i32) {
|
|
CLIENT_ONLY = 1,
|
|
SERVER_ONLY = 2,
|
|
COMBINED = 3,
|
|
};
|
|
pub const WS_SECURITY_KEY_ENTROPY_MODE_CLIENT_ONLY = WS_SECURITY_KEY_ENTROPY_MODE.CLIENT_ONLY;
|
|
pub const WS_SECURITY_KEY_ENTROPY_MODE_SERVER_ONLY = WS_SECURITY_KEY_ENTROPY_MODE.SERVER_ONLY;
|
|
pub const WS_SECURITY_KEY_ENTROPY_MODE_COMBINED = WS_SECURITY_KEY_ENTROPY_MODE.COMBINED;
|
|
|
|
pub const WS_EXTENDED_PROTECTION_POLICY = enum(i32) {
|
|
NEVER = 1,
|
|
WHEN_SUPPORTED = 2,
|
|
ALWAYS = 3,
|
|
};
|
|
pub const WS_EXTENDED_PROTECTION_POLICY_NEVER = WS_EXTENDED_PROTECTION_POLICY.NEVER;
|
|
pub const WS_EXTENDED_PROTECTION_POLICY_WHEN_SUPPORTED = WS_EXTENDED_PROTECTION_POLICY.WHEN_SUPPORTED;
|
|
pub const WS_EXTENDED_PROTECTION_POLICY_ALWAYS = WS_EXTENDED_PROTECTION_POLICY.ALWAYS;
|
|
|
|
pub const WS_EXTENDED_PROTECTION_SCENARIO = enum(i32) {
|
|
BOUND_SERVER = 1,
|
|
TERMINATED_SSL = 2,
|
|
};
|
|
pub const WS_EXTENDED_PROTECTION_SCENARIO_BOUND_SERVER = WS_EXTENDED_PROTECTION_SCENARIO.BOUND_SERVER;
|
|
pub const WS_EXTENDED_PROTECTION_SCENARIO_TERMINATED_SSL = WS_EXTENDED_PROTECTION_SCENARIO.TERMINATED_SSL;
|
|
|
|
pub const WS_SECURITY_BINDING_PROPERTY_ID = enum(i32) {
|
|
REQUIRE_SSL_CLIENT_CERT = 1,
|
|
WINDOWS_INTEGRATED_AUTH_PACKAGE = 2,
|
|
REQUIRE_SERVER_AUTH = 3,
|
|
ALLOW_ANONYMOUS_CLIENTS = 4,
|
|
ALLOWED_IMPERSONATION_LEVEL = 5,
|
|
HTTP_HEADER_AUTH_SCHEME = 6,
|
|
HTTP_HEADER_AUTH_TARGET = 7,
|
|
HTTP_HEADER_AUTH_BASIC_REALM = 8,
|
|
HTTP_HEADER_AUTH_DIGEST_REALM = 9,
|
|
HTTP_HEADER_AUTH_DIGEST_DOMAIN = 10,
|
|
SECURITY_CONTEXT_KEY_SIZE = 11,
|
|
SECURITY_CONTEXT_KEY_ENTROPY_MODE = 12,
|
|
MESSAGE_PROPERTIES = 13,
|
|
SECURITY_CONTEXT_MAX_PENDING_CONTEXTS = 14,
|
|
SECURITY_CONTEXT_MAX_ACTIVE_CONTEXTS = 15,
|
|
SECURE_CONVERSATION_VERSION = 16,
|
|
SECURITY_CONTEXT_SUPPORT_RENEW = 17,
|
|
SECURITY_CONTEXT_RENEWAL_INTERVAL = 18,
|
|
SECURITY_CONTEXT_ROLLOVER_INTERVAL = 19,
|
|
CERT_FAILURES_TO_IGNORE = 20,
|
|
DISABLE_CERT_REVOCATION_CHECK = 21,
|
|
DISALLOWED_SECURE_PROTOCOLS = 22,
|
|
CERTIFICATE_VALIDATION_CALLBACK_CONTEXT = 23,
|
|
};
|
|
pub const WS_SECURITY_BINDING_PROPERTY_REQUIRE_SSL_CLIENT_CERT = WS_SECURITY_BINDING_PROPERTY_ID.REQUIRE_SSL_CLIENT_CERT;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_WINDOWS_INTEGRATED_AUTH_PACKAGE = WS_SECURITY_BINDING_PROPERTY_ID.WINDOWS_INTEGRATED_AUTH_PACKAGE;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_REQUIRE_SERVER_AUTH = WS_SECURITY_BINDING_PROPERTY_ID.REQUIRE_SERVER_AUTH;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_ALLOW_ANONYMOUS_CLIENTS = WS_SECURITY_BINDING_PROPERTY_ID.ALLOW_ANONYMOUS_CLIENTS;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_ALLOWED_IMPERSONATION_LEVEL = WS_SECURITY_BINDING_PROPERTY_ID.ALLOWED_IMPERSONATION_LEVEL;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_SCHEME = WS_SECURITY_BINDING_PROPERTY_ID.HTTP_HEADER_AUTH_SCHEME;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_TARGET = WS_SECURITY_BINDING_PROPERTY_ID.HTTP_HEADER_AUTH_TARGET;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_BASIC_REALM = WS_SECURITY_BINDING_PROPERTY_ID.HTTP_HEADER_AUTH_BASIC_REALM;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_DIGEST_REALM = WS_SECURITY_BINDING_PROPERTY_ID.HTTP_HEADER_AUTH_DIGEST_REALM;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_DIGEST_DOMAIN = WS_SECURITY_BINDING_PROPERTY_ID.HTTP_HEADER_AUTH_DIGEST_DOMAIN;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_KEY_SIZE = WS_SECURITY_BINDING_PROPERTY_ID.SECURITY_CONTEXT_KEY_SIZE;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_KEY_ENTROPY_MODE = WS_SECURITY_BINDING_PROPERTY_ID.SECURITY_CONTEXT_KEY_ENTROPY_MODE;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_MESSAGE_PROPERTIES = WS_SECURITY_BINDING_PROPERTY_ID.MESSAGE_PROPERTIES;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_MAX_PENDING_CONTEXTS = WS_SECURITY_BINDING_PROPERTY_ID.SECURITY_CONTEXT_MAX_PENDING_CONTEXTS;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_MAX_ACTIVE_CONTEXTS = WS_SECURITY_BINDING_PROPERTY_ID.SECURITY_CONTEXT_MAX_ACTIVE_CONTEXTS;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_SECURE_CONVERSATION_VERSION = WS_SECURITY_BINDING_PROPERTY_ID.SECURE_CONVERSATION_VERSION;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_SUPPORT_RENEW = WS_SECURITY_BINDING_PROPERTY_ID.SECURITY_CONTEXT_SUPPORT_RENEW;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_RENEWAL_INTERVAL = WS_SECURITY_BINDING_PROPERTY_ID.SECURITY_CONTEXT_RENEWAL_INTERVAL;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_ROLLOVER_INTERVAL = WS_SECURITY_BINDING_PROPERTY_ID.SECURITY_CONTEXT_ROLLOVER_INTERVAL;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_CERT_FAILURES_TO_IGNORE = WS_SECURITY_BINDING_PROPERTY_ID.CERT_FAILURES_TO_IGNORE;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_DISABLE_CERT_REVOCATION_CHECK = WS_SECURITY_BINDING_PROPERTY_ID.DISABLE_CERT_REVOCATION_CHECK;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_DISALLOWED_SECURE_PROTOCOLS = WS_SECURITY_BINDING_PROPERTY_ID.DISALLOWED_SECURE_PROTOCOLS;
|
|
pub const WS_SECURITY_BINDING_PROPERTY_CERTIFICATE_VALIDATION_CALLBACK_CONTEXT = WS_SECURITY_BINDING_PROPERTY_ID.CERTIFICATE_VALIDATION_CALLBACK_CONTEXT;
|
|
|
|
pub const WS_CERT_CREDENTIAL_TYPE = enum(i32) {
|
|
SUBJECT_NAME_CERT_CREDENTIAL_TYPE = 1,
|
|
THUMBPRINT_CERT_CREDENTIAL_TYPE = 2,
|
|
CUSTOM_CERT_CREDENTIAL_TYPE = 3,
|
|
};
|
|
pub const WS_SUBJECT_NAME_CERT_CREDENTIAL_TYPE = WS_CERT_CREDENTIAL_TYPE.SUBJECT_NAME_CERT_CREDENTIAL_TYPE;
|
|
pub const WS_THUMBPRINT_CERT_CREDENTIAL_TYPE = WS_CERT_CREDENTIAL_TYPE.THUMBPRINT_CERT_CREDENTIAL_TYPE;
|
|
pub const WS_CUSTOM_CERT_CREDENTIAL_TYPE = WS_CERT_CREDENTIAL_TYPE.CUSTOM_CERT_CREDENTIAL_TYPE;
|
|
|
|
pub const WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE = enum(i32) {
|
|
STRING_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE = 1,
|
|
DEFAULT_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE = 2,
|
|
OPAQUE_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE = 3,
|
|
};
|
|
pub const WS_STRING_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE = WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE.STRING_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE;
|
|
pub const WS_DEFAULT_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE = WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE.DEFAULT_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE;
|
|
pub const WS_OPAQUE_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE = WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE.OPAQUE_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE;
|
|
|
|
pub const WS_USERNAME_CREDENTIAL_TYPE = enum(i32) {
|
|
E = 1,
|
|
};
|
|
pub const WS_STRING_USERNAME_CREDENTIAL_TYPE = WS_USERNAME_CREDENTIAL_TYPE.E;
|
|
|
|
pub const WS_SECURITY_TOKEN_PROPERTY_ID = enum(i32) {
|
|
KEY_TYPE = 1,
|
|
VALID_FROM_TIME = 2,
|
|
VALID_TILL_TIME = 3,
|
|
SERIALIZED_XML = 4,
|
|
ATTACHED_REFERENCE_XML = 5,
|
|
UNATTACHED_REFERENCE_XML = 6,
|
|
SYMMETRIC_KEY = 7,
|
|
};
|
|
pub const WS_SECURITY_TOKEN_PROPERTY_KEY_TYPE = WS_SECURITY_TOKEN_PROPERTY_ID.KEY_TYPE;
|
|
pub const WS_SECURITY_TOKEN_PROPERTY_VALID_FROM_TIME = WS_SECURITY_TOKEN_PROPERTY_ID.VALID_FROM_TIME;
|
|
pub const WS_SECURITY_TOKEN_PROPERTY_VALID_TILL_TIME = WS_SECURITY_TOKEN_PROPERTY_ID.VALID_TILL_TIME;
|
|
pub const WS_SECURITY_TOKEN_PROPERTY_SERIALIZED_XML = WS_SECURITY_TOKEN_PROPERTY_ID.SERIALIZED_XML;
|
|
pub const WS_SECURITY_TOKEN_PROPERTY_ATTACHED_REFERENCE_XML = WS_SECURITY_TOKEN_PROPERTY_ID.ATTACHED_REFERENCE_XML;
|
|
pub const WS_SECURITY_TOKEN_PROPERTY_UNATTACHED_REFERENCE_XML = WS_SECURITY_TOKEN_PROPERTY_ID.UNATTACHED_REFERENCE_XML;
|
|
pub const WS_SECURITY_TOKEN_PROPERTY_SYMMETRIC_KEY = WS_SECURITY_TOKEN_PROPERTY_ID.SYMMETRIC_KEY;
|
|
|
|
pub const WS_SECURITY_KEY_HANDLE_TYPE = enum(i32) {
|
|
RAW_SYMMETRIC_SECURITY_KEY_HANDLE_TYPE = 1,
|
|
NCRYPT_ASYMMETRIC_SECURITY_KEY_HANDLE_TYPE = 2,
|
|
CAPI_ASYMMETRIC_SECURITY_KEY_HANDLE_TYPE = 3,
|
|
};
|
|
pub const WS_RAW_SYMMETRIC_SECURITY_KEY_HANDLE_TYPE = WS_SECURITY_KEY_HANDLE_TYPE.RAW_SYMMETRIC_SECURITY_KEY_HANDLE_TYPE;
|
|
pub const WS_NCRYPT_ASYMMETRIC_SECURITY_KEY_HANDLE_TYPE = WS_SECURITY_KEY_HANDLE_TYPE.NCRYPT_ASYMMETRIC_SECURITY_KEY_HANDLE_TYPE;
|
|
pub const WS_CAPI_ASYMMETRIC_SECURITY_KEY_HANDLE_TYPE = WS_SECURITY_KEY_HANDLE_TYPE.CAPI_ASYMMETRIC_SECURITY_KEY_HANDLE_TYPE;
|
|
|
|
pub const WS_MESSAGE_SECURITY_USAGE = enum(i32) {
|
|
E = 1,
|
|
};
|
|
pub const WS_SUPPORTING_MESSAGE_SECURITY_USAGE = WS_MESSAGE_SECURITY_USAGE.E;
|
|
|
|
pub const WS_SECURITY_CONTEXT_PROPERTY_ID = enum(i32) {
|
|
IDENTIFIER = 1,
|
|
USERNAME = 2,
|
|
MESSAGE_SECURITY_WINDOWS_TOKEN = 3,
|
|
SAML_ASSERTION = 4,
|
|
};
|
|
pub const WS_SECURITY_CONTEXT_PROPERTY_IDENTIFIER = WS_SECURITY_CONTEXT_PROPERTY_ID.IDENTIFIER;
|
|
pub const WS_SECURITY_CONTEXT_PROPERTY_USERNAME = WS_SECURITY_CONTEXT_PROPERTY_ID.USERNAME;
|
|
pub const WS_SECURITY_CONTEXT_PROPERTY_MESSAGE_SECURITY_WINDOWS_TOKEN = WS_SECURITY_CONTEXT_PROPERTY_ID.MESSAGE_SECURITY_WINDOWS_TOKEN;
|
|
pub const WS_SECURITY_CONTEXT_PROPERTY_SAML_ASSERTION = WS_SECURITY_CONTEXT_PROPERTY_ID.SAML_ASSERTION;
|
|
|
|
pub const WS_XML_SECURITY_TOKEN_PROPERTY_ID = enum(i32) {
|
|
ATTACHED_REFERENCE = 1,
|
|
UNATTACHED_REFERENCE = 2,
|
|
VALID_FROM_TIME = 3,
|
|
VALID_TILL_TIME = 4,
|
|
};
|
|
pub const WS_XML_SECURITY_TOKEN_PROPERTY_ATTACHED_REFERENCE = WS_XML_SECURITY_TOKEN_PROPERTY_ID.ATTACHED_REFERENCE;
|
|
pub const WS_XML_SECURITY_TOKEN_PROPERTY_UNATTACHED_REFERENCE = WS_XML_SECURITY_TOKEN_PROPERTY_ID.UNATTACHED_REFERENCE;
|
|
pub const WS_XML_SECURITY_TOKEN_PROPERTY_VALID_FROM_TIME = WS_XML_SECURITY_TOKEN_PROPERTY_ID.VALID_FROM_TIME;
|
|
pub const WS_XML_SECURITY_TOKEN_PROPERTY_VALID_TILL_TIME = WS_XML_SECURITY_TOKEN_PROPERTY_ID.VALID_TILL_TIME;
|
|
|
|
pub const WS_SAML_AUTHENTICATOR_TYPE = enum(i32) {
|
|
E = 1,
|
|
};
|
|
pub const WS_CERT_SIGNED_SAML_AUTHENTICATOR_TYPE = WS_SAML_AUTHENTICATOR_TYPE.E;
|
|
|
|
pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID = enum(i32) {
|
|
APPLIES_TO = 1,
|
|
TRUST_VERSION = 2,
|
|
SECURE_CONVERSATION_VERSION = 3,
|
|
ISSUED_TOKEN_TYPE = 4,
|
|
REQUEST_ACTION = 5,
|
|
EXISTING_TOKEN = 6,
|
|
ISSUED_TOKEN_KEY_TYPE = 7,
|
|
ISSUED_TOKEN_KEY_SIZE = 8,
|
|
ISSUED_TOKEN_KEY_ENTROPY = 9,
|
|
LOCAL_REQUEST_PARAMETERS = 10,
|
|
SERVICE_REQUEST_PARAMETERS = 11,
|
|
MESSAGE_PROPERTIES = 12,
|
|
BEARER_KEY_TYPE_VERSION = 13,
|
|
};
|
|
pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_APPLIES_TO = WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID.APPLIES_TO;
|
|
pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_TRUST_VERSION = WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID.TRUST_VERSION;
|
|
pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_SECURE_CONVERSATION_VERSION = WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID.SECURE_CONVERSATION_VERSION;
|
|
pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_ISSUED_TOKEN_TYPE = WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID.ISSUED_TOKEN_TYPE;
|
|
pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_REQUEST_ACTION = WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID.REQUEST_ACTION;
|
|
pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_EXISTING_TOKEN = WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID.EXISTING_TOKEN;
|
|
pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_ISSUED_TOKEN_KEY_TYPE = WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID.ISSUED_TOKEN_KEY_TYPE;
|
|
pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_ISSUED_TOKEN_KEY_SIZE = WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID.ISSUED_TOKEN_KEY_SIZE;
|
|
pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_ISSUED_TOKEN_KEY_ENTROPY = WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID.ISSUED_TOKEN_KEY_ENTROPY;
|
|
pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_LOCAL_REQUEST_PARAMETERS = WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID.LOCAL_REQUEST_PARAMETERS;
|
|
pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_SERVICE_REQUEST_PARAMETERS = WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID.SERVICE_REQUEST_PARAMETERS;
|
|
pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_MESSAGE_PROPERTIES = WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID.MESSAGE_PROPERTIES;
|
|
pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_BEARER_KEY_TYPE_VERSION = WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID.BEARER_KEY_TYPE_VERSION;
|
|
|
|
pub const WS_SECURITY_BEARER_KEY_TYPE_VERSION = enum(i32) {
|
|
ORIGINAL_SPECIFICATION = 1,
|
|
ORIGINAL_SCHEMA = 2,
|
|
ERRATA_01 = 3,
|
|
};
|
|
pub const WS_SECURITY_BEARER_KEY_TYPE_VERSION_1_3_ORIGINAL_SPECIFICATION = WS_SECURITY_BEARER_KEY_TYPE_VERSION.ORIGINAL_SPECIFICATION;
|
|
pub const WS_SECURITY_BEARER_KEY_TYPE_VERSION_1_3_ORIGINAL_SCHEMA = WS_SECURITY_BEARER_KEY_TYPE_VERSION.ORIGINAL_SCHEMA;
|
|
pub const WS_SECURITY_BEARER_KEY_TYPE_VERSION_1_3_ERRATA_01 = WS_SECURITY_BEARER_KEY_TYPE_VERSION.ERRATA_01;
|
|
|
|
pub const WS_TYPE = enum(i32) {
|
|
BOOL_TYPE = 0,
|
|
INT8_TYPE = 1,
|
|
INT16_TYPE = 2,
|
|
INT32_TYPE = 3,
|
|
INT64_TYPE = 4,
|
|
UINT8_TYPE = 5,
|
|
UINT16_TYPE = 6,
|
|
UINT32_TYPE = 7,
|
|
UINT64_TYPE = 8,
|
|
FLOAT_TYPE = 9,
|
|
DOUBLE_TYPE = 10,
|
|
DECIMAL_TYPE = 11,
|
|
DATETIME_TYPE = 12,
|
|
TIMESPAN_TYPE = 13,
|
|
GUID_TYPE = 14,
|
|
UNIQUE_ID_TYPE = 15,
|
|
STRING_TYPE = 16,
|
|
WSZ_TYPE = 17,
|
|
BYTES_TYPE = 18,
|
|
XML_STRING_TYPE = 19,
|
|
XML_QNAME_TYPE = 20,
|
|
XML_BUFFER_TYPE = 21,
|
|
CHAR_ARRAY_TYPE = 22,
|
|
UTF8_ARRAY_TYPE = 23,
|
|
BYTE_ARRAY_TYPE = 24,
|
|
DESCRIPTION_TYPE = 25,
|
|
STRUCT_TYPE = 26,
|
|
CUSTOM_TYPE = 27,
|
|
ENDPOINT_ADDRESS_TYPE = 28,
|
|
FAULT_TYPE = 29,
|
|
VOID_TYPE = 30,
|
|
ENUM_TYPE = 31,
|
|
DURATION_TYPE = 32,
|
|
UNION_TYPE = 33,
|
|
ANY_ATTRIBUTES_TYPE = 34,
|
|
};
|
|
pub const WS_BOOL_TYPE = WS_TYPE.BOOL_TYPE;
|
|
pub const WS_INT8_TYPE = WS_TYPE.INT8_TYPE;
|
|
pub const WS_INT16_TYPE = WS_TYPE.INT16_TYPE;
|
|
pub const WS_INT32_TYPE = WS_TYPE.INT32_TYPE;
|
|
pub const WS_INT64_TYPE = WS_TYPE.INT64_TYPE;
|
|
pub const WS_UINT8_TYPE = WS_TYPE.UINT8_TYPE;
|
|
pub const WS_UINT16_TYPE = WS_TYPE.UINT16_TYPE;
|
|
pub const WS_UINT32_TYPE = WS_TYPE.UINT32_TYPE;
|
|
pub const WS_UINT64_TYPE = WS_TYPE.UINT64_TYPE;
|
|
pub const WS_FLOAT_TYPE = WS_TYPE.FLOAT_TYPE;
|
|
pub const WS_DOUBLE_TYPE = WS_TYPE.DOUBLE_TYPE;
|
|
pub const WS_DECIMAL_TYPE = WS_TYPE.DECIMAL_TYPE;
|
|
pub const WS_DATETIME_TYPE = WS_TYPE.DATETIME_TYPE;
|
|
pub const WS_TIMESPAN_TYPE = WS_TYPE.TIMESPAN_TYPE;
|
|
pub const WS_GUID_TYPE = WS_TYPE.GUID_TYPE;
|
|
pub const WS_UNIQUE_ID_TYPE = WS_TYPE.UNIQUE_ID_TYPE;
|
|
pub const WS_STRING_TYPE = WS_TYPE.STRING_TYPE;
|
|
pub const WS_WSZ_TYPE = WS_TYPE.WSZ_TYPE;
|
|
pub const WS_BYTES_TYPE = WS_TYPE.BYTES_TYPE;
|
|
pub const WS_XML_STRING_TYPE = WS_TYPE.XML_STRING_TYPE;
|
|
pub const WS_XML_QNAME_TYPE = WS_TYPE.XML_QNAME_TYPE;
|
|
pub const WS_XML_BUFFER_TYPE = WS_TYPE.XML_BUFFER_TYPE;
|
|
pub const WS_CHAR_ARRAY_TYPE = WS_TYPE.CHAR_ARRAY_TYPE;
|
|
pub const WS_UTF8_ARRAY_TYPE = WS_TYPE.UTF8_ARRAY_TYPE;
|
|
pub const WS_BYTE_ARRAY_TYPE = WS_TYPE.BYTE_ARRAY_TYPE;
|
|
pub const WS_DESCRIPTION_TYPE = WS_TYPE.DESCRIPTION_TYPE;
|
|
pub const WS_STRUCT_TYPE = WS_TYPE.STRUCT_TYPE;
|
|
pub const WS_CUSTOM_TYPE = WS_TYPE.CUSTOM_TYPE;
|
|
pub const WS_ENDPOINT_ADDRESS_TYPE = WS_TYPE.ENDPOINT_ADDRESS_TYPE;
|
|
pub const WS_FAULT_TYPE = WS_TYPE.FAULT_TYPE;
|
|
pub const WS_VOID_TYPE = WS_TYPE.VOID_TYPE;
|
|
pub const WS_ENUM_TYPE = WS_TYPE.ENUM_TYPE;
|
|
pub const WS_DURATION_TYPE = WS_TYPE.DURATION_TYPE;
|
|
pub const WS_UNION_TYPE = WS_TYPE.UNION_TYPE;
|
|
pub const WS_ANY_ATTRIBUTES_TYPE = WS_TYPE.ANY_ATTRIBUTES_TYPE;
|
|
|
|
pub const WS_FIELD_MAPPING = enum(i32) {
|
|
TYPE_ATTRIBUTE_FIELD_MAPPING = 0,
|
|
ATTRIBUTE_FIELD_MAPPING = 1,
|
|
ELEMENT_FIELD_MAPPING = 2,
|
|
REPEATING_ELEMENT_FIELD_MAPPING = 3,
|
|
TEXT_FIELD_MAPPING = 4,
|
|
NO_FIELD_MAPPING = 5,
|
|
XML_ATTRIBUTE_FIELD_MAPPING = 6,
|
|
ELEMENT_CHOICE_FIELD_MAPPING = 7,
|
|
REPEATING_ELEMENT_CHOICE_FIELD_MAPPING = 8,
|
|
ANY_ELEMENT_FIELD_MAPPING = 9,
|
|
REPEATING_ANY_ELEMENT_FIELD_MAPPING = 10,
|
|
ANY_CONTENT_FIELD_MAPPING = 11,
|
|
ANY_ATTRIBUTES_FIELD_MAPPING = 12,
|
|
};
|
|
pub const WS_TYPE_ATTRIBUTE_FIELD_MAPPING = WS_FIELD_MAPPING.TYPE_ATTRIBUTE_FIELD_MAPPING;
|
|
pub const WS_ATTRIBUTE_FIELD_MAPPING = WS_FIELD_MAPPING.ATTRIBUTE_FIELD_MAPPING;
|
|
pub const WS_ELEMENT_FIELD_MAPPING = WS_FIELD_MAPPING.ELEMENT_FIELD_MAPPING;
|
|
pub const WS_REPEATING_ELEMENT_FIELD_MAPPING = WS_FIELD_MAPPING.REPEATING_ELEMENT_FIELD_MAPPING;
|
|
pub const WS_TEXT_FIELD_MAPPING = WS_FIELD_MAPPING.TEXT_FIELD_MAPPING;
|
|
pub const WS_NO_FIELD_MAPPING = WS_FIELD_MAPPING.NO_FIELD_MAPPING;
|
|
pub const WS_XML_ATTRIBUTE_FIELD_MAPPING = WS_FIELD_MAPPING.XML_ATTRIBUTE_FIELD_MAPPING;
|
|
pub const WS_ELEMENT_CHOICE_FIELD_MAPPING = WS_FIELD_MAPPING.ELEMENT_CHOICE_FIELD_MAPPING;
|
|
pub const WS_REPEATING_ELEMENT_CHOICE_FIELD_MAPPING = WS_FIELD_MAPPING.REPEATING_ELEMENT_CHOICE_FIELD_MAPPING;
|
|
pub const WS_ANY_ELEMENT_FIELD_MAPPING = WS_FIELD_MAPPING.ANY_ELEMENT_FIELD_MAPPING;
|
|
pub const WS_REPEATING_ANY_ELEMENT_FIELD_MAPPING = WS_FIELD_MAPPING.REPEATING_ANY_ELEMENT_FIELD_MAPPING;
|
|
pub const WS_ANY_CONTENT_FIELD_MAPPING = WS_FIELD_MAPPING.ANY_CONTENT_FIELD_MAPPING;
|
|
pub const WS_ANY_ATTRIBUTES_FIELD_MAPPING = WS_FIELD_MAPPING.ANY_ATTRIBUTES_FIELD_MAPPING;
|
|
|
|
pub const WS_TYPE_MAPPING = enum(i32) {
|
|
ELEMENT_TYPE_MAPPING = 1,
|
|
ATTRIBUTE_TYPE_MAPPING = 2,
|
|
ELEMENT_CONTENT_TYPE_MAPPING = 3,
|
|
ANY_ELEMENT_TYPE_MAPPING = 4,
|
|
};
|
|
pub const WS_ELEMENT_TYPE_MAPPING = WS_TYPE_MAPPING.ELEMENT_TYPE_MAPPING;
|
|
pub const WS_ATTRIBUTE_TYPE_MAPPING = WS_TYPE_MAPPING.ATTRIBUTE_TYPE_MAPPING;
|
|
pub const WS_ELEMENT_CONTENT_TYPE_MAPPING = WS_TYPE_MAPPING.ELEMENT_CONTENT_TYPE_MAPPING;
|
|
pub const WS_ANY_ELEMENT_TYPE_MAPPING = WS_TYPE_MAPPING.ANY_ELEMENT_TYPE_MAPPING;
|
|
|
|
pub const WS_READ_OPTION = enum(i32) {
|
|
REQUIRED_VALUE = 1,
|
|
REQUIRED_POINTER = 2,
|
|
OPTIONAL_POINTER = 3,
|
|
NILLABLE_POINTER = 4,
|
|
NILLABLE_VALUE = 5,
|
|
};
|
|
pub const WS_READ_REQUIRED_VALUE = WS_READ_OPTION.REQUIRED_VALUE;
|
|
pub const WS_READ_REQUIRED_POINTER = WS_READ_OPTION.REQUIRED_POINTER;
|
|
pub const WS_READ_OPTIONAL_POINTER = WS_READ_OPTION.OPTIONAL_POINTER;
|
|
pub const WS_READ_NILLABLE_POINTER = WS_READ_OPTION.NILLABLE_POINTER;
|
|
pub const WS_READ_NILLABLE_VALUE = WS_READ_OPTION.NILLABLE_VALUE;
|
|
|
|
pub const WS_WRITE_OPTION = enum(i32) {
|
|
REQUIRED_VALUE = 1,
|
|
REQUIRED_POINTER = 2,
|
|
NILLABLE_VALUE = 3,
|
|
NILLABLE_POINTER = 4,
|
|
};
|
|
pub const WS_WRITE_REQUIRED_VALUE = WS_WRITE_OPTION.REQUIRED_VALUE;
|
|
pub const WS_WRITE_REQUIRED_POINTER = WS_WRITE_OPTION.REQUIRED_POINTER;
|
|
pub const WS_WRITE_NILLABLE_VALUE = WS_WRITE_OPTION.NILLABLE_VALUE;
|
|
pub const WS_WRITE_NILLABLE_POINTER = WS_WRITE_OPTION.NILLABLE_POINTER;
|
|
|
|
pub const WS_SERVICE_CANCEL_REASON = enum(i32) {
|
|
HOST_ABORT = 0,
|
|
CHANNEL_FAULTED = 1,
|
|
};
|
|
pub const WS_SERVICE_HOST_ABORT = WS_SERVICE_CANCEL_REASON.HOST_ABORT;
|
|
pub const WS_SERVICE_CHANNEL_FAULTED = WS_SERVICE_CANCEL_REASON.CHANNEL_FAULTED;
|
|
|
|
pub const WS_OPERATION_STYLE = enum(i32) {
|
|
NON_RPC_LITERAL_OPERATION = 0,
|
|
RPC_LITERAL_OPERATION = 1,
|
|
};
|
|
pub const WS_NON_RPC_LITERAL_OPERATION = WS_OPERATION_STYLE.NON_RPC_LITERAL_OPERATION;
|
|
pub const WS_RPC_LITERAL_OPERATION = WS_OPERATION_STYLE.RPC_LITERAL_OPERATION;
|
|
|
|
pub const WS_PARAMETER_TYPE = enum(i32) {
|
|
NORMAL = 0,
|
|
ARRAY = 1,
|
|
ARRAY_COUNT = 2,
|
|
MESSAGES = 3,
|
|
};
|
|
pub const WS_PARAMETER_TYPE_NORMAL = WS_PARAMETER_TYPE.NORMAL;
|
|
pub const WS_PARAMETER_TYPE_ARRAY = WS_PARAMETER_TYPE.ARRAY;
|
|
pub const WS_PARAMETER_TYPE_ARRAY_COUNT = WS_PARAMETER_TYPE.ARRAY_COUNT;
|
|
pub const WS_PARAMETER_TYPE_MESSAGES = WS_PARAMETER_TYPE.MESSAGES;
|
|
|
|
pub const WS_SERVICE_ENDPOINT_PROPERTY_ID = enum(i32) {
|
|
ACCEPT_CHANNEL_CALLBACK = 0,
|
|
CLOSE_CHANNEL_CALLBACK = 1,
|
|
MAX_ACCEPTING_CHANNELS = 2,
|
|
MAX_CONCURRENCY = 3,
|
|
BODY_HEAP_MAX_SIZE = 4,
|
|
BODY_HEAP_TRIM_SIZE = 5,
|
|
MESSAGE_PROPERTIES = 6,
|
|
MAX_CALL_POOL_SIZE = 7,
|
|
MAX_CHANNEL_POOL_SIZE = 8,
|
|
LISTENER_PROPERTIES = 9,
|
|
CHECK_MUST_UNDERSTAND = 10,
|
|
METADATA_EXCHANGE_TYPE = 11,
|
|
METADATA = 12,
|
|
METADATA_EXCHANGE_URL_SUFFIX = 13,
|
|
MAX_CHANNELS = 14,
|
|
};
|
|
pub const WS_SERVICE_ENDPOINT_PROPERTY_ACCEPT_CHANNEL_CALLBACK = WS_SERVICE_ENDPOINT_PROPERTY_ID.ACCEPT_CHANNEL_CALLBACK;
|
|
pub const WS_SERVICE_ENDPOINT_PROPERTY_CLOSE_CHANNEL_CALLBACK = WS_SERVICE_ENDPOINT_PROPERTY_ID.CLOSE_CHANNEL_CALLBACK;
|
|
pub const WS_SERVICE_ENDPOINT_PROPERTY_MAX_ACCEPTING_CHANNELS = WS_SERVICE_ENDPOINT_PROPERTY_ID.MAX_ACCEPTING_CHANNELS;
|
|
pub const WS_SERVICE_ENDPOINT_PROPERTY_MAX_CONCURRENCY = WS_SERVICE_ENDPOINT_PROPERTY_ID.MAX_CONCURRENCY;
|
|
pub const WS_SERVICE_ENDPOINT_PROPERTY_BODY_HEAP_MAX_SIZE = WS_SERVICE_ENDPOINT_PROPERTY_ID.BODY_HEAP_MAX_SIZE;
|
|
pub const WS_SERVICE_ENDPOINT_PROPERTY_BODY_HEAP_TRIM_SIZE = WS_SERVICE_ENDPOINT_PROPERTY_ID.BODY_HEAP_TRIM_SIZE;
|
|
pub const WS_SERVICE_ENDPOINT_PROPERTY_MESSAGE_PROPERTIES = WS_SERVICE_ENDPOINT_PROPERTY_ID.MESSAGE_PROPERTIES;
|
|
pub const WS_SERVICE_ENDPOINT_PROPERTY_MAX_CALL_POOL_SIZE = WS_SERVICE_ENDPOINT_PROPERTY_ID.MAX_CALL_POOL_SIZE;
|
|
pub const WS_SERVICE_ENDPOINT_PROPERTY_MAX_CHANNEL_POOL_SIZE = WS_SERVICE_ENDPOINT_PROPERTY_ID.MAX_CHANNEL_POOL_SIZE;
|
|
pub const WS_SERVICE_ENDPOINT_PROPERTY_LISTENER_PROPERTIES = WS_SERVICE_ENDPOINT_PROPERTY_ID.LISTENER_PROPERTIES;
|
|
pub const WS_SERVICE_ENDPOINT_PROPERTY_CHECK_MUST_UNDERSTAND = WS_SERVICE_ENDPOINT_PROPERTY_ID.CHECK_MUST_UNDERSTAND;
|
|
pub const WS_SERVICE_ENDPOINT_PROPERTY_METADATA_EXCHANGE_TYPE = WS_SERVICE_ENDPOINT_PROPERTY_ID.METADATA_EXCHANGE_TYPE;
|
|
pub const WS_SERVICE_ENDPOINT_PROPERTY_METADATA = WS_SERVICE_ENDPOINT_PROPERTY_ID.METADATA;
|
|
pub const WS_SERVICE_ENDPOINT_PROPERTY_METADATA_EXCHANGE_URL_SUFFIX = WS_SERVICE_ENDPOINT_PROPERTY_ID.METADATA_EXCHANGE_URL_SUFFIX;
|
|
pub const WS_SERVICE_ENDPOINT_PROPERTY_MAX_CHANNELS = WS_SERVICE_ENDPOINT_PROPERTY_ID.MAX_CHANNELS;
|
|
|
|
pub const WS_METADATA_EXCHANGE_TYPE = enum(i32) {
|
|
NONE = 0,
|
|
MEX = 1,
|
|
HTTP_GET = 2,
|
|
};
|
|
pub const WS_METADATA_EXCHANGE_TYPE_NONE = WS_METADATA_EXCHANGE_TYPE.NONE;
|
|
pub const WS_METADATA_EXCHANGE_TYPE_MEX = WS_METADATA_EXCHANGE_TYPE.MEX;
|
|
pub const WS_METADATA_EXCHANGE_TYPE_HTTP_GET = WS_METADATA_EXCHANGE_TYPE.HTTP_GET;
|
|
|
|
pub const WS_SERVICE_PROPERTY_ID = enum(i32) {
|
|
HOST_USER_STATE = 0,
|
|
FAULT_DISCLOSURE = 1,
|
|
FAULT_LANGID = 2,
|
|
HOST_STATE = 3,
|
|
METADATA = 4,
|
|
CLOSE_TIMEOUT = 5,
|
|
};
|
|
pub const WS_SERVICE_PROPERTY_HOST_USER_STATE = WS_SERVICE_PROPERTY_ID.HOST_USER_STATE;
|
|
pub const WS_SERVICE_PROPERTY_FAULT_DISCLOSURE = WS_SERVICE_PROPERTY_ID.FAULT_DISCLOSURE;
|
|
pub const WS_SERVICE_PROPERTY_FAULT_LANGID = WS_SERVICE_PROPERTY_ID.FAULT_LANGID;
|
|
pub const WS_SERVICE_PROPERTY_HOST_STATE = WS_SERVICE_PROPERTY_ID.HOST_STATE;
|
|
pub const WS_SERVICE_PROPERTY_METADATA = WS_SERVICE_PROPERTY_ID.METADATA;
|
|
pub const WS_SERVICE_PROPERTY_CLOSE_TIMEOUT = WS_SERVICE_PROPERTY_ID.CLOSE_TIMEOUT;
|
|
|
|
pub const WS_SERVICE_HOST_STATE = enum(i32) {
|
|
CREATED = 0,
|
|
OPENING = 1,
|
|
OPEN = 2,
|
|
CLOSING = 3,
|
|
CLOSED = 4,
|
|
FAULTED = 5,
|
|
};
|
|
pub const WS_SERVICE_HOST_STATE_CREATED = WS_SERVICE_HOST_STATE.CREATED;
|
|
pub const WS_SERVICE_HOST_STATE_OPENING = WS_SERVICE_HOST_STATE.OPENING;
|
|
pub const WS_SERVICE_HOST_STATE_OPEN = WS_SERVICE_HOST_STATE.OPEN;
|
|
pub const WS_SERVICE_HOST_STATE_CLOSING = WS_SERVICE_HOST_STATE.CLOSING;
|
|
pub const WS_SERVICE_HOST_STATE_CLOSED = WS_SERVICE_HOST_STATE.CLOSED;
|
|
pub const WS_SERVICE_HOST_STATE_FAULTED = WS_SERVICE_HOST_STATE.FAULTED;
|
|
|
|
pub const WS_SERVICE_PROXY_STATE = enum(i32) {
|
|
CREATED = 0,
|
|
OPENING = 1,
|
|
OPEN = 2,
|
|
CLOSING = 3,
|
|
CLOSED = 4,
|
|
FAULTED = 5,
|
|
};
|
|
pub const WS_SERVICE_PROXY_STATE_CREATED = WS_SERVICE_PROXY_STATE.CREATED;
|
|
pub const WS_SERVICE_PROXY_STATE_OPENING = WS_SERVICE_PROXY_STATE.OPENING;
|
|
pub const WS_SERVICE_PROXY_STATE_OPEN = WS_SERVICE_PROXY_STATE.OPEN;
|
|
pub const WS_SERVICE_PROXY_STATE_CLOSING = WS_SERVICE_PROXY_STATE.CLOSING;
|
|
pub const WS_SERVICE_PROXY_STATE_CLOSED = WS_SERVICE_PROXY_STATE.CLOSED;
|
|
pub const WS_SERVICE_PROXY_STATE_FAULTED = WS_SERVICE_PROXY_STATE.FAULTED;
|
|
|
|
pub const WS_PROXY_PROPERTY_ID = enum(i32) {
|
|
PROPERTY_CALL_TIMEOUT = 0,
|
|
PROPERTY_MESSAGE_PROPERTIES = 1,
|
|
PROPERTY_MAX_CALL_POOL_SIZE = 2,
|
|
PROPERTY_STATE = 3,
|
|
PROPERTY_MAX_PENDING_CALLS = 4,
|
|
PROPERTY_MAX_CLOSE_TIMEOUT = 5,
|
|
FAULT_LANG_ID = 6,
|
|
};
|
|
pub const WS_PROXY_PROPERTY_CALL_TIMEOUT = WS_PROXY_PROPERTY_ID.PROPERTY_CALL_TIMEOUT;
|
|
pub const WS_PROXY_PROPERTY_MESSAGE_PROPERTIES = WS_PROXY_PROPERTY_ID.PROPERTY_MESSAGE_PROPERTIES;
|
|
pub const WS_PROXY_PROPERTY_MAX_CALL_POOL_SIZE = WS_PROXY_PROPERTY_ID.PROPERTY_MAX_CALL_POOL_SIZE;
|
|
pub const WS_PROXY_PROPERTY_STATE = WS_PROXY_PROPERTY_ID.PROPERTY_STATE;
|
|
pub const WS_PROXY_PROPERTY_MAX_PENDING_CALLS = WS_PROXY_PROPERTY_ID.PROPERTY_MAX_PENDING_CALLS;
|
|
pub const WS_PROXY_PROPERTY_MAX_CLOSE_TIMEOUT = WS_PROXY_PROPERTY_ID.PROPERTY_MAX_CLOSE_TIMEOUT;
|
|
pub const WS_PROXY_FAULT_LANG_ID = WS_PROXY_PROPERTY_ID.FAULT_LANG_ID;
|
|
|
|
pub const WS_CALL_PROPERTY_ID = enum(i32) {
|
|
CHECK_MUST_UNDERSTAND = 0,
|
|
SEND_MESSAGE_CONTEXT = 1,
|
|
RECEIVE_MESSAGE_CONTEXT = 2,
|
|
CALL_ID = 3,
|
|
};
|
|
pub const WS_CALL_PROPERTY_CHECK_MUST_UNDERSTAND = WS_CALL_PROPERTY_ID.CHECK_MUST_UNDERSTAND;
|
|
pub const WS_CALL_PROPERTY_SEND_MESSAGE_CONTEXT = WS_CALL_PROPERTY_ID.SEND_MESSAGE_CONTEXT;
|
|
pub const WS_CALL_PROPERTY_RECEIVE_MESSAGE_CONTEXT = WS_CALL_PROPERTY_ID.RECEIVE_MESSAGE_CONTEXT;
|
|
pub const WS_CALL_PROPERTY_CALL_ID = WS_CALL_PROPERTY_ID.CALL_ID;
|
|
|
|
pub const WS_TRACE_API = enum(i32) {
|
|
NONE = -1,
|
|
START_READER_CANONICALIZATION = 0,
|
|
END_READER_CANONICALIZATION = 1,
|
|
START_WRITER_CANONICALIZATION = 2,
|
|
END_WRITER_CANONICALIZATION = 3,
|
|
CREATE_XML_BUFFER = 4,
|
|
REMOVE_NODE = 5,
|
|
CREATE_READER = 6,
|
|
SET_INPUT = 7,
|
|
SET_INPUT_TO_BUFFER = 8,
|
|
FREE_XML_READER = 9,
|
|
GET_READER_PROPERTY = 10,
|
|
GET_READER_NODE = 11,
|
|
FILL_READER = 12,
|
|
READ_START_ELEMENT = 13,
|
|
READ_TO_START_ELEMENT = 14,
|
|
READ_START_ATTRIBUTE = 15,
|
|
READ_END_ATTRIBUTE = 16,
|
|
READ_NODE = 17,
|
|
SKIP_NODE = 18,
|
|
READ_END_ELEMENT = 19,
|
|
FIND_ATTRIBUTE = 20,
|
|
READ_ELEMENT_VALUE = 21,
|
|
READ_CHARS = 22,
|
|
READ_CHARS_UTF8 = 23,
|
|
READ_BYTES = 24,
|
|
READ_ARRAY = 25,
|
|
GET_READER_POSITION = 26,
|
|
SET_READER_POSITION = 27,
|
|
MOVE_READER = 28,
|
|
CREATE_WRITER = 29,
|
|
FREE_XML_WRITER = 30,
|
|
SET_OUTPUT = 31,
|
|
SET_OUTPUT_TO_BUFFER = 32,
|
|
GET_WRITER_PROPERTY = 33,
|
|
FLUSH_WRITER = 34,
|
|
WRITE_START_ELEMENT = 35,
|
|
WRITE_END_START_ELEMENT = 36,
|
|
WRITE_XMLNS_ATTRIBUTE = 37,
|
|
WRITE_START_ATTRIBUTE = 38,
|
|
WRITE_END_ATTRIBUTE = 39,
|
|
WRITE_VALUE = 40,
|
|
WRITE_XML_BUFFER = 41,
|
|
READ_XML_BUFFER = 42,
|
|
WRITE_XML_BUFFER_TO_BYTES = 43,
|
|
READ_XML_BUFFER_FROM_BYTES = 44,
|
|
WRITE_ARRAY = 45,
|
|
WRITE_QUALIFIED_NAME = 46,
|
|
WRITE_CHARS = 47,
|
|
WRITE_CHARS_UTF8 = 48,
|
|
WRITE_BYTES = 49,
|
|
PUSH_BYTES = 50,
|
|
PULL_BYTES = 51,
|
|
WRITE_END_ELEMENT = 52,
|
|
WRITE_TEXT = 53,
|
|
WRITE_START_CDATA = 54,
|
|
WRITE_END_CDATA = 55,
|
|
WRITE_NODE = 56,
|
|
PREFIX_FROM_NAMESPACE = 57,
|
|
GET_WRITER_POSITION = 58,
|
|
SET_WRITER_POSITION = 59,
|
|
MOVE_WRITER = 60,
|
|
TRIM_XML_WHITESPACE = 61,
|
|
VERIFY_XML_NCNAME = 62,
|
|
XML_STRING_EQUALS = 63,
|
|
NAMESPACE_FROM_PREFIX = 64,
|
|
READ_QUALIFIED_NAME = 65,
|
|
GET_XML_ATTRIBUTE = 66,
|
|
COPY_NODE = 67,
|
|
ASYNC_EXECUTE = 68,
|
|
CREATE_CHANNEL = 69,
|
|
OPEN_CHANNEL = 70,
|
|
SEND_MESSAGE = 71,
|
|
RECEIVE_MESSAGE = 72,
|
|
REQUEST_REPLY = 73,
|
|
SEND_REPLY_MESSAGE = 74,
|
|
SEND_FAULT_MESSAGE_FOR_ERROR = 75,
|
|
GET_CHANNEL_PROPERTY = 76,
|
|
SET_CHANNEL_PROPERTY = 77,
|
|
WRITE_MESSAGE_START = 78,
|
|
WRITE_MESSAGE_END = 79,
|
|
READ_MESSAGE_START = 80,
|
|
READ_MESSAGE_END = 81,
|
|
CLOSE_CHANNEL = 82,
|
|
ABORT_CHANNEL = 83,
|
|
FREE_CHANNEL = 84,
|
|
RESET_CHANNEL = 85,
|
|
ABANDON_MESSAGE = 86,
|
|
SHUTDOWN_SESSION_CHANNEL = 87,
|
|
GET_CONTEXT_PROPERTY = 88,
|
|
GET_DICTIONARY = 89,
|
|
READ_ENDPOINT_ADDRESS_EXTENSION = 90,
|
|
CREATE_ERROR = 91,
|
|
ADD_ERROR_STRING = 92,
|
|
GET_ERROR_STRING = 93,
|
|
COPY_ERROR = 94,
|
|
GET_ERROR_PROPERTY = 95,
|
|
SET_ERROR_PROPERTY = 96,
|
|
RESET_ERROR = 97,
|
|
FREE_ERROR = 98,
|
|
GET_FAULT_ERROR_PROPERTY = 99,
|
|
SET_FAULT_ERROR_PROPERTY = 100,
|
|
CREATE_FAULT_FROM_ERROR = 101,
|
|
SET_FAULT_ERROR_DETAIL = 102,
|
|
GET_FAULT_ERROR_DETAIL = 103,
|
|
CREATE_HEAP = 104,
|
|
ALLOC = 105,
|
|
GET_HEAP_PROPERTY = 106,
|
|
RESET_HEAP = 107,
|
|
FREE_HEAP = 108,
|
|
CREATE_LISTENER = 109,
|
|
OPEN_LISTENER = 110,
|
|
ACCEPT_CHANNEL = 111,
|
|
CLOSE_LISTENER = 112,
|
|
ABORT_LISTENER = 113,
|
|
RESET_LISTENER = 114,
|
|
FREE_LISTENER = 115,
|
|
GET_LISTENER_PROPERTY = 116,
|
|
SET_LISTENER_PROPERTY = 117,
|
|
CREATE_CHANNEL_FOR_LISTENER = 118,
|
|
CREATE_MESSAGE = 119,
|
|
CREATE_MESSAGE_FOR_CHANNEL = 120,
|
|
INITIALIZE_MESSAGE = 121,
|
|
RESET_MESSAGE = 122,
|
|
FREE_MESSAGE = 123,
|
|
GET_HEADER_ATTRIBUTES = 124,
|
|
GET_HEADER = 125,
|
|
GET_CUSTOM_HEADER = 126,
|
|
REMOVE_HEADER = 127,
|
|
SET_HEADER = 128,
|
|
REMOVE_CUSTOM_HEADER = 129,
|
|
ADD_CUSTOM_HEADER = 130,
|
|
ADD_MAPPED_HEADER = 131,
|
|
REMOVE_MAPPED_HEADER = 132,
|
|
GET_MAPPED_HEADER = 133,
|
|
WRITE_BODY = 134,
|
|
READ_BODY = 135,
|
|
WRITE_ENVELOPE_START = 136,
|
|
WRITE_ENVELOPE_END = 137,
|
|
READ_ENVELOPE_START = 138,
|
|
READ_ENVELOPE_END = 139,
|
|
GET_MESSAGE_PROPERTY = 140,
|
|
SET_MESSAGE_PROPERTY = 141,
|
|
ADDRESS_MESSAGE = 142,
|
|
CHECK_MUST_UNDERSTAND_HEADERS = 143,
|
|
MARK_HEADER_AS_UNDERSTOOD = 144,
|
|
FILL_BODY = 145,
|
|
FLUSH_BODY = 146,
|
|
REQUEST_SECURITY_TOKEN = 147,
|
|
GET_SECURITY_TOKEN_PROPERTY = 148,
|
|
CREATE_XML_SECURITY_TOKEN = 149,
|
|
FREE_SECURITY_TOKEN = 150,
|
|
REVOKE_SECURITY_CONTEXT = 151,
|
|
GET_SECURITY_CONTEXT_PROPERTY = 152,
|
|
READ_ELEMENT_TYPE = 153,
|
|
READ_ATTRIBUTE_TYPE = 154,
|
|
READ_TYPE = 155,
|
|
WRITE_ELEMENT_TYPE = 156,
|
|
WRITE_ATTRIBUTE_TYPE = 157,
|
|
WRITE_TYPE = 158,
|
|
SERVICE_REGISTER_FOR_CANCEL = 159,
|
|
GET_SERVICE_HOST_PROPERTY = 160,
|
|
CREATE_SERVICE_HOST = 161,
|
|
OPEN_SERVICE_HOST = 162,
|
|
CLOSE_SERVICE_HOST = 163,
|
|
ABORT_SERVICE_HOST = 164,
|
|
FREE_SERVICE_HOST = 165,
|
|
RESET_SERVICE_HOST = 166,
|
|
GET_SERVICE_PROXY_PROPERTY = 167,
|
|
CREATE_SERVICE_PROXY = 168,
|
|
OPEN_SERVICE_PROXY = 169,
|
|
CLOSE_SERVICE_PROXY = 170,
|
|
ABORT_SERVICE_PROXY = 171,
|
|
FREE_SERVICE_PROXY = 172,
|
|
RESET_SERVICE_PROXY = 173,
|
|
ABORT_CALL = 174,
|
|
CALL = 175,
|
|
DECODE_URL = 176,
|
|
ENCODE_URL = 177,
|
|
COMBINE_URL = 178,
|
|
DATETIME_TO_FILETIME = 179,
|
|
FILETIME_TO_DATETIME = 180,
|
|
DUMP_MEMORY = 181,
|
|
SET_AUTOFAIL = 182,
|
|
CREATE_METADATA = 183,
|
|
READ_METADATA = 184,
|
|
FREE_METADATA = 185,
|
|
RESET_METADATA = 186,
|
|
GET_METADATA_PROPERTY = 187,
|
|
GET_MISSING_METADATA_DOCUMENT_ADDRESS = 188,
|
|
GET_METADATA_ENDPOINTS = 189,
|
|
MATCH_POLICY_ALTERNATIVE = 190,
|
|
GET_POLICY_PROPERTY = 191,
|
|
GET_POLICY_ALTERNATIVE_COUNT = 192,
|
|
WS_CREATE_SERVICE_PROXY_FROM_TEMPLATE = 193,
|
|
WS_CREATE_SERVICE_HOST_FROM_TEMPLATE = 194,
|
|
};
|
|
pub const WS_TRACE_API_NONE = WS_TRACE_API.NONE;
|
|
pub const WS_TRACE_API_START_READER_CANONICALIZATION = WS_TRACE_API.START_READER_CANONICALIZATION;
|
|
pub const WS_TRACE_API_END_READER_CANONICALIZATION = WS_TRACE_API.END_READER_CANONICALIZATION;
|
|
pub const WS_TRACE_API_START_WRITER_CANONICALIZATION = WS_TRACE_API.START_WRITER_CANONICALIZATION;
|
|
pub const WS_TRACE_API_END_WRITER_CANONICALIZATION = WS_TRACE_API.END_WRITER_CANONICALIZATION;
|
|
pub const WS_TRACE_API_CREATE_XML_BUFFER = WS_TRACE_API.CREATE_XML_BUFFER;
|
|
pub const WS_TRACE_API_REMOVE_NODE = WS_TRACE_API.REMOVE_NODE;
|
|
pub const WS_TRACE_API_CREATE_READER = WS_TRACE_API.CREATE_READER;
|
|
pub const WS_TRACE_API_SET_INPUT = WS_TRACE_API.SET_INPUT;
|
|
pub const WS_TRACE_API_SET_INPUT_TO_BUFFER = WS_TRACE_API.SET_INPUT_TO_BUFFER;
|
|
pub const WS_TRACE_API_FREE_XML_READER = WS_TRACE_API.FREE_XML_READER;
|
|
pub const WS_TRACE_API_GET_READER_PROPERTY = WS_TRACE_API.GET_READER_PROPERTY;
|
|
pub const WS_TRACE_API_GET_READER_NODE = WS_TRACE_API.GET_READER_NODE;
|
|
pub const WS_TRACE_API_FILL_READER = WS_TRACE_API.FILL_READER;
|
|
pub const WS_TRACE_API_READ_START_ELEMENT = WS_TRACE_API.READ_START_ELEMENT;
|
|
pub const WS_TRACE_API_READ_TO_START_ELEMENT = WS_TRACE_API.READ_TO_START_ELEMENT;
|
|
pub const WS_TRACE_API_READ_START_ATTRIBUTE = WS_TRACE_API.READ_START_ATTRIBUTE;
|
|
pub const WS_TRACE_API_READ_END_ATTRIBUTE = WS_TRACE_API.READ_END_ATTRIBUTE;
|
|
pub const WS_TRACE_API_READ_NODE = WS_TRACE_API.READ_NODE;
|
|
pub const WS_TRACE_API_SKIP_NODE = WS_TRACE_API.SKIP_NODE;
|
|
pub const WS_TRACE_API_READ_END_ELEMENT = WS_TRACE_API.READ_END_ELEMENT;
|
|
pub const WS_TRACE_API_FIND_ATTRIBUTE = WS_TRACE_API.FIND_ATTRIBUTE;
|
|
pub const WS_TRACE_API_READ_ELEMENT_VALUE = WS_TRACE_API.READ_ELEMENT_VALUE;
|
|
pub const WS_TRACE_API_READ_CHARS = WS_TRACE_API.READ_CHARS;
|
|
pub const WS_TRACE_API_READ_CHARS_UTF8 = WS_TRACE_API.READ_CHARS_UTF8;
|
|
pub const WS_TRACE_API_READ_BYTES = WS_TRACE_API.READ_BYTES;
|
|
pub const WS_TRACE_API_READ_ARRAY = WS_TRACE_API.READ_ARRAY;
|
|
pub const WS_TRACE_API_GET_READER_POSITION = WS_TRACE_API.GET_READER_POSITION;
|
|
pub const WS_TRACE_API_SET_READER_POSITION = WS_TRACE_API.SET_READER_POSITION;
|
|
pub const WS_TRACE_API_MOVE_READER = WS_TRACE_API.MOVE_READER;
|
|
pub const WS_TRACE_API_CREATE_WRITER = WS_TRACE_API.CREATE_WRITER;
|
|
pub const WS_TRACE_API_FREE_XML_WRITER = WS_TRACE_API.FREE_XML_WRITER;
|
|
pub const WS_TRACE_API_SET_OUTPUT = WS_TRACE_API.SET_OUTPUT;
|
|
pub const WS_TRACE_API_SET_OUTPUT_TO_BUFFER = WS_TRACE_API.SET_OUTPUT_TO_BUFFER;
|
|
pub const WS_TRACE_API_GET_WRITER_PROPERTY = WS_TRACE_API.GET_WRITER_PROPERTY;
|
|
pub const WS_TRACE_API_FLUSH_WRITER = WS_TRACE_API.FLUSH_WRITER;
|
|
pub const WS_TRACE_API_WRITE_START_ELEMENT = WS_TRACE_API.WRITE_START_ELEMENT;
|
|
pub const WS_TRACE_API_WRITE_END_START_ELEMENT = WS_TRACE_API.WRITE_END_START_ELEMENT;
|
|
pub const WS_TRACE_API_WRITE_XMLNS_ATTRIBUTE = WS_TRACE_API.WRITE_XMLNS_ATTRIBUTE;
|
|
pub const WS_TRACE_API_WRITE_START_ATTRIBUTE = WS_TRACE_API.WRITE_START_ATTRIBUTE;
|
|
pub const WS_TRACE_API_WRITE_END_ATTRIBUTE = WS_TRACE_API.WRITE_END_ATTRIBUTE;
|
|
pub const WS_TRACE_API_WRITE_VALUE = WS_TRACE_API.WRITE_VALUE;
|
|
pub const WS_TRACE_API_WRITE_XML_BUFFER = WS_TRACE_API.WRITE_XML_BUFFER;
|
|
pub const WS_TRACE_API_READ_XML_BUFFER = WS_TRACE_API.READ_XML_BUFFER;
|
|
pub const WS_TRACE_API_WRITE_XML_BUFFER_TO_BYTES = WS_TRACE_API.WRITE_XML_BUFFER_TO_BYTES;
|
|
pub const WS_TRACE_API_READ_XML_BUFFER_FROM_BYTES = WS_TRACE_API.READ_XML_BUFFER_FROM_BYTES;
|
|
pub const WS_TRACE_API_WRITE_ARRAY = WS_TRACE_API.WRITE_ARRAY;
|
|
pub const WS_TRACE_API_WRITE_QUALIFIED_NAME = WS_TRACE_API.WRITE_QUALIFIED_NAME;
|
|
pub const WS_TRACE_API_WRITE_CHARS = WS_TRACE_API.WRITE_CHARS;
|
|
pub const WS_TRACE_API_WRITE_CHARS_UTF8 = WS_TRACE_API.WRITE_CHARS_UTF8;
|
|
pub const WS_TRACE_API_WRITE_BYTES = WS_TRACE_API.WRITE_BYTES;
|
|
pub const WS_TRACE_API_PUSH_BYTES = WS_TRACE_API.PUSH_BYTES;
|
|
pub const WS_TRACE_API_PULL_BYTES = WS_TRACE_API.PULL_BYTES;
|
|
pub const WS_TRACE_API_WRITE_END_ELEMENT = WS_TRACE_API.WRITE_END_ELEMENT;
|
|
pub const WS_TRACE_API_WRITE_TEXT = WS_TRACE_API.WRITE_TEXT;
|
|
pub const WS_TRACE_API_WRITE_START_CDATA = WS_TRACE_API.WRITE_START_CDATA;
|
|
pub const WS_TRACE_API_WRITE_END_CDATA = WS_TRACE_API.WRITE_END_CDATA;
|
|
pub const WS_TRACE_API_WRITE_NODE = WS_TRACE_API.WRITE_NODE;
|
|
pub const WS_TRACE_API_PREFIX_FROM_NAMESPACE = WS_TRACE_API.PREFIX_FROM_NAMESPACE;
|
|
pub const WS_TRACE_API_GET_WRITER_POSITION = WS_TRACE_API.GET_WRITER_POSITION;
|
|
pub const WS_TRACE_API_SET_WRITER_POSITION = WS_TRACE_API.SET_WRITER_POSITION;
|
|
pub const WS_TRACE_API_MOVE_WRITER = WS_TRACE_API.MOVE_WRITER;
|
|
pub const WS_TRACE_API_TRIM_XML_WHITESPACE = WS_TRACE_API.TRIM_XML_WHITESPACE;
|
|
pub const WS_TRACE_API_VERIFY_XML_NCNAME = WS_TRACE_API.VERIFY_XML_NCNAME;
|
|
pub const WS_TRACE_API_XML_STRING_EQUALS = WS_TRACE_API.XML_STRING_EQUALS;
|
|
pub const WS_TRACE_API_NAMESPACE_FROM_PREFIX = WS_TRACE_API.NAMESPACE_FROM_PREFIX;
|
|
pub const WS_TRACE_API_READ_QUALIFIED_NAME = WS_TRACE_API.READ_QUALIFIED_NAME;
|
|
pub const WS_TRACE_API_GET_XML_ATTRIBUTE = WS_TRACE_API.GET_XML_ATTRIBUTE;
|
|
pub const WS_TRACE_API_COPY_NODE = WS_TRACE_API.COPY_NODE;
|
|
pub const WS_TRACE_API_ASYNC_EXECUTE = WS_TRACE_API.ASYNC_EXECUTE;
|
|
pub const WS_TRACE_API_CREATE_CHANNEL = WS_TRACE_API.CREATE_CHANNEL;
|
|
pub const WS_TRACE_API_OPEN_CHANNEL = WS_TRACE_API.OPEN_CHANNEL;
|
|
pub const WS_TRACE_API_SEND_MESSAGE = WS_TRACE_API.SEND_MESSAGE;
|
|
pub const WS_TRACE_API_RECEIVE_MESSAGE = WS_TRACE_API.RECEIVE_MESSAGE;
|
|
pub const WS_TRACE_API_REQUEST_REPLY = WS_TRACE_API.REQUEST_REPLY;
|
|
pub const WS_TRACE_API_SEND_REPLY_MESSAGE = WS_TRACE_API.SEND_REPLY_MESSAGE;
|
|
pub const WS_TRACE_API_SEND_FAULT_MESSAGE_FOR_ERROR = WS_TRACE_API.SEND_FAULT_MESSAGE_FOR_ERROR;
|
|
pub const WS_TRACE_API_GET_CHANNEL_PROPERTY = WS_TRACE_API.GET_CHANNEL_PROPERTY;
|
|
pub const WS_TRACE_API_SET_CHANNEL_PROPERTY = WS_TRACE_API.SET_CHANNEL_PROPERTY;
|
|
pub const WS_TRACE_API_WRITE_MESSAGE_START = WS_TRACE_API.WRITE_MESSAGE_START;
|
|
pub const WS_TRACE_API_WRITE_MESSAGE_END = WS_TRACE_API.WRITE_MESSAGE_END;
|
|
pub const WS_TRACE_API_READ_MESSAGE_START = WS_TRACE_API.READ_MESSAGE_START;
|
|
pub const WS_TRACE_API_READ_MESSAGE_END = WS_TRACE_API.READ_MESSAGE_END;
|
|
pub const WS_TRACE_API_CLOSE_CHANNEL = WS_TRACE_API.CLOSE_CHANNEL;
|
|
pub const WS_TRACE_API_ABORT_CHANNEL = WS_TRACE_API.ABORT_CHANNEL;
|
|
pub const WS_TRACE_API_FREE_CHANNEL = WS_TRACE_API.FREE_CHANNEL;
|
|
pub const WS_TRACE_API_RESET_CHANNEL = WS_TRACE_API.RESET_CHANNEL;
|
|
pub const WS_TRACE_API_ABANDON_MESSAGE = WS_TRACE_API.ABANDON_MESSAGE;
|
|
pub const WS_TRACE_API_SHUTDOWN_SESSION_CHANNEL = WS_TRACE_API.SHUTDOWN_SESSION_CHANNEL;
|
|
pub const WS_TRACE_API_GET_CONTEXT_PROPERTY = WS_TRACE_API.GET_CONTEXT_PROPERTY;
|
|
pub const WS_TRACE_API_GET_DICTIONARY = WS_TRACE_API.GET_DICTIONARY;
|
|
pub const WS_TRACE_API_READ_ENDPOINT_ADDRESS_EXTENSION = WS_TRACE_API.READ_ENDPOINT_ADDRESS_EXTENSION;
|
|
pub const WS_TRACE_API_CREATE_ERROR = WS_TRACE_API.CREATE_ERROR;
|
|
pub const WS_TRACE_API_ADD_ERROR_STRING = WS_TRACE_API.ADD_ERROR_STRING;
|
|
pub const WS_TRACE_API_GET_ERROR_STRING = WS_TRACE_API.GET_ERROR_STRING;
|
|
pub const WS_TRACE_API_COPY_ERROR = WS_TRACE_API.COPY_ERROR;
|
|
pub const WS_TRACE_API_GET_ERROR_PROPERTY = WS_TRACE_API.GET_ERROR_PROPERTY;
|
|
pub const WS_TRACE_API_SET_ERROR_PROPERTY = WS_TRACE_API.SET_ERROR_PROPERTY;
|
|
pub const WS_TRACE_API_RESET_ERROR = WS_TRACE_API.RESET_ERROR;
|
|
pub const WS_TRACE_API_FREE_ERROR = WS_TRACE_API.FREE_ERROR;
|
|
pub const WS_TRACE_API_GET_FAULT_ERROR_PROPERTY = WS_TRACE_API.GET_FAULT_ERROR_PROPERTY;
|
|
pub const WS_TRACE_API_SET_FAULT_ERROR_PROPERTY = WS_TRACE_API.SET_FAULT_ERROR_PROPERTY;
|
|
pub const WS_TRACE_API_CREATE_FAULT_FROM_ERROR = WS_TRACE_API.CREATE_FAULT_FROM_ERROR;
|
|
pub const WS_TRACE_API_SET_FAULT_ERROR_DETAIL = WS_TRACE_API.SET_FAULT_ERROR_DETAIL;
|
|
pub const WS_TRACE_API_GET_FAULT_ERROR_DETAIL = WS_TRACE_API.GET_FAULT_ERROR_DETAIL;
|
|
pub const WS_TRACE_API_CREATE_HEAP = WS_TRACE_API.CREATE_HEAP;
|
|
pub const WS_TRACE_API_ALLOC = WS_TRACE_API.ALLOC;
|
|
pub const WS_TRACE_API_GET_HEAP_PROPERTY = WS_TRACE_API.GET_HEAP_PROPERTY;
|
|
pub const WS_TRACE_API_RESET_HEAP = WS_TRACE_API.RESET_HEAP;
|
|
pub const WS_TRACE_API_FREE_HEAP = WS_TRACE_API.FREE_HEAP;
|
|
pub const WS_TRACE_API_CREATE_LISTENER = WS_TRACE_API.CREATE_LISTENER;
|
|
pub const WS_TRACE_API_OPEN_LISTENER = WS_TRACE_API.OPEN_LISTENER;
|
|
pub const WS_TRACE_API_ACCEPT_CHANNEL = WS_TRACE_API.ACCEPT_CHANNEL;
|
|
pub const WS_TRACE_API_CLOSE_LISTENER = WS_TRACE_API.CLOSE_LISTENER;
|
|
pub const WS_TRACE_API_ABORT_LISTENER = WS_TRACE_API.ABORT_LISTENER;
|
|
pub const WS_TRACE_API_RESET_LISTENER = WS_TRACE_API.RESET_LISTENER;
|
|
pub const WS_TRACE_API_FREE_LISTENER = WS_TRACE_API.FREE_LISTENER;
|
|
pub const WS_TRACE_API_GET_LISTENER_PROPERTY = WS_TRACE_API.GET_LISTENER_PROPERTY;
|
|
pub const WS_TRACE_API_SET_LISTENER_PROPERTY = WS_TRACE_API.SET_LISTENER_PROPERTY;
|
|
pub const WS_TRACE_API_CREATE_CHANNEL_FOR_LISTENER = WS_TRACE_API.CREATE_CHANNEL_FOR_LISTENER;
|
|
pub const WS_TRACE_API_CREATE_MESSAGE = WS_TRACE_API.CREATE_MESSAGE;
|
|
pub const WS_TRACE_API_CREATE_MESSAGE_FOR_CHANNEL = WS_TRACE_API.CREATE_MESSAGE_FOR_CHANNEL;
|
|
pub const WS_TRACE_API_INITIALIZE_MESSAGE = WS_TRACE_API.INITIALIZE_MESSAGE;
|
|
pub const WS_TRACE_API_RESET_MESSAGE = WS_TRACE_API.RESET_MESSAGE;
|
|
pub const WS_TRACE_API_FREE_MESSAGE = WS_TRACE_API.FREE_MESSAGE;
|
|
pub const WS_TRACE_API_GET_HEADER_ATTRIBUTES = WS_TRACE_API.GET_HEADER_ATTRIBUTES;
|
|
pub const WS_TRACE_API_GET_HEADER = WS_TRACE_API.GET_HEADER;
|
|
pub const WS_TRACE_API_GET_CUSTOM_HEADER = WS_TRACE_API.GET_CUSTOM_HEADER;
|
|
pub const WS_TRACE_API_REMOVE_HEADER = WS_TRACE_API.REMOVE_HEADER;
|
|
pub const WS_TRACE_API_SET_HEADER = WS_TRACE_API.SET_HEADER;
|
|
pub const WS_TRACE_API_REMOVE_CUSTOM_HEADER = WS_TRACE_API.REMOVE_CUSTOM_HEADER;
|
|
pub const WS_TRACE_API_ADD_CUSTOM_HEADER = WS_TRACE_API.ADD_CUSTOM_HEADER;
|
|
pub const WS_TRACE_API_ADD_MAPPED_HEADER = WS_TRACE_API.ADD_MAPPED_HEADER;
|
|
pub const WS_TRACE_API_REMOVE_MAPPED_HEADER = WS_TRACE_API.REMOVE_MAPPED_HEADER;
|
|
pub const WS_TRACE_API_GET_MAPPED_HEADER = WS_TRACE_API.GET_MAPPED_HEADER;
|
|
pub const WS_TRACE_API_WRITE_BODY = WS_TRACE_API.WRITE_BODY;
|
|
pub const WS_TRACE_API_READ_BODY = WS_TRACE_API.READ_BODY;
|
|
pub const WS_TRACE_API_WRITE_ENVELOPE_START = WS_TRACE_API.WRITE_ENVELOPE_START;
|
|
pub const WS_TRACE_API_WRITE_ENVELOPE_END = WS_TRACE_API.WRITE_ENVELOPE_END;
|
|
pub const WS_TRACE_API_READ_ENVELOPE_START = WS_TRACE_API.READ_ENVELOPE_START;
|
|
pub const WS_TRACE_API_READ_ENVELOPE_END = WS_TRACE_API.READ_ENVELOPE_END;
|
|
pub const WS_TRACE_API_GET_MESSAGE_PROPERTY = WS_TRACE_API.GET_MESSAGE_PROPERTY;
|
|
pub const WS_TRACE_API_SET_MESSAGE_PROPERTY = WS_TRACE_API.SET_MESSAGE_PROPERTY;
|
|
pub const WS_TRACE_API_ADDRESS_MESSAGE = WS_TRACE_API.ADDRESS_MESSAGE;
|
|
pub const WS_TRACE_API_CHECK_MUST_UNDERSTAND_HEADERS = WS_TRACE_API.CHECK_MUST_UNDERSTAND_HEADERS;
|
|
pub const WS_TRACE_API_MARK_HEADER_AS_UNDERSTOOD = WS_TRACE_API.MARK_HEADER_AS_UNDERSTOOD;
|
|
pub const WS_TRACE_API_FILL_BODY = WS_TRACE_API.FILL_BODY;
|
|
pub const WS_TRACE_API_FLUSH_BODY = WS_TRACE_API.FLUSH_BODY;
|
|
pub const WS_TRACE_API_REQUEST_SECURITY_TOKEN = WS_TRACE_API.REQUEST_SECURITY_TOKEN;
|
|
pub const WS_TRACE_API_GET_SECURITY_TOKEN_PROPERTY = WS_TRACE_API.GET_SECURITY_TOKEN_PROPERTY;
|
|
pub const WS_TRACE_API_CREATE_XML_SECURITY_TOKEN = WS_TRACE_API.CREATE_XML_SECURITY_TOKEN;
|
|
pub const WS_TRACE_API_FREE_SECURITY_TOKEN = WS_TRACE_API.FREE_SECURITY_TOKEN;
|
|
pub const WS_TRACE_API_REVOKE_SECURITY_CONTEXT = WS_TRACE_API.REVOKE_SECURITY_CONTEXT;
|
|
pub const WS_TRACE_API_GET_SECURITY_CONTEXT_PROPERTY = WS_TRACE_API.GET_SECURITY_CONTEXT_PROPERTY;
|
|
pub const WS_TRACE_API_READ_ELEMENT_TYPE = WS_TRACE_API.READ_ELEMENT_TYPE;
|
|
pub const WS_TRACE_API_READ_ATTRIBUTE_TYPE = WS_TRACE_API.READ_ATTRIBUTE_TYPE;
|
|
pub const WS_TRACE_API_READ_TYPE = WS_TRACE_API.READ_TYPE;
|
|
pub const WS_TRACE_API_WRITE_ELEMENT_TYPE = WS_TRACE_API.WRITE_ELEMENT_TYPE;
|
|
pub const WS_TRACE_API_WRITE_ATTRIBUTE_TYPE = WS_TRACE_API.WRITE_ATTRIBUTE_TYPE;
|
|
pub const WS_TRACE_API_WRITE_TYPE = WS_TRACE_API.WRITE_TYPE;
|
|
pub const WS_TRACE_API_SERVICE_REGISTER_FOR_CANCEL = WS_TRACE_API.SERVICE_REGISTER_FOR_CANCEL;
|
|
pub const WS_TRACE_API_GET_SERVICE_HOST_PROPERTY = WS_TRACE_API.GET_SERVICE_HOST_PROPERTY;
|
|
pub const WS_TRACE_API_CREATE_SERVICE_HOST = WS_TRACE_API.CREATE_SERVICE_HOST;
|
|
pub const WS_TRACE_API_OPEN_SERVICE_HOST = WS_TRACE_API.OPEN_SERVICE_HOST;
|
|
pub const WS_TRACE_API_CLOSE_SERVICE_HOST = WS_TRACE_API.CLOSE_SERVICE_HOST;
|
|
pub const WS_TRACE_API_ABORT_SERVICE_HOST = WS_TRACE_API.ABORT_SERVICE_HOST;
|
|
pub const WS_TRACE_API_FREE_SERVICE_HOST = WS_TRACE_API.FREE_SERVICE_HOST;
|
|
pub const WS_TRACE_API_RESET_SERVICE_HOST = WS_TRACE_API.RESET_SERVICE_HOST;
|
|
pub const WS_TRACE_API_GET_SERVICE_PROXY_PROPERTY = WS_TRACE_API.GET_SERVICE_PROXY_PROPERTY;
|
|
pub const WS_TRACE_API_CREATE_SERVICE_PROXY = WS_TRACE_API.CREATE_SERVICE_PROXY;
|
|
pub const WS_TRACE_API_OPEN_SERVICE_PROXY = WS_TRACE_API.OPEN_SERVICE_PROXY;
|
|
pub const WS_TRACE_API_CLOSE_SERVICE_PROXY = WS_TRACE_API.CLOSE_SERVICE_PROXY;
|
|
pub const WS_TRACE_API_ABORT_SERVICE_PROXY = WS_TRACE_API.ABORT_SERVICE_PROXY;
|
|
pub const WS_TRACE_API_FREE_SERVICE_PROXY = WS_TRACE_API.FREE_SERVICE_PROXY;
|
|
pub const WS_TRACE_API_RESET_SERVICE_PROXY = WS_TRACE_API.RESET_SERVICE_PROXY;
|
|
pub const WS_TRACE_API_ABORT_CALL = WS_TRACE_API.ABORT_CALL;
|
|
pub const WS_TRACE_API_CALL = WS_TRACE_API.CALL;
|
|
pub const WS_TRACE_API_DECODE_URL = WS_TRACE_API.DECODE_URL;
|
|
pub const WS_TRACE_API_ENCODE_URL = WS_TRACE_API.ENCODE_URL;
|
|
pub const WS_TRACE_API_COMBINE_URL = WS_TRACE_API.COMBINE_URL;
|
|
pub const WS_TRACE_API_DATETIME_TO_FILETIME = WS_TRACE_API.DATETIME_TO_FILETIME;
|
|
pub const WS_TRACE_API_FILETIME_TO_DATETIME = WS_TRACE_API.FILETIME_TO_DATETIME;
|
|
pub const WS_TRACE_API_DUMP_MEMORY = WS_TRACE_API.DUMP_MEMORY;
|
|
pub const WS_TRACE_API_SET_AUTOFAIL = WS_TRACE_API.SET_AUTOFAIL;
|
|
pub const WS_TRACE_API_CREATE_METADATA = WS_TRACE_API.CREATE_METADATA;
|
|
pub const WS_TRACE_API_READ_METADATA = WS_TRACE_API.READ_METADATA;
|
|
pub const WS_TRACE_API_FREE_METADATA = WS_TRACE_API.FREE_METADATA;
|
|
pub const WS_TRACE_API_RESET_METADATA = WS_TRACE_API.RESET_METADATA;
|
|
pub const WS_TRACE_API_GET_METADATA_PROPERTY = WS_TRACE_API.GET_METADATA_PROPERTY;
|
|
pub const WS_TRACE_API_GET_MISSING_METADATA_DOCUMENT_ADDRESS = WS_TRACE_API.GET_MISSING_METADATA_DOCUMENT_ADDRESS;
|
|
pub const WS_TRACE_API_GET_METADATA_ENDPOINTS = WS_TRACE_API.GET_METADATA_ENDPOINTS;
|
|
pub const WS_TRACE_API_MATCH_POLICY_ALTERNATIVE = WS_TRACE_API.MATCH_POLICY_ALTERNATIVE;
|
|
pub const WS_TRACE_API_GET_POLICY_PROPERTY = WS_TRACE_API.GET_POLICY_PROPERTY;
|
|
pub const WS_TRACE_API_GET_POLICY_ALTERNATIVE_COUNT = WS_TRACE_API.GET_POLICY_ALTERNATIVE_COUNT;
|
|
pub const WS_TRACE_API_WS_CREATE_SERVICE_PROXY_FROM_TEMPLATE = WS_TRACE_API.WS_CREATE_SERVICE_PROXY_FROM_TEMPLATE;
|
|
pub const WS_TRACE_API_WS_CREATE_SERVICE_HOST_FROM_TEMPLATE = WS_TRACE_API.WS_CREATE_SERVICE_HOST_FROM_TEMPLATE;
|
|
|
|
pub const WS_URL_SCHEME_TYPE = enum(i32) {
|
|
HTTP_SCHEME_TYPE = 0,
|
|
HTTPS_SCHEME_TYPE = 1,
|
|
NETTCP_SCHEME_TYPE = 2,
|
|
SOAPUDP_SCHEME_TYPE = 3,
|
|
NETPIPE_SCHEME_TYPE = 4,
|
|
};
|
|
pub const WS_URL_HTTP_SCHEME_TYPE = WS_URL_SCHEME_TYPE.HTTP_SCHEME_TYPE;
|
|
pub const WS_URL_HTTPS_SCHEME_TYPE = WS_URL_SCHEME_TYPE.HTTPS_SCHEME_TYPE;
|
|
pub const WS_URL_NETTCP_SCHEME_TYPE = WS_URL_SCHEME_TYPE.NETTCP_SCHEME_TYPE;
|
|
pub const WS_URL_SOAPUDP_SCHEME_TYPE = WS_URL_SCHEME_TYPE.SOAPUDP_SCHEME_TYPE;
|
|
pub const WS_URL_NETPIPE_SCHEME_TYPE = WS_URL_SCHEME_TYPE.NETPIPE_SCHEME_TYPE;
|
|
|
|
pub const WS_DATETIME_FORMAT = enum(i32) {
|
|
UTC = 0,
|
|
LOCAL = 1,
|
|
NONE = 2,
|
|
};
|
|
pub const WS_DATETIME_FORMAT_UTC = WS_DATETIME_FORMAT.UTC;
|
|
pub const WS_DATETIME_FORMAT_LOCAL = WS_DATETIME_FORMAT.LOCAL;
|
|
pub const WS_DATETIME_FORMAT_NONE = WS_DATETIME_FORMAT.NONE;
|
|
|
|
pub const WS_METADATA_STATE = enum(i32) {
|
|
CREATED = 1,
|
|
RESOLVED = 2,
|
|
FAULTED = 3,
|
|
};
|
|
pub const WS_METADATA_STATE_CREATED = WS_METADATA_STATE.CREATED;
|
|
pub const WS_METADATA_STATE_RESOLVED = WS_METADATA_STATE.RESOLVED;
|
|
pub const WS_METADATA_STATE_FAULTED = WS_METADATA_STATE.FAULTED;
|
|
|
|
pub const WS_METADATA_PROPERTY_ID = enum(i32) {
|
|
STATE = 1,
|
|
HEAP_PROPERTIES = 2,
|
|
POLICY_PROPERTIES = 3,
|
|
HEAP_REQUESTED_SIZE = 4,
|
|
MAX_DOCUMENTS = 5,
|
|
HOST_NAMES = 6,
|
|
VERIFY_HOST_NAMES = 7,
|
|
};
|
|
pub const WS_METADATA_PROPERTY_STATE = WS_METADATA_PROPERTY_ID.STATE;
|
|
pub const WS_METADATA_PROPERTY_HEAP_PROPERTIES = WS_METADATA_PROPERTY_ID.HEAP_PROPERTIES;
|
|
pub const WS_METADATA_PROPERTY_POLICY_PROPERTIES = WS_METADATA_PROPERTY_ID.POLICY_PROPERTIES;
|
|
pub const WS_METADATA_PROPERTY_HEAP_REQUESTED_SIZE = WS_METADATA_PROPERTY_ID.HEAP_REQUESTED_SIZE;
|
|
pub const WS_METADATA_PROPERTY_MAX_DOCUMENTS = WS_METADATA_PROPERTY_ID.MAX_DOCUMENTS;
|
|
pub const WS_METADATA_PROPERTY_HOST_NAMES = WS_METADATA_PROPERTY_ID.HOST_NAMES;
|
|
pub const WS_METADATA_PROPERTY_VERIFY_HOST_NAMES = WS_METADATA_PROPERTY_ID.VERIFY_HOST_NAMES;
|
|
|
|
pub const WS_POLICY_STATE = enum(i32) {
|
|
CREATED = 1,
|
|
FAULTED = 2,
|
|
};
|
|
pub const WS_POLICY_STATE_CREATED = WS_POLICY_STATE.CREATED;
|
|
pub const WS_POLICY_STATE_FAULTED = WS_POLICY_STATE.FAULTED;
|
|
|
|
pub const WS_POLICY_PROPERTY_ID = enum(i32) {
|
|
STATE = 1,
|
|
MAX_ALTERNATIVES = 2,
|
|
MAX_DEPTH = 3,
|
|
MAX_EXTENSIONS = 4,
|
|
};
|
|
pub const WS_POLICY_PROPERTY_STATE = WS_POLICY_PROPERTY_ID.STATE;
|
|
pub const WS_POLICY_PROPERTY_MAX_ALTERNATIVES = WS_POLICY_PROPERTY_ID.MAX_ALTERNATIVES;
|
|
pub const WS_POLICY_PROPERTY_MAX_DEPTH = WS_POLICY_PROPERTY_ID.MAX_DEPTH;
|
|
pub const WS_POLICY_PROPERTY_MAX_EXTENSIONS = WS_POLICY_PROPERTY_ID.MAX_EXTENSIONS;
|
|
|
|
pub const WS_SECURITY_BINDING_CONSTRAINT_TYPE = enum(i32) {
|
|
SSL_TRANSPORT_SECURITY_BINDING_CONSTRAINT_TYPE = 1,
|
|
TCP_SSPI_TRANSPORT_SECURITY_BINDING_CONSTRAINT_TYPE = 2,
|
|
HTTP_HEADER_AUTH_SECURITY_BINDING_CONSTRAINT_TYPE = 3,
|
|
USERNAME_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE = 4,
|
|
KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE = 5,
|
|
ISSUED_TOKEN_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE = 6,
|
|
CERT_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE = 7,
|
|
SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE = 8,
|
|
};
|
|
pub const WS_SSL_TRANSPORT_SECURITY_BINDING_CONSTRAINT_TYPE = WS_SECURITY_BINDING_CONSTRAINT_TYPE.SSL_TRANSPORT_SECURITY_BINDING_CONSTRAINT_TYPE;
|
|
pub const WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_CONSTRAINT_TYPE = WS_SECURITY_BINDING_CONSTRAINT_TYPE.TCP_SSPI_TRANSPORT_SECURITY_BINDING_CONSTRAINT_TYPE;
|
|
pub const WS_HTTP_HEADER_AUTH_SECURITY_BINDING_CONSTRAINT_TYPE = WS_SECURITY_BINDING_CONSTRAINT_TYPE.HTTP_HEADER_AUTH_SECURITY_BINDING_CONSTRAINT_TYPE;
|
|
pub const WS_USERNAME_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE = WS_SECURITY_BINDING_CONSTRAINT_TYPE.USERNAME_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE;
|
|
pub const WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE = WS_SECURITY_BINDING_CONSTRAINT_TYPE.KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE;
|
|
pub const WS_ISSUED_TOKEN_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE = WS_SECURITY_BINDING_CONSTRAINT_TYPE.ISSUED_TOKEN_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE;
|
|
pub const WS_CERT_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE = WS_SECURITY_BINDING_CONSTRAINT_TYPE.CERT_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE;
|
|
pub const WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE = WS_SECURITY_BINDING_CONSTRAINT_TYPE.SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE;
|
|
|
|
pub const WS_POLICY_EXTENSION_TYPE = enum(i32) {
|
|
E = 1,
|
|
};
|
|
pub const WS_ENDPOINT_POLICY_EXTENSION_TYPE = WS_POLICY_EXTENSION_TYPE.E;
|
|
|
|
pub const WS_BINDING_TEMPLATE_TYPE = enum(i32) {
|
|
HTTP_BINDING_TEMPLATE_TYPE = 0,
|
|
HTTP_SSL_BINDING_TEMPLATE_TYPE = 1,
|
|
HTTP_HEADER_AUTH_BINDING_TEMPLATE_TYPE = 2,
|
|
HTTP_SSL_HEADER_AUTH_BINDING_TEMPLATE_TYPE = 3,
|
|
HTTP_SSL_USERNAME_BINDING_TEMPLATE_TYPE = 4,
|
|
HTTP_SSL_KERBEROS_APREQ_BINDING_TEMPLATE_TYPE = 5,
|
|
TCP_BINDING_TEMPLATE_TYPE = 6,
|
|
TCP_SSPI_BINDING_TEMPLATE_TYPE = 7,
|
|
TCP_SSPI_USERNAME_BINDING_TEMPLATE_TYPE = 8,
|
|
TCP_SSPI_KERBEROS_APREQ_BINDING_TEMPLATE_TYPE = 9,
|
|
HTTP_SSL_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE = 10,
|
|
HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE = 11,
|
|
TCP_SSPI_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE = 12,
|
|
TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE = 13,
|
|
};
|
|
pub const WS_HTTP_BINDING_TEMPLATE_TYPE = WS_BINDING_TEMPLATE_TYPE.HTTP_BINDING_TEMPLATE_TYPE;
|
|
pub const WS_HTTP_SSL_BINDING_TEMPLATE_TYPE = WS_BINDING_TEMPLATE_TYPE.HTTP_SSL_BINDING_TEMPLATE_TYPE;
|
|
pub const WS_HTTP_HEADER_AUTH_BINDING_TEMPLATE_TYPE = WS_BINDING_TEMPLATE_TYPE.HTTP_HEADER_AUTH_BINDING_TEMPLATE_TYPE;
|
|
pub const WS_HTTP_SSL_HEADER_AUTH_BINDING_TEMPLATE_TYPE = WS_BINDING_TEMPLATE_TYPE.HTTP_SSL_HEADER_AUTH_BINDING_TEMPLATE_TYPE;
|
|
pub const WS_HTTP_SSL_USERNAME_BINDING_TEMPLATE_TYPE = WS_BINDING_TEMPLATE_TYPE.HTTP_SSL_USERNAME_BINDING_TEMPLATE_TYPE;
|
|
pub const WS_HTTP_SSL_KERBEROS_APREQ_BINDING_TEMPLATE_TYPE = WS_BINDING_TEMPLATE_TYPE.HTTP_SSL_KERBEROS_APREQ_BINDING_TEMPLATE_TYPE;
|
|
pub const WS_TCP_BINDING_TEMPLATE_TYPE = WS_BINDING_TEMPLATE_TYPE.TCP_BINDING_TEMPLATE_TYPE;
|
|
pub const WS_TCP_SSPI_BINDING_TEMPLATE_TYPE = WS_BINDING_TEMPLATE_TYPE.TCP_SSPI_BINDING_TEMPLATE_TYPE;
|
|
pub const WS_TCP_SSPI_USERNAME_BINDING_TEMPLATE_TYPE = WS_BINDING_TEMPLATE_TYPE.TCP_SSPI_USERNAME_BINDING_TEMPLATE_TYPE;
|
|
pub const WS_TCP_SSPI_KERBEROS_APREQ_BINDING_TEMPLATE_TYPE = WS_BINDING_TEMPLATE_TYPE.TCP_SSPI_KERBEROS_APREQ_BINDING_TEMPLATE_TYPE;
|
|
pub const WS_HTTP_SSL_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE = WS_BINDING_TEMPLATE_TYPE.HTTP_SSL_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE;
|
|
pub const WS_HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE = WS_BINDING_TEMPLATE_TYPE.HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE;
|
|
pub const WS_TCP_SSPI_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE = WS_BINDING_TEMPLATE_TYPE.TCP_SSPI_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE;
|
|
pub const WS_TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE = WS_BINDING_TEMPLATE_TYPE.TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE;
|
|
|
|
pub const WS_READ_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
callbackState: ?*anyopaque,
|
|
// TODO: what to do with BytesParamIndex 2?
|
|
bytes: ?*anyopaque,
|
|
maxSize: u32,
|
|
actualSize: ?*u32,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
callbackState: ?*anyopaque,
|
|
// TODO: what to do with BytesParamIndex 2?
|
|
bytes: ?*anyopaque,
|
|
maxSize: u32,
|
|
actualSize: ?*u32,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_WRITE_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
callbackState: ?*anyopaque,
|
|
buffers: [*]const WS_BYTES,
|
|
count: u32,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
callbackState: ?*anyopaque,
|
|
buffers: [*]const WS_BYTES,
|
|
count: u32,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_PUSH_BYTES_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
callbackState: ?*anyopaque,
|
|
writeCallback: ?WS_WRITE_CALLBACK,
|
|
writeCallbackState: ?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
callbackState: ?*anyopaque,
|
|
writeCallback: ?WS_WRITE_CALLBACK,
|
|
writeCallbackState: ?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_PULL_BYTES_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
callbackState: ?*anyopaque,
|
|
// TODO: what to do with BytesParamIndex 2?
|
|
bytes: ?*anyopaque,
|
|
maxSize: u32,
|
|
actualSize: ?*u32,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
callbackState: ?*anyopaque,
|
|
// TODO: what to do with BytesParamIndex 2?
|
|
bytes: ?*anyopaque,
|
|
maxSize: u32,
|
|
actualSize: ?*u32,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_DYNAMIC_STRING_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
callbackState: ?*anyopaque,
|
|
string: ?*const WS_XML_STRING,
|
|
found: ?*BOOL,
|
|
id: ?*u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
callbackState: ?*anyopaque,
|
|
string: ?*const WS_XML_STRING,
|
|
found: ?*BOOL,
|
|
id: ?*u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_ASYNC_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
errorCode: HRESULT,
|
|
callbackModel: WS_CALLBACK_MODEL,
|
|
callbackState: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
errorCode: HRESULT,
|
|
callbackModel: WS_CALLBACK_MODEL,
|
|
callbackState: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
} ;
|
|
|
|
// TODO: this function pointer causes dependency loop problems, so it's stubbed out
|
|
pub const WS_ASYNC_FUNCTION = switch (@import("builtin").zig_backend) { .stage1 => fn() callconv(@import("std").os.windows.WINAPI) void, else => *const fn() callconv(@import("std").os.windows.WINAPI) void};
|
|
|
|
pub const WS_CREATE_CHANNEL_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
channelType: WS_CHANNEL_TYPE,
|
|
// TODO: what to do with BytesParamIndex 2?
|
|
channelParameters: ?*const anyopaque,
|
|
channelParametersSize: u32,
|
|
channelInstance: ?*?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
channelType: WS_CHANNEL_TYPE,
|
|
// TODO: what to do with BytesParamIndex 2?
|
|
channelParameters: ?*const anyopaque,
|
|
channelParametersSize: u32,
|
|
channelInstance: ?*?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_FREE_CHANNEL_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
channelInstance: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
channelInstance: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
} ;
|
|
|
|
pub const WS_RESET_CHANNEL_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
channelInstance: ?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
channelInstance: ?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_ABORT_CHANNEL_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
channelInstance: ?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
channelInstance: ?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_OPEN_CHANNEL_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
channelInstance: ?*anyopaque,
|
|
endpointAddress: ?*const WS_ENDPOINT_ADDRESS,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
channelInstance: ?*anyopaque,
|
|
endpointAddress: ?*const WS_ENDPOINT_ADDRESS,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_CLOSE_CHANNEL_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
channelInstance: ?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
channelInstance: ?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_SET_CHANNEL_PROPERTY_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
channelInstance: ?*anyopaque,
|
|
id: WS_CHANNEL_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
channelInstance: ?*anyopaque,
|
|
id: WS_CHANNEL_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_GET_CHANNEL_PROPERTY_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
channelInstance: ?*anyopaque,
|
|
id: WS_CHANNEL_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
channelInstance: ?*anyopaque,
|
|
id: WS_CHANNEL_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_READ_MESSAGE_START_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
channelInstance: ?*anyopaque,
|
|
message: ?*WS_MESSAGE,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
channelInstance: ?*anyopaque,
|
|
message: ?*WS_MESSAGE,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_READ_MESSAGE_END_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
channelInstance: ?*anyopaque,
|
|
message: ?*WS_MESSAGE,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
channelInstance: ?*anyopaque,
|
|
message: ?*WS_MESSAGE,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_WRITE_MESSAGE_START_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
channelInstance: ?*anyopaque,
|
|
message: ?*WS_MESSAGE,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
channelInstance: ?*anyopaque,
|
|
message: ?*WS_MESSAGE,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_WRITE_MESSAGE_END_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
channelInstance: ?*anyopaque,
|
|
message: ?*WS_MESSAGE,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
channelInstance: ?*anyopaque,
|
|
message: ?*WS_MESSAGE,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_ABANDON_MESSAGE_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
channelInstance: ?*anyopaque,
|
|
message: ?*WS_MESSAGE,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
channelInstance: ?*anyopaque,
|
|
message: ?*WS_MESSAGE,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_SHUTDOWN_SESSION_CHANNEL_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
channelInstance: ?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
channelInstance: ?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_CREATE_ENCODER_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
createContext: ?*anyopaque,
|
|
writeCallback: ?WS_WRITE_CALLBACK,
|
|
writeContext: ?*anyopaque,
|
|
encoderContext: ?*?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
createContext: ?*anyopaque,
|
|
writeCallback: ?WS_WRITE_CALLBACK,
|
|
writeContext: ?*anyopaque,
|
|
encoderContext: ?*?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_ENCODER_GET_CONTENT_TYPE_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
encoderContext: ?*anyopaque,
|
|
contentType: ?*const WS_STRING,
|
|
newContentType: ?*WS_STRING,
|
|
contentEncoding: ?*WS_STRING,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
encoderContext: ?*anyopaque,
|
|
contentType: ?*const WS_STRING,
|
|
newContentType: ?*WS_STRING,
|
|
contentEncoding: ?*WS_STRING,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_ENCODER_START_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
encoderContext: ?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
encoderContext: ?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_ENCODER_ENCODE_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
encoderContext: ?*anyopaque,
|
|
buffers: [*]const WS_BYTES,
|
|
count: u32,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
encoderContext: ?*anyopaque,
|
|
buffers: [*]const WS_BYTES,
|
|
count: u32,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_ENCODER_END_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
encoderContext: ?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
encoderContext: ?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_FREE_ENCODER_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
encoderContext: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
encoderContext: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
} ;
|
|
|
|
pub const WS_CREATE_DECODER_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
createContext: ?*anyopaque,
|
|
readCallback: ?WS_READ_CALLBACK,
|
|
readContext: ?*anyopaque,
|
|
decoderContext: ?*?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
createContext: ?*anyopaque,
|
|
readCallback: ?WS_READ_CALLBACK,
|
|
readContext: ?*anyopaque,
|
|
decoderContext: ?*?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_DECODER_GET_CONTENT_TYPE_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
decoderContext: ?*anyopaque,
|
|
contentType: ?*const WS_STRING,
|
|
contentEncoding: ?*const WS_STRING,
|
|
newContentType: ?*WS_STRING,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
decoderContext: ?*anyopaque,
|
|
contentType: ?*const WS_STRING,
|
|
contentEncoding: ?*const WS_STRING,
|
|
newContentType: ?*WS_STRING,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_DECODER_START_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
encoderContext: ?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
encoderContext: ?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_DECODER_DECODE_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
encoderContext: ?*anyopaque,
|
|
// TODO: what to do with BytesParamIndex 2?
|
|
buffer: ?*anyopaque,
|
|
maxLength: u32,
|
|
length: ?*u32,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
encoderContext: ?*anyopaque,
|
|
// TODO: what to do with BytesParamIndex 2?
|
|
buffer: ?*anyopaque,
|
|
maxLength: u32,
|
|
length: ?*u32,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_DECODER_END_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
encoderContext: ?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
encoderContext: ?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_FREE_DECODER_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
decoderContext: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
decoderContext: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
} ;
|
|
|
|
pub const WS_HTTP_REDIRECT_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
state: ?*anyopaque,
|
|
originalUrl: ?*const WS_STRING,
|
|
newUrl: ?*const WS_STRING,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
state: ?*anyopaque,
|
|
originalUrl: ?*const WS_STRING,
|
|
newUrl: ?*const WS_STRING,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_CREATE_LISTENER_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
channelType: WS_CHANNEL_TYPE,
|
|
// TODO: what to do with BytesParamIndex 2?
|
|
listenerParameters: ?*const anyopaque,
|
|
listenerParametersSize: u32,
|
|
listenerInstance: ?*?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
channelType: WS_CHANNEL_TYPE,
|
|
// TODO: what to do with BytesParamIndex 2?
|
|
listenerParameters: ?*const anyopaque,
|
|
listenerParametersSize: u32,
|
|
listenerInstance: ?*?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_FREE_LISTENER_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
listenerInstance: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
listenerInstance: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
} ;
|
|
|
|
pub const WS_RESET_LISTENER_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
listenerInstance: ?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
listenerInstance: ?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_OPEN_LISTENER_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
listenerInstance: ?*anyopaque,
|
|
url: ?*const WS_STRING,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
listenerInstance: ?*anyopaque,
|
|
url: ?*const WS_STRING,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_CLOSE_LISTENER_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
listenerInstance: ?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
listenerInstance: ?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_GET_LISTENER_PROPERTY_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
listenerInstance: ?*anyopaque,
|
|
id: WS_LISTENER_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
listenerInstance: ?*anyopaque,
|
|
id: WS_LISTENER_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_SET_LISTENER_PROPERTY_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
listenerInstance: ?*anyopaque,
|
|
id: WS_LISTENER_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
listenerInstance: ?*anyopaque,
|
|
id: WS_LISTENER_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_ACCEPT_CHANNEL_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
listenerInstance: ?*anyopaque,
|
|
channelInstance: ?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
listenerInstance: ?*anyopaque,
|
|
channelInstance: ?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_ABORT_LISTENER_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
listenerInstance: ?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
listenerInstance: ?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_CREATE_CHANNEL_FOR_LISTENER_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
listenerInstance: ?*anyopaque,
|
|
// TODO: what to do with BytesParamIndex 2?
|
|
channelParameters: ?*const anyopaque,
|
|
channelParametersSize: u32,
|
|
channelInstance: ?*?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
listenerInstance: ?*anyopaque,
|
|
// TODO: what to do with BytesParamIndex 2?
|
|
channelParameters: ?*const anyopaque,
|
|
channelParametersSize: u32,
|
|
channelInstance: ?*?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_MESSAGE_DONE_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
doneCallbackState: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
doneCallbackState: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
} ;
|
|
|
|
pub const WS_CERTIFICATE_VALIDATION_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
certContext: ?*const CERT_CONTEXT,
|
|
state: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
certContext: ?*const CERT_CONTEXT,
|
|
state: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_GET_CERT_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
getCertCallbackState: ?*anyopaque,
|
|
targetAddress: ?*const WS_ENDPOINT_ADDRESS,
|
|
viaUri: ?*const WS_STRING,
|
|
cert: ?*const ?*CERT_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
getCertCallbackState: ?*anyopaque,
|
|
targetAddress: ?*const WS_ENDPOINT_ADDRESS,
|
|
viaUri: ?*const WS_STRING,
|
|
cert: ?*const ?*CERT_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_CERT_ISSUER_LIST_NOTIFICATION_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
certIssuerListNotificationCallbackState: ?*anyopaque,
|
|
issuerList: ?*const SecPkgContext_IssuerListInfoEx,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
certIssuerListNotificationCallbackState: ?*anyopaque,
|
|
issuerList: ?*const SecPkgContext_IssuerListInfoEx,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_VALIDATE_PASSWORD_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
passwordValidatorCallbackState: ?*anyopaque,
|
|
username: ?*const WS_STRING,
|
|
password: ?*const WS_STRING,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
passwordValidatorCallbackState: ?*anyopaque,
|
|
username: ?*const WS_STRING,
|
|
password: ?*const WS_STRING,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_VALIDATE_SAML_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
samlValidatorCallbackState: ?*anyopaque,
|
|
samlAssertion: ?*WS_XML_BUFFER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
samlValidatorCallbackState: ?*anyopaque,
|
|
samlAssertion: ?*WS_XML_BUFFER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_DURATION_COMPARISON_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
duration1: ?*const WS_DURATION,
|
|
duration2: ?*const WS_DURATION,
|
|
result: ?*i32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
duration1: ?*const WS_DURATION,
|
|
duration2: ?*const WS_DURATION,
|
|
result: ?*i32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_READ_TYPE_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
reader: ?*WS_XML_READER,
|
|
typeMapping: WS_TYPE_MAPPING,
|
|
descriptionData: ?*const anyopaque,
|
|
heap: ?*WS_HEAP,
|
|
// TODO: what to do with BytesParamIndex 5?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
reader: ?*WS_XML_READER,
|
|
typeMapping: WS_TYPE_MAPPING,
|
|
descriptionData: ?*const anyopaque,
|
|
heap: ?*WS_HEAP,
|
|
// TODO: what to do with BytesParamIndex 5?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_WRITE_TYPE_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
writer: ?*WS_XML_WRITER,
|
|
typeMapping: WS_TYPE_MAPPING,
|
|
descriptionData: ?*const anyopaque,
|
|
// TODO: what to do with BytesParamIndex 4?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
writer: ?*WS_XML_WRITER,
|
|
typeMapping: WS_TYPE_MAPPING,
|
|
descriptionData: ?*const anyopaque,
|
|
// TODO: what to do with BytesParamIndex 4?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_IS_DEFAULT_VALUE_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
descriptionData: ?*const anyopaque,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*const anyopaque,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
defaultValue: ?*const anyopaque,
|
|
valueSize: u32,
|
|
isDefault: ?*BOOL,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
descriptionData: ?*const anyopaque,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*const anyopaque,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
defaultValue: ?*const anyopaque,
|
|
valueSize: u32,
|
|
isDefault: ?*BOOL,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_SERVICE_MESSAGE_RECEIVE_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
context: ?*const WS_OPERATION_CONTEXT,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
context: ?*const WS_OPERATION_CONTEXT,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_OPERATION_CANCEL_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
reason: WS_SERVICE_CANCEL_REASON,
|
|
state: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
reason: WS_SERVICE_CANCEL_REASON,
|
|
state: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
} ;
|
|
|
|
pub const WS_OPERATION_FREE_STATE_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
state: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
state: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
} ;
|
|
|
|
pub const WS_SERVICE_STUB_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
context: ?*const WS_OPERATION_CONTEXT,
|
|
frame: ?*anyopaque,
|
|
callback: ?*const anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
context: ?*const WS_OPERATION_CONTEXT,
|
|
frame: ?*anyopaque,
|
|
callback: ?*const anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_SERVICE_ACCEPT_CHANNEL_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
context: ?*const WS_OPERATION_CONTEXT,
|
|
channelState: ?*?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
context: ?*const WS_OPERATION_CONTEXT,
|
|
channelState: ?*?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_SERVICE_CLOSE_CHANNEL_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
context: ?*const WS_OPERATION_CONTEXT,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
context: ?*const WS_OPERATION_CONTEXT,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_SERVICE_SECURITY_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
context: ?*const WS_OPERATION_CONTEXT,
|
|
authorized: ?*BOOL,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
context: ?*const WS_OPERATION_CONTEXT,
|
|
authorized: ?*BOOL,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_PROXY_MESSAGE_CALLBACK = switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
message: ?*WS_MESSAGE,
|
|
heap: ?*WS_HEAP,
|
|
state: ?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
message: ?*WS_MESSAGE,
|
|
heap: ?*WS_HEAP,
|
|
state: ?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
} ;
|
|
|
|
pub const WS_XML_DICTIONARY = extern struct {
|
|
guid: Guid,
|
|
strings: ?*WS_XML_STRING,
|
|
stringCount: u32,
|
|
isConst: BOOL,
|
|
};
|
|
|
|
pub const WS_XML_STRING = extern struct {
|
|
length: u32,
|
|
bytes: ?*u8,
|
|
dictionary: ?*WS_XML_DICTIONARY,
|
|
id: u32,
|
|
};
|
|
|
|
pub const WS_XML_QNAME = extern struct {
|
|
localName: WS_XML_STRING,
|
|
ns: WS_XML_STRING,
|
|
};
|
|
|
|
pub const WS_XML_NODE_POSITION = extern struct {
|
|
buffer: ?*WS_XML_BUFFER,
|
|
node: ?*anyopaque,
|
|
};
|
|
|
|
pub const WS_XML_READER_PROPERTY = extern struct {
|
|
id: WS_XML_READER_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_XML_CANONICALIZATION_INCLUSIVE_PREFIXES = extern struct {
|
|
prefixCount: u32,
|
|
prefixes: ?*WS_XML_STRING,
|
|
};
|
|
|
|
pub const WS_XML_CANONICALIZATION_PROPERTY = extern struct {
|
|
id: WS_XML_CANONICALIZATION_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_XML_WRITER_PROPERTY = extern struct {
|
|
id: WS_XML_WRITER_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_XML_BUFFER_PROPERTY = extern struct {
|
|
id: WS_XML_BUFFER_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_XML_TEXT = extern struct {
|
|
textType: WS_XML_TEXT_TYPE,
|
|
};
|
|
|
|
pub const WS_XML_UTF8_TEXT = extern struct {
|
|
text: WS_XML_TEXT,
|
|
value: WS_XML_STRING,
|
|
};
|
|
|
|
pub const WS_XML_UTF16_TEXT = extern struct {
|
|
text: WS_XML_TEXT,
|
|
bytes: ?*u8,
|
|
byteCount: u32,
|
|
};
|
|
|
|
pub const WS_XML_BASE64_TEXT = extern struct {
|
|
text: WS_XML_TEXT,
|
|
bytes: ?*u8,
|
|
length: u32,
|
|
};
|
|
|
|
pub const WS_XML_BOOL_TEXT = extern struct {
|
|
text: WS_XML_TEXT,
|
|
value: BOOL,
|
|
};
|
|
|
|
pub const WS_XML_INT32_TEXT = extern struct {
|
|
text: WS_XML_TEXT,
|
|
value: i32,
|
|
};
|
|
|
|
pub const WS_XML_INT64_TEXT = extern struct {
|
|
text: WS_XML_TEXT,
|
|
value: i64,
|
|
};
|
|
|
|
pub const WS_XML_UINT64_TEXT = extern struct {
|
|
text: WS_XML_TEXT,
|
|
value: u64,
|
|
};
|
|
|
|
pub const WS_XML_FLOAT_TEXT = extern struct {
|
|
text: WS_XML_TEXT,
|
|
value: f32,
|
|
};
|
|
|
|
pub const WS_XML_DOUBLE_TEXT = extern struct {
|
|
text: WS_XML_TEXT,
|
|
value: f64,
|
|
};
|
|
|
|
pub const WS_XML_DECIMAL_TEXT = extern struct {
|
|
text: WS_XML_TEXT,
|
|
value: DECIMAL,
|
|
};
|
|
|
|
pub const WS_XML_GUID_TEXT = extern struct {
|
|
text: WS_XML_TEXT,
|
|
value: Guid,
|
|
};
|
|
|
|
pub const WS_XML_UNIQUE_ID_TEXT = extern struct {
|
|
text: WS_XML_TEXT,
|
|
value: Guid,
|
|
};
|
|
|
|
pub const WS_DATETIME = extern struct {
|
|
ticks: u64,
|
|
format: WS_DATETIME_FORMAT,
|
|
};
|
|
|
|
pub const WS_XML_DATETIME_TEXT = extern struct {
|
|
text: WS_XML_TEXT,
|
|
value: WS_DATETIME,
|
|
};
|
|
|
|
pub const WS_TIMESPAN = extern struct {
|
|
ticks: i64,
|
|
};
|
|
|
|
pub const WS_XML_TIMESPAN_TEXT = extern struct {
|
|
text: WS_XML_TEXT,
|
|
value: WS_TIMESPAN,
|
|
};
|
|
|
|
pub const WS_XML_QNAME_TEXT = extern struct {
|
|
text: WS_XML_TEXT,
|
|
prefix: ?*WS_XML_STRING,
|
|
localName: ?*WS_XML_STRING,
|
|
ns: ?*WS_XML_STRING,
|
|
};
|
|
|
|
pub const WS_XML_LIST_TEXT = extern struct {
|
|
text: WS_XML_TEXT,
|
|
itemCount: u32,
|
|
items: ?*?*WS_XML_TEXT,
|
|
};
|
|
|
|
pub const WS_XML_NODE = extern struct {
|
|
nodeType: WS_XML_NODE_TYPE,
|
|
};
|
|
|
|
pub const WS_XML_ATTRIBUTE = extern struct {
|
|
singleQuote: u8,
|
|
isXmlNs: u8,
|
|
prefix: ?*WS_XML_STRING,
|
|
localName: ?*WS_XML_STRING,
|
|
ns: ?*WS_XML_STRING,
|
|
value: ?*WS_XML_TEXT,
|
|
};
|
|
|
|
pub const WS_XML_ELEMENT_NODE = extern struct {
|
|
node: WS_XML_NODE,
|
|
prefix: ?*WS_XML_STRING,
|
|
localName: ?*WS_XML_STRING,
|
|
ns: ?*WS_XML_STRING,
|
|
attributeCount: u32,
|
|
attributes: ?*?*WS_XML_ATTRIBUTE,
|
|
isEmpty: BOOL,
|
|
};
|
|
|
|
pub const WS_XML_TEXT_NODE = extern struct {
|
|
node: WS_XML_NODE,
|
|
text: ?*WS_XML_TEXT,
|
|
};
|
|
|
|
pub const WS_XML_COMMENT_NODE = extern struct {
|
|
node: WS_XML_NODE,
|
|
value: WS_XML_STRING,
|
|
};
|
|
|
|
pub const WS_XML_READER_INPUT = extern struct {
|
|
inputType: WS_XML_READER_INPUT_TYPE,
|
|
};
|
|
|
|
pub const WS_XML_READER_BUFFER_INPUT = extern struct {
|
|
input: WS_XML_READER_INPUT,
|
|
encodedData: ?*anyopaque,
|
|
encodedDataSize: u32,
|
|
};
|
|
|
|
pub const WS_XML_READER_STREAM_INPUT = extern struct {
|
|
input: WS_XML_READER_INPUT,
|
|
readCallback: ?WS_READ_CALLBACK,
|
|
readCallbackState: ?*anyopaque,
|
|
};
|
|
|
|
pub const WS_XML_READER_ENCODING = extern struct {
|
|
encodingType: WS_XML_READER_ENCODING_TYPE,
|
|
};
|
|
|
|
pub const WS_XML_READER_TEXT_ENCODING = extern struct {
|
|
encoding: WS_XML_READER_ENCODING,
|
|
charSet: WS_CHARSET,
|
|
};
|
|
|
|
pub const WS_XML_READER_BINARY_ENCODING = extern struct {
|
|
encoding: WS_XML_READER_ENCODING,
|
|
staticDictionary: ?*WS_XML_DICTIONARY,
|
|
dynamicDictionary: ?*WS_XML_DICTIONARY,
|
|
};
|
|
|
|
pub const WS_STRING = extern struct {
|
|
length: u32,
|
|
chars: ?PWSTR,
|
|
};
|
|
|
|
pub const WS_XML_READER_MTOM_ENCODING = extern struct {
|
|
encoding: WS_XML_READER_ENCODING,
|
|
textEncoding: ?*WS_XML_READER_ENCODING,
|
|
readMimeHeader: BOOL,
|
|
startInfo: WS_STRING,
|
|
boundary: WS_STRING,
|
|
startUri: WS_STRING,
|
|
};
|
|
|
|
pub const WS_XML_READER_RAW_ENCODING = extern struct {
|
|
encoding: WS_XML_READER_ENCODING,
|
|
};
|
|
|
|
pub const WS_XML_WRITER_ENCODING = extern struct {
|
|
encodingType: WS_XML_WRITER_ENCODING_TYPE,
|
|
};
|
|
|
|
pub const WS_XML_WRITER_TEXT_ENCODING = extern struct {
|
|
encoding: WS_XML_WRITER_ENCODING,
|
|
charSet: WS_CHARSET,
|
|
};
|
|
|
|
pub const WS_XML_WRITER_BINARY_ENCODING = extern struct {
|
|
encoding: WS_XML_WRITER_ENCODING,
|
|
staticDictionary: ?*WS_XML_DICTIONARY,
|
|
dynamicStringCallback: ?WS_DYNAMIC_STRING_CALLBACK,
|
|
dynamicStringCallbackState: ?*anyopaque,
|
|
};
|
|
|
|
pub const WS_XML_WRITER_MTOM_ENCODING = extern struct {
|
|
encoding: WS_XML_WRITER_ENCODING,
|
|
textEncoding: ?*WS_XML_WRITER_ENCODING,
|
|
writeMimeHeader: BOOL,
|
|
boundary: WS_STRING,
|
|
startInfo: WS_STRING,
|
|
startUri: WS_STRING,
|
|
maxInlineByteCount: u32,
|
|
};
|
|
|
|
pub const WS_XML_WRITER_RAW_ENCODING = extern struct {
|
|
encoding: WS_XML_WRITER_ENCODING,
|
|
};
|
|
|
|
pub const WS_XML_WRITER_OUTPUT = extern struct {
|
|
outputType: WS_XML_WRITER_OUTPUT_TYPE,
|
|
};
|
|
|
|
pub const WS_XML_WRITER_BUFFER_OUTPUT = extern struct {
|
|
output: WS_XML_WRITER_OUTPUT,
|
|
};
|
|
|
|
pub const WS_XML_WRITER_STREAM_OUTPUT = extern struct {
|
|
output: WS_XML_WRITER_OUTPUT,
|
|
writeCallback: ?WS_WRITE_CALLBACK,
|
|
writeCallbackState: ?*anyopaque,
|
|
};
|
|
|
|
pub const WS_XML_WRITER_PROPERTIES = extern struct {
|
|
properties: ?*WS_XML_WRITER_PROPERTY,
|
|
propertyCount: u32,
|
|
};
|
|
|
|
pub const WS_XML_READER_PROPERTIES = extern struct {
|
|
properties: ?*WS_XML_READER_PROPERTY,
|
|
propertyCount: u32,
|
|
};
|
|
|
|
pub const WS_ASYNC_CONTEXT = extern struct {
|
|
callback: ?WS_ASYNC_CALLBACK,
|
|
callbackState: ?*anyopaque,
|
|
};
|
|
|
|
pub const WS_ASYNC_STATE = extern struct {
|
|
internal0: ?*anyopaque,
|
|
internal1: ?*anyopaque,
|
|
internal2: ?*anyopaque,
|
|
internal3: ?*anyopaque,
|
|
internal4: ?*anyopaque,
|
|
};
|
|
|
|
pub const WS_ASYNC_OPERATION = extern struct {
|
|
function: ?WS_ASYNC_FUNCTION,
|
|
};
|
|
|
|
pub const WS_CHANNEL_PROPERTY = extern struct {
|
|
id: WS_CHANNEL_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_CUSTOM_HTTP_PROXY = extern struct {
|
|
servers: WS_STRING,
|
|
bypass: WS_STRING,
|
|
};
|
|
|
|
pub const WS_CHANNEL_PROPERTIES = extern struct {
|
|
properties: ?*WS_CHANNEL_PROPERTY,
|
|
propertyCount: u32,
|
|
};
|
|
|
|
pub const WS_CUSTOM_CHANNEL_CALLBACKS = extern struct {
|
|
createChannelCallback: ?WS_CREATE_CHANNEL_CALLBACK,
|
|
freeChannelCallback: ?WS_FREE_CHANNEL_CALLBACK,
|
|
resetChannelCallback: ?WS_RESET_CHANNEL_CALLBACK,
|
|
openChannelCallback: ?WS_OPEN_CHANNEL_CALLBACK,
|
|
closeChannelCallback: ?WS_CLOSE_CHANNEL_CALLBACK,
|
|
abortChannelCallback: ?WS_ABORT_CHANNEL_CALLBACK,
|
|
getChannelPropertyCallback: ?WS_GET_CHANNEL_PROPERTY_CALLBACK,
|
|
setChannelPropertyCallback: ?WS_SET_CHANNEL_PROPERTY_CALLBACK,
|
|
writeMessageStartCallback: ?WS_WRITE_MESSAGE_START_CALLBACK,
|
|
writeMessageEndCallback: ?WS_WRITE_MESSAGE_END_CALLBACK,
|
|
readMessageStartCallback: ?WS_READ_MESSAGE_START_CALLBACK,
|
|
readMessageEndCallback: ?WS_READ_MESSAGE_END_CALLBACK,
|
|
abandonMessageCallback: ?WS_ABANDON_MESSAGE_CALLBACK,
|
|
shutdownSessionChannelCallback: ?WS_SHUTDOWN_SESSION_CHANNEL_CALLBACK,
|
|
};
|
|
|
|
pub const WS_HTTP_HEADER_MAPPING = extern struct {
|
|
headerName: WS_XML_STRING,
|
|
headerMappingOptions: u32,
|
|
};
|
|
|
|
pub const WS_HTTP_MESSAGE_MAPPING = extern struct {
|
|
requestMappingOptions: u32,
|
|
responseMappingOptions: u32,
|
|
requestHeaderMappings: ?*?*WS_HTTP_HEADER_MAPPING,
|
|
requestHeaderMappingCount: u32,
|
|
responseHeaderMappings: ?*?*WS_HTTP_HEADER_MAPPING,
|
|
responseHeaderMappingCount: u32,
|
|
};
|
|
|
|
pub const WS_ELEMENT_DESCRIPTION = extern struct {
|
|
elementLocalName: ?*WS_XML_STRING,
|
|
elementNs: ?*WS_XML_STRING,
|
|
type: WS_TYPE,
|
|
typeDescription: ?*anyopaque,
|
|
};
|
|
|
|
pub const WS_MESSAGE_DESCRIPTION = extern struct {
|
|
action: ?*WS_XML_STRING,
|
|
bodyElementDescription: ?*WS_ELEMENT_DESCRIPTION,
|
|
};
|
|
|
|
pub const WS_CHANNEL_ENCODER = extern struct {
|
|
createContext: ?*anyopaque,
|
|
createEncoderCallback: ?WS_CREATE_ENCODER_CALLBACK,
|
|
encoderGetContentTypeCallback: ?WS_ENCODER_GET_CONTENT_TYPE_CALLBACK,
|
|
encoderStartCallback: ?WS_ENCODER_START_CALLBACK,
|
|
encoderEncodeCallback: ?WS_ENCODER_ENCODE_CALLBACK,
|
|
encoderEndCallback: ?WS_ENCODER_END_CALLBACK,
|
|
freeEncoderCallback: ?WS_FREE_ENCODER_CALLBACK,
|
|
};
|
|
|
|
pub const WS_CHANNEL_DECODER = extern struct {
|
|
createContext: ?*anyopaque,
|
|
createDecoderCallback: ?WS_CREATE_DECODER_CALLBACK,
|
|
decoderGetContentTypeCallback: ?WS_DECODER_GET_CONTENT_TYPE_CALLBACK,
|
|
decoderStartCallback: ?WS_DECODER_START_CALLBACK,
|
|
decoderDecodeCallback: ?WS_DECODER_DECODE_CALLBACK,
|
|
decoderEndCallback: ?WS_DECODER_END_CALLBACK,
|
|
freeDecoderCallback: ?WS_FREE_DECODER_CALLBACK,
|
|
};
|
|
|
|
pub const WS_HTTP_REDIRECT_CALLBACK_CONTEXT = extern struct {
|
|
callback: ?WS_HTTP_REDIRECT_CALLBACK,
|
|
state: ?*anyopaque,
|
|
};
|
|
|
|
pub const WS_ENDPOINT_IDENTITY = extern struct {
|
|
identityType: WS_ENDPOINT_IDENTITY_TYPE,
|
|
};
|
|
|
|
pub const WS_ENDPOINT_ADDRESS = extern struct {
|
|
url: WS_STRING,
|
|
headers: ?*WS_XML_BUFFER,
|
|
extensions: ?*WS_XML_BUFFER,
|
|
identity: ?*WS_ENDPOINT_IDENTITY,
|
|
};
|
|
|
|
pub const WS_DNS_ENDPOINT_IDENTITY = extern struct {
|
|
identity: WS_ENDPOINT_IDENTITY,
|
|
dns: WS_STRING,
|
|
};
|
|
|
|
pub const WS_UPN_ENDPOINT_IDENTITY = extern struct {
|
|
identity: WS_ENDPOINT_IDENTITY,
|
|
upn: WS_STRING,
|
|
};
|
|
|
|
pub const WS_SPN_ENDPOINT_IDENTITY = extern struct {
|
|
identity: WS_ENDPOINT_IDENTITY,
|
|
spn: WS_STRING,
|
|
};
|
|
|
|
pub const WS_BYTES = extern struct {
|
|
length: u32,
|
|
bytes: ?*u8,
|
|
};
|
|
|
|
pub const WS_RSA_ENDPOINT_IDENTITY = extern struct {
|
|
identity: WS_ENDPOINT_IDENTITY,
|
|
modulus: WS_BYTES,
|
|
exponent: WS_BYTES,
|
|
};
|
|
|
|
pub const WS_CERT_ENDPOINT_IDENTITY = extern struct {
|
|
identity: WS_ENDPOINT_IDENTITY,
|
|
rawCertificateData: WS_BYTES,
|
|
};
|
|
|
|
pub const WS_UNKNOWN_ENDPOINT_IDENTITY = extern struct {
|
|
identity: WS_ENDPOINT_IDENTITY,
|
|
element: ?*WS_XML_BUFFER,
|
|
};
|
|
|
|
pub const WS_ERROR_PROPERTY = extern struct {
|
|
id: WS_ERROR_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_FAULT_REASON = extern struct {
|
|
text: WS_STRING,
|
|
lang: WS_STRING,
|
|
};
|
|
|
|
pub const WS_FAULT_CODE = extern struct {
|
|
value: WS_XML_QNAME,
|
|
subCode: ?*WS_FAULT_CODE,
|
|
};
|
|
|
|
pub const WS_FAULT = extern struct {
|
|
code: ?*WS_FAULT_CODE,
|
|
reasons: ?*WS_FAULT_REASON,
|
|
reasonCount: u32,
|
|
actor: WS_STRING,
|
|
node: WS_STRING,
|
|
detail: ?*WS_XML_BUFFER,
|
|
};
|
|
|
|
pub const WS_FAULT_DETAIL_DESCRIPTION = extern struct {
|
|
action: ?*WS_XML_STRING,
|
|
detailElementDescription: ?*WS_ELEMENT_DESCRIPTION,
|
|
};
|
|
|
|
pub const WS_HEAP_PROPERTY = extern struct {
|
|
id: WS_HEAP_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_HEAP_PROPERTIES = extern struct {
|
|
properties: ?*WS_HEAP_PROPERTY,
|
|
propertyCount: u32,
|
|
};
|
|
|
|
pub const WS_LISTENER_PROPERTY = extern struct {
|
|
id: WS_LISTENER_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_DISALLOWED_USER_AGENT_SUBSTRINGS = extern struct {
|
|
subStringCount: u32,
|
|
subStrings: ?*?*WS_STRING,
|
|
};
|
|
|
|
pub const WS_LISTENER_PROPERTIES = extern struct {
|
|
properties: ?*WS_LISTENER_PROPERTY,
|
|
propertyCount: u32,
|
|
};
|
|
|
|
pub const WS_HOST_NAMES = extern struct {
|
|
hostNames: ?*WS_STRING,
|
|
hostNameCount: u32,
|
|
};
|
|
|
|
pub const WS_CUSTOM_LISTENER_CALLBACKS = extern struct {
|
|
createListenerCallback: ?WS_CREATE_LISTENER_CALLBACK,
|
|
freeListenerCallback: ?WS_FREE_LISTENER_CALLBACK,
|
|
resetListenerCallback: ?WS_RESET_LISTENER_CALLBACK,
|
|
openListenerCallback: ?WS_OPEN_LISTENER_CALLBACK,
|
|
closeListenerCallback: ?WS_CLOSE_LISTENER_CALLBACK,
|
|
abortListenerCallback: ?WS_ABORT_LISTENER_CALLBACK,
|
|
getListenerPropertyCallback: ?WS_GET_LISTENER_PROPERTY_CALLBACK,
|
|
setListenerPropertyCallback: ?WS_SET_LISTENER_PROPERTY_CALLBACK,
|
|
createChannelForListenerCallback: ?WS_CREATE_CHANNEL_FOR_LISTENER_CALLBACK,
|
|
acceptChannelCallback: ?WS_ACCEPT_CHANNEL_CALLBACK,
|
|
};
|
|
|
|
pub const WS_MESSAGE_PROPERTY = extern struct {
|
|
id: WS_MESSAGE_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_MESSAGE_PROPERTIES = extern struct {
|
|
properties: ?*WS_MESSAGE_PROPERTY,
|
|
propertyCount: u32,
|
|
};
|
|
|
|
pub const WS_SECURITY_ALGORITHM_PROPERTY = extern struct {
|
|
id: WS_SECURITY_ALGORITHM_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_SECURITY_ALGORITHM_SUITE = extern struct {
|
|
canonicalizationAlgorithm: WS_SECURITY_ALGORITHM_ID,
|
|
digestAlgorithm: WS_SECURITY_ALGORITHM_ID,
|
|
symmetricSignatureAlgorithm: WS_SECURITY_ALGORITHM_ID,
|
|
asymmetricSignatureAlgorithm: WS_SECURITY_ALGORITHM_ID,
|
|
encryptionAlgorithm: WS_SECURITY_ALGORITHM_ID,
|
|
keyDerivationAlgorithm: WS_SECURITY_ALGORITHM_ID,
|
|
symmetricKeyWrapAlgorithm: WS_SECURITY_ALGORITHM_ID,
|
|
asymmetricKeyWrapAlgorithm: WS_SECURITY_ALGORITHM_ID,
|
|
minSymmetricKeyLength: u32,
|
|
maxSymmetricKeyLength: u32,
|
|
minAsymmetricKeyLength: u32,
|
|
maxAsymmetricKeyLength: u32,
|
|
properties: ?*WS_SECURITY_ALGORITHM_PROPERTY,
|
|
propertyCount: u32,
|
|
};
|
|
|
|
pub const WS_SECURITY_PROPERTY = extern struct {
|
|
id: WS_SECURITY_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_SECURITY_PROPERTIES = extern struct {
|
|
properties: ?*WS_SECURITY_PROPERTY,
|
|
propertyCount: u32,
|
|
};
|
|
|
|
pub const WS_SECURITY_BINDING_PROPERTY = extern struct {
|
|
id: WS_SECURITY_BINDING_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_SECURITY_BINDING_PROPERTIES = extern struct {
|
|
properties: ?*WS_SECURITY_BINDING_PROPERTY,
|
|
propertyCount: u32,
|
|
};
|
|
|
|
pub const WS_SERVICE_SECURITY_IDENTITIES = extern struct {
|
|
serviceIdentities: ?*WS_STRING,
|
|
serviceIdentityCount: u32,
|
|
};
|
|
|
|
pub const WS_CERTIFICATE_VALIDATION_CALLBACK_CONTEXT = extern struct {
|
|
callback: ?WS_CERTIFICATE_VALIDATION_CALLBACK,
|
|
state: ?*anyopaque,
|
|
};
|
|
|
|
pub const WS_CERT_CREDENTIAL = extern struct {
|
|
credentialType: WS_CERT_CREDENTIAL_TYPE,
|
|
};
|
|
|
|
pub const WS_SUBJECT_NAME_CERT_CREDENTIAL = extern struct {
|
|
credential: WS_CERT_CREDENTIAL,
|
|
storeLocation: u32,
|
|
storeName: WS_STRING,
|
|
subjectName: WS_STRING,
|
|
};
|
|
|
|
pub const WS_THUMBPRINT_CERT_CREDENTIAL = extern struct {
|
|
credential: WS_CERT_CREDENTIAL,
|
|
storeLocation: u32,
|
|
storeName: WS_STRING,
|
|
thumbprint: WS_STRING,
|
|
};
|
|
|
|
pub const WS_CUSTOM_CERT_CREDENTIAL = extern struct {
|
|
credential: WS_CERT_CREDENTIAL,
|
|
getCertCallback: ?WS_GET_CERT_CALLBACK,
|
|
getCertCallbackState: ?*anyopaque,
|
|
certIssuerListNotificationCallback: ?WS_CERT_ISSUER_LIST_NOTIFICATION_CALLBACK,
|
|
certIssuerListNotificationCallbackState: ?*anyopaque,
|
|
};
|
|
|
|
pub const WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL = extern struct {
|
|
credentialType: WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE,
|
|
};
|
|
|
|
pub const WS_STRING_WINDOWS_INTEGRATED_AUTH_CREDENTIAL = extern struct {
|
|
credential: WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
|
|
username: WS_STRING,
|
|
password: WS_STRING,
|
|
domain: WS_STRING,
|
|
};
|
|
|
|
pub const WS_DEFAULT_WINDOWS_INTEGRATED_AUTH_CREDENTIAL = extern struct {
|
|
credential: WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
|
|
};
|
|
|
|
pub const WS_OPAQUE_WINDOWS_INTEGRATED_AUTH_CREDENTIAL = extern struct {
|
|
credential: WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
|
|
opaqueAuthIdentity: ?*anyopaque,
|
|
};
|
|
|
|
pub const WS_USERNAME_CREDENTIAL = extern struct {
|
|
credentialType: WS_USERNAME_CREDENTIAL_TYPE,
|
|
};
|
|
|
|
pub const WS_STRING_USERNAME_CREDENTIAL = extern struct {
|
|
credential: WS_USERNAME_CREDENTIAL,
|
|
username: WS_STRING,
|
|
password: WS_STRING,
|
|
};
|
|
|
|
pub const WS_SECURITY_KEY_HANDLE = extern struct {
|
|
keyHandleType: WS_SECURITY_KEY_HANDLE_TYPE,
|
|
};
|
|
|
|
pub const WS_RAW_SYMMETRIC_SECURITY_KEY_HANDLE = extern struct {
|
|
keyHandle: WS_SECURITY_KEY_HANDLE,
|
|
rawKeyBytes: WS_BYTES,
|
|
};
|
|
|
|
pub const WS_NCRYPT_ASYMMETRIC_SECURITY_KEY_HANDLE = extern struct {
|
|
keyHandle: WS_SECURITY_KEY_HANDLE,
|
|
asymmetricKey: NCRYPT_KEY_HANDLE,
|
|
};
|
|
|
|
pub const WS_CAPI_ASYMMETRIC_SECURITY_KEY_HANDLE = extern struct {
|
|
keyHandle: WS_SECURITY_KEY_HANDLE,
|
|
provider: usize,
|
|
keySpec: u32,
|
|
};
|
|
|
|
pub const WS_SECURITY_BINDING = extern struct {
|
|
bindingType: WS_SECURITY_BINDING_TYPE,
|
|
properties: ?*WS_SECURITY_BINDING_PROPERTY,
|
|
propertyCount: u32,
|
|
};
|
|
|
|
pub const WS_SSL_TRANSPORT_SECURITY_BINDING = extern struct {
|
|
binding: WS_SECURITY_BINDING,
|
|
localCertCredential: ?*WS_CERT_CREDENTIAL,
|
|
};
|
|
|
|
pub const WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING = extern struct {
|
|
binding: WS_SECURITY_BINDING,
|
|
clientCredential: ?*WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
|
|
};
|
|
|
|
pub const WS_NAMEDPIPE_SSPI_TRANSPORT_SECURITY_BINDING = extern struct {
|
|
binding: WS_SECURITY_BINDING,
|
|
clientCredential: ?*WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
|
|
};
|
|
|
|
pub const WS_HTTP_HEADER_AUTH_SECURITY_BINDING = extern struct {
|
|
binding: WS_SECURITY_BINDING,
|
|
clientCredential: ?*WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
|
|
};
|
|
|
|
pub const WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING = extern struct {
|
|
binding: WS_SECURITY_BINDING,
|
|
bindingUsage: WS_MESSAGE_SECURITY_USAGE,
|
|
clientCredential: ?*WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
|
|
};
|
|
|
|
pub const WS_USERNAME_MESSAGE_SECURITY_BINDING = extern struct {
|
|
binding: WS_SECURITY_BINDING,
|
|
bindingUsage: WS_MESSAGE_SECURITY_USAGE,
|
|
clientCredential: ?*WS_USERNAME_CREDENTIAL,
|
|
passwordValidator: ?WS_VALIDATE_PASSWORD_CALLBACK,
|
|
passwordValidatorCallbackState: ?*anyopaque,
|
|
};
|
|
|
|
pub const WS_SECURITY_DESCRIPTION = extern struct {
|
|
securityBindings: ?*?*WS_SECURITY_BINDING,
|
|
securityBindingCount: u32,
|
|
properties: ?*WS_SECURITY_PROPERTY,
|
|
propertyCount: u32,
|
|
};
|
|
|
|
pub const WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING = extern struct {
|
|
binding: WS_SECURITY_BINDING,
|
|
bindingUsage: WS_MESSAGE_SECURITY_USAGE,
|
|
bootstrapSecurityDescription: ?*WS_SECURITY_DESCRIPTION,
|
|
};
|
|
|
|
pub const WS_SECURITY_CONTEXT_PROPERTY = extern struct {
|
|
id: WS_SECURITY_CONTEXT_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_XML_SECURITY_TOKEN_PROPERTY = extern struct {
|
|
id: WS_XML_SECURITY_TOKEN_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_XML_TOKEN_MESSAGE_SECURITY_BINDING = extern struct {
|
|
binding: WS_SECURITY_BINDING,
|
|
bindingUsage: WS_MESSAGE_SECURITY_USAGE,
|
|
xmlToken: ?*WS_SECURITY_TOKEN,
|
|
};
|
|
|
|
pub const WS_SAML_AUTHENTICATOR = extern struct {
|
|
authenticatorType: WS_SAML_AUTHENTICATOR_TYPE,
|
|
};
|
|
|
|
pub const WS_CERT_SIGNED_SAML_AUTHENTICATOR = extern struct {
|
|
authenticator: WS_SAML_AUTHENTICATOR,
|
|
trustedIssuerCerts: ?*const ?*CERT_CONTEXT,
|
|
trustedIssuerCertCount: u32,
|
|
decryptionCert: ?*const CERT_CONTEXT,
|
|
samlValidator: ?WS_VALIDATE_SAML_CALLBACK,
|
|
samlValidatorCallbackState: ?*anyopaque,
|
|
};
|
|
|
|
pub const WS_SAML_MESSAGE_SECURITY_BINDING = extern struct {
|
|
binding: WS_SECURITY_BINDING,
|
|
bindingUsage: WS_MESSAGE_SECURITY_USAGE,
|
|
authenticator: ?*WS_SAML_AUTHENTICATOR,
|
|
};
|
|
|
|
pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY = extern struct {
|
|
id: WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_ANY_ATTRIBUTE = extern struct {
|
|
localName: WS_XML_STRING,
|
|
ns: WS_XML_STRING,
|
|
value: ?*WS_XML_TEXT,
|
|
};
|
|
|
|
pub const WS_ANY_ATTRIBUTES = extern struct {
|
|
attributes: ?*WS_ANY_ATTRIBUTE,
|
|
attributeCount: u32,
|
|
};
|
|
|
|
pub const WS_BOOL_DESCRIPTION = extern struct {
|
|
value: BOOL,
|
|
};
|
|
|
|
pub const WS_GUID_DESCRIPTION = extern struct {
|
|
value: Guid,
|
|
};
|
|
|
|
pub const WS_DATETIME_DESCRIPTION = extern struct {
|
|
minValue: WS_DATETIME,
|
|
maxValue: WS_DATETIME,
|
|
};
|
|
|
|
pub const WS_DURATION = extern struct {
|
|
negative: BOOL,
|
|
years: u32,
|
|
months: u32,
|
|
days: u32,
|
|
hours: u32,
|
|
minutes: u32,
|
|
seconds: u32,
|
|
milliseconds: u32,
|
|
ticks: u32,
|
|
};
|
|
|
|
pub const WS_DURATION_DESCRIPTION = extern struct {
|
|
minValue: WS_DURATION,
|
|
maxValue: WS_DURATION,
|
|
comparer: ?WS_DURATION_COMPARISON_CALLBACK,
|
|
};
|
|
|
|
pub const WS_TIMESPAN_DESCRIPTION = extern struct {
|
|
minValue: WS_TIMESPAN,
|
|
maxValue: WS_TIMESPAN,
|
|
};
|
|
|
|
pub const WS_UNIQUE_ID_DESCRIPTION = extern struct {
|
|
minCharCount: u32,
|
|
maxCharCount: u32,
|
|
};
|
|
|
|
pub const WS_STRING_DESCRIPTION = extern struct {
|
|
minCharCount: u32,
|
|
maxCharCount: u32,
|
|
};
|
|
|
|
pub const WS_XML_STRING_DESCRIPTION = extern struct {
|
|
minByteCount: u32,
|
|
maxByteCount: u32,
|
|
};
|
|
|
|
pub const WS_XML_QNAME_DESCRIPTION = extern struct {
|
|
minLocalNameByteCount: u32,
|
|
maxLocalNameByteCount: u32,
|
|
minNsByteCount: u32,
|
|
maxNsByteCount: u32,
|
|
};
|
|
|
|
pub const WS_CHAR_ARRAY_DESCRIPTION = extern struct {
|
|
minCharCount: u32,
|
|
maxCharCount: u32,
|
|
};
|
|
|
|
pub const WS_BYTE_ARRAY_DESCRIPTION = extern struct {
|
|
minByteCount: u32,
|
|
maxByteCount: u32,
|
|
};
|
|
|
|
pub const WS_UTF8_ARRAY_DESCRIPTION = extern struct {
|
|
minByteCount: u32,
|
|
maxByteCount: u32,
|
|
};
|
|
|
|
pub const WS_WSZ_DESCRIPTION = extern struct {
|
|
minCharCount: u32,
|
|
maxCharCount: u32,
|
|
};
|
|
|
|
pub const WS_INT8_DESCRIPTION = extern struct {
|
|
minValue: CHAR,
|
|
maxValue: CHAR,
|
|
};
|
|
|
|
pub const WS_UINT8_DESCRIPTION = extern struct {
|
|
minValue: u8,
|
|
maxValue: u8,
|
|
};
|
|
|
|
pub const WS_INT16_DESCRIPTION = extern struct {
|
|
minValue: i16,
|
|
maxValue: i16,
|
|
};
|
|
|
|
pub const WS_UINT16_DESCRIPTION = extern struct {
|
|
minValue: u16,
|
|
maxValue: u16,
|
|
};
|
|
|
|
pub const WS_INT32_DESCRIPTION = extern struct {
|
|
minValue: i32,
|
|
maxValue: i32,
|
|
};
|
|
|
|
pub const WS_UINT32_DESCRIPTION = extern struct {
|
|
minValue: u32,
|
|
maxValue: u32,
|
|
};
|
|
|
|
pub const WS_INT64_DESCRIPTION = extern struct {
|
|
minValue: i64,
|
|
maxValue: i64,
|
|
};
|
|
|
|
pub const WS_UINT64_DESCRIPTION = extern struct {
|
|
minValue: u64,
|
|
maxValue: u64,
|
|
};
|
|
|
|
pub const WS_FLOAT_DESCRIPTION = extern struct {
|
|
minValue: f32,
|
|
maxValue: f32,
|
|
};
|
|
|
|
pub const WS_DOUBLE_DESCRIPTION = extern struct {
|
|
minValue: f64,
|
|
maxValue: f64,
|
|
};
|
|
|
|
pub const WS_DECIMAL_DESCRIPTION = extern struct {
|
|
minValue: DECIMAL,
|
|
maxValue: DECIMAL,
|
|
};
|
|
|
|
pub const WS_BYTES_DESCRIPTION = extern struct {
|
|
minByteCount: u32,
|
|
maxByteCount: u32,
|
|
};
|
|
|
|
pub const WS_ENUM_VALUE = extern struct {
|
|
value: i32,
|
|
name: ?*WS_XML_STRING,
|
|
};
|
|
|
|
pub const WS_ENUM_DESCRIPTION = extern struct {
|
|
values: ?*WS_ENUM_VALUE,
|
|
valueCount: u32,
|
|
maxByteCount: u32,
|
|
nameIndices: ?*u32,
|
|
};
|
|
|
|
pub const WS_ITEM_RANGE = extern struct {
|
|
minItemCount: u32,
|
|
maxItemCount: u32,
|
|
};
|
|
|
|
pub const WS_DEFAULT_VALUE = extern struct {
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_FIELD_DESCRIPTION = extern struct {
|
|
mapping: WS_FIELD_MAPPING,
|
|
localName: ?*WS_XML_STRING,
|
|
ns: ?*WS_XML_STRING,
|
|
type: WS_TYPE,
|
|
typeDescription: ?*anyopaque,
|
|
offset: u32,
|
|
options: u32,
|
|
defaultValue: ?*WS_DEFAULT_VALUE,
|
|
countOffset: u32,
|
|
itemLocalName: ?*WS_XML_STRING,
|
|
itemNs: ?*WS_XML_STRING,
|
|
itemRange: ?*WS_ITEM_RANGE,
|
|
};
|
|
|
|
pub const WS_UNION_FIELD_DESCRIPTION = extern struct {
|
|
value: i32,
|
|
field: WS_FIELD_DESCRIPTION,
|
|
};
|
|
|
|
pub const WS_STRUCT_DESCRIPTION = extern struct {
|
|
size: u32,
|
|
alignment: u32,
|
|
fields: ?*?*WS_FIELD_DESCRIPTION,
|
|
fieldCount: u32,
|
|
typeLocalName: ?*WS_XML_STRING,
|
|
typeNs: ?*WS_XML_STRING,
|
|
parentType: ?*WS_STRUCT_DESCRIPTION,
|
|
subTypes: ?*?*WS_STRUCT_DESCRIPTION,
|
|
subTypeCount: u32,
|
|
structOptions: u32,
|
|
};
|
|
|
|
pub const WS_UNION_DESCRIPTION = extern struct {
|
|
size: u32,
|
|
alignment: u32,
|
|
fields: ?*?*WS_UNION_FIELD_DESCRIPTION,
|
|
fieldCount: u32,
|
|
enumOffset: u32,
|
|
noneEnumValue: i32,
|
|
valueIndices: ?*u32,
|
|
};
|
|
|
|
pub const WS_ENDPOINT_ADDRESS_DESCRIPTION = extern struct {
|
|
addressingVersion: WS_ADDRESSING_VERSION,
|
|
};
|
|
|
|
pub const WS_FAULT_DESCRIPTION = extern struct {
|
|
envelopeVersion: WS_ENVELOPE_VERSION,
|
|
};
|
|
|
|
pub const WS_VOID_DESCRIPTION = extern struct {
|
|
size: u32,
|
|
};
|
|
|
|
pub const WS_CUSTOM_TYPE_DESCRIPTION = extern struct {
|
|
size: u32,
|
|
alignment: u32,
|
|
readCallback: ?WS_READ_TYPE_CALLBACK,
|
|
writeCallback: ?WS_WRITE_TYPE_CALLBACK,
|
|
descriptionData: ?*anyopaque,
|
|
isDefaultValueCallback: ?WS_IS_DEFAULT_VALUE_CALLBACK,
|
|
};
|
|
|
|
pub const WS_ATTRIBUTE_DESCRIPTION = extern struct {
|
|
attributeLocalName: ?*WS_XML_STRING,
|
|
attributeNs: ?*WS_XML_STRING,
|
|
type: WS_TYPE,
|
|
typeDescription: ?*anyopaque,
|
|
};
|
|
|
|
pub const WS_PARAMETER_DESCRIPTION = extern struct {
|
|
parameterType: WS_PARAMETER_TYPE,
|
|
inputMessageIndex: u16,
|
|
outputMessageIndex: u16,
|
|
};
|
|
|
|
pub const WS_OPERATION_DESCRIPTION = extern struct {
|
|
versionInfo: u32,
|
|
inputMessageDescription: ?*WS_MESSAGE_DESCRIPTION,
|
|
outputMessageDescription: ?*WS_MESSAGE_DESCRIPTION,
|
|
inputMessageOptions: u32,
|
|
outputMessageOptions: u32,
|
|
parameterCount: u16,
|
|
parameterDescription: ?*WS_PARAMETER_DESCRIPTION,
|
|
stubCallback: ?WS_SERVICE_STUB_CALLBACK,
|
|
style: WS_OPERATION_STYLE,
|
|
};
|
|
|
|
pub const WS_CONTRACT_DESCRIPTION = extern struct {
|
|
operationCount: u32,
|
|
operations: ?*?*WS_OPERATION_DESCRIPTION,
|
|
};
|
|
|
|
pub const WS_SERVICE_CONTRACT = extern struct {
|
|
contractDescription: ?*const WS_CONTRACT_DESCRIPTION,
|
|
defaultMessageHandlerCallback: ?WS_SERVICE_MESSAGE_RECEIVE_CALLBACK,
|
|
methodTable: ?*const anyopaque,
|
|
};
|
|
|
|
pub const WS_SERVICE_PROPERTY = extern struct {
|
|
id: WS_SERVICE_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_SERVICE_ENDPOINT_PROPERTY = extern struct {
|
|
id: WS_SERVICE_ENDPOINT_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_SERVICE_PROPERTY_ACCEPT_CALLBACK = extern struct {
|
|
callback: ?WS_SERVICE_ACCEPT_CHANNEL_CALLBACK,
|
|
};
|
|
|
|
pub const WS_SERVICE_METADATA_DOCUMENT = extern struct {
|
|
content: ?*WS_XML_STRING,
|
|
name: ?*WS_STRING,
|
|
};
|
|
|
|
pub const WS_SERVICE_METADATA = extern struct {
|
|
documentCount: u32,
|
|
documents: ?*?*WS_SERVICE_METADATA_DOCUMENT,
|
|
serviceName: ?*WS_XML_STRING,
|
|
serviceNs: ?*WS_XML_STRING,
|
|
};
|
|
|
|
pub const WS_SERVICE_PROPERTY_CLOSE_CALLBACK = extern struct {
|
|
callback: ?WS_SERVICE_CLOSE_CHANNEL_CALLBACK,
|
|
};
|
|
|
|
pub const WS_SERVICE_ENDPOINT_METADATA = extern struct {
|
|
portName: ?*WS_XML_STRING,
|
|
bindingName: ?*WS_XML_STRING,
|
|
bindingNs: ?*WS_XML_STRING,
|
|
};
|
|
|
|
pub const WS_SERVICE_ENDPOINT = extern struct {
|
|
address: WS_ENDPOINT_ADDRESS,
|
|
channelBinding: WS_CHANNEL_BINDING,
|
|
channelType: WS_CHANNEL_TYPE,
|
|
securityDescription: ?*const WS_SECURITY_DESCRIPTION,
|
|
contract: ?*const WS_SERVICE_CONTRACT,
|
|
authorizationCallback: ?WS_SERVICE_SECURITY_CALLBACK,
|
|
properties: ?*const WS_SERVICE_ENDPOINT_PROPERTY,
|
|
propertyCount: u32,
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
};
|
|
|
|
pub const WS_PROXY_PROPERTY = extern struct {
|
|
id: WS_PROXY_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_PROXY_MESSAGE_CALLBACK_CONTEXT = extern struct {
|
|
callback: ?WS_PROXY_MESSAGE_CALLBACK,
|
|
state: ?*anyopaque,
|
|
};
|
|
|
|
pub const WS_CALL_PROPERTY = extern struct {
|
|
id: WS_CALL_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_URL = extern struct {
|
|
scheme: WS_URL_SCHEME_TYPE,
|
|
};
|
|
|
|
pub const WS_HTTP_URL = extern struct {
|
|
url: WS_URL,
|
|
host: WS_STRING,
|
|
port: u16,
|
|
portAsString: WS_STRING,
|
|
path: WS_STRING,
|
|
query: WS_STRING,
|
|
fragment: WS_STRING,
|
|
};
|
|
|
|
pub const WS_HTTPS_URL = extern struct {
|
|
url: WS_URL,
|
|
host: WS_STRING,
|
|
port: u16,
|
|
portAsString: WS_STRING,
|
|
path: WS_STRING,
|
|
query: WS_STRING,
|
|
fragment: WS_STRING,
|
|
};
|
|
|
|
pub const WS_NETTCP_URL = extern struct {
|
|
url: WS_URL,
|
|
host: WS_STRING,
|
|
port: u16,
|
|
portAsString: WS_STRING,
|
|
path: WS_STRING,
|
|
query: WS_STRING,
|
|
fragment: WS_STRING,
|
|
};
|
|
|
|
pub const WS_SOAPUDP_URL = extern struct {
|
|
url: WS_URL,
|
|
host: WS_STRING,
|
|
port: u16,
|
|
portAsString: WS_STRING,
|
|
path: WS_STRING,
|
|
query: WS_STRING,
|
|
fragment: WS_STRING,
|
|
};
|
|
|
|
pub const WS_NETPIPE_URL = extern struct {
|
|
url: WS_URL,
|
|
host: WS_STRING,
|
|
port: u16,
|
|
portAsString: WS_STRING,
|
|
path: WS_STRING,
|
|
query: WS_STRING,
|
|
fragment: WS_STRING,
|
|
};
|
|
|
|
pub const WS_UNIQUE_ID = extern struct {
|
|
uri: WS_STRING,
|
|
guid: Guid,
|
|
};
|
|
|
|
pub const WS_BUFFERS = extern struct {
|
|
bufferCount: u32,
|
|
buffers: ?*WS_BYTES,
|
|
};
|
|
|
|
pub const WS_METADATA_ENDPOINT = extern struct {
|
|
endpointAddress: WS_ENDPOINT_ADDRESS,
|
|
endpointPolicy: ?*WS_POLICY,
|
|
portName: ?*WS_XML_STRING,
|
|
serviceName: ?*WS_XML_STRING,
|
|
serviceNs: ?*WS_XML_STRING,
|
|
bindingName: ?*WS_XML_STRING,
|
|
bindingNs: ?*WS_XML_STRING,
|
|
portTypeName: ?*WS_XML_STRING,
|
|
portTypeNs: ?*WS_XML_STRING,
|
|
};
|
|
|
|
pub const WS_METADATA_ENDPOINTS = extern struct {
|
|
endpoints: ?*WS_METADATA_ENDPOINT,
|
|
endpointCount: u32,
|
|
};
|
|
|
|
pub const WS_METADATA_PROPERTY = extern struct {
|
|
id: WS_METADATA_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_POLICY_PROPERTY = extern struct {
|
|
id: WS_POLICY_PROPERTY_ID,
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
};
|
|
|
|
pub const WS_POLICY_PROPERTIES = extern struct {
|
|
properties: ?*WS_POLICY_PROPERTY,
|
|
propertyCount: u32,
|
|
};
|
|
|
|
pub const WS_SECURITY_BINDING_PROPERTY_CONSTRAINT = extern struct {
|
|
id: WS_SECURITY_BINDING_PROPERTY_ID,
|
|
allowedValues: ?*anyopaque,
|
|
allowedValuesSize: u32,
|
|
out: extern struct {
|
|
securityBindingProperty: WS_SECURITY_BINDING_PROPERTY,
|
|
},
|
|
};
|
|
|
|
pub const WS_SECURITY_BINDING_CONSTRAINT = extern struct {
|
|
type: WS_SECURITY_BINDING_CONSTRAINT_TYPE,
|
|
propertyConstraints: ?*WS_SECURITY_BINDING_PROPERTY_CONSTRAINT,
|
|
propertyConstraintCount: u32,
|
|
};
|
|
|
|
pub const WS_SSL_TRANSPORT_SECURITY_BINDING_CONSTRAINT = extern struct {
|
|
bindingConstraint: WS_SECURITY_BINDING_CONSTRAINT,
|
|
out: extern struct {
|
|
clientCertCredentialRequired: BOOL,
|
|
},
|
|
};
|
|
|
|
pub const WS_USERNAME_MESSAGE_SECURITY_BINDING_CONSTRAINT = extern struct {
|
|
bindingConstraint: WS_SECURITY_BINDING_CONSTRAINT,
|
|
bindingUsage: WS_MESSAGE_SECURITY_USAGE,
|
|
};
|
|
|
|
pub const WS_HTTP_HEADER_AUTH_SECURITY_BINDING_CONSTRAINT = extern struct {
|
|
bindingConstraint: WS_SECURITY_BINDING_CONSTRAINT,
|
|
};
|
|
|
|
pub const WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_CONSTRAINT = extern struct {
|
|
bindingConstraint: WS_SECURITY_BINDING_CONSTRAINT,
|
|
};
|
|
|
|
pub const WS_CERT_MESSAGE_SECURITY_BINDING_CONSTRAINT = extern struct {
|
|
bindingConstraint: WS_SECURITY_BINDING_CONSTRAINT,
|
|
bindingUsage: WS_MESSAGE_SECURITY_USAGE,
|
|
};
|
|
|
|
pub const WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_CONSTRAINT = extern struct {
|
|
bindingConstraint: WS_SECURITY_BINDING_CONSTRAINT,
|
|
bindingUsage: WS_MESSAGE_SECURITY_USAGE,
|
|
};
|
|
|
|
pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_CONSTRAINT = extern struct {
|
|
id: WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID,
|
|
allowedValues: ?*anyopaque,
|
|
allowedValuesSize: u32,
|
|
out: extern struct {
|
|
requestSecurityTokenProperty: WS_REQUEST_SECURITY_TOKEN_PROPERTY,
|
|
},
|
|
};
|
|
|
|
pub const WS_ISSUED_TOKEN_MESSAGE_SECURITY_BINDING_CONSTRAINT = extern struct {
|
|
bindingConstraint: WS_SECURITY_BINDING_CONSTRAINT,
|
|
bindingUsage: WS_MESSAGE_SECURITY_USAGE,
|
|
claimConstraints: ?*WS_XML_STRING,
|
|
claimConstraintCount: u32,
|
|
requestSecurityTokenPropertyConstraints: ?*WS_REQUEST_SECURITY_TOKEN_PROPERTY_CONSTRAINT,
|
|
requestSecurityTokenPropertyConstraintCount: u32,
|
|
out: extern struct {
|
|
issuerAddress: ?*WS_ENDPOINT_ADDRESS,
|
|
requestSecurityTokenTemplate: ?*WS_XML_BUFFER,
|
|
},
|
|
};
|
|
|
|
pub const WS_SECURITY_PROPERTY_CONSTRAINT = extern struct {
|
|
id: WS_SECURITY_PROPERTY_ID,
|
|
allowedValues: ?*anyopaque,
|
|
allowedValuesSize: u32,
|
|
out: extern struct {
|
|
securityProperty: WS_SECURITY_PROPERTY,
|
|
},
|
|
};
|
|
|
|
pub const WS_SECURITY_CONSTRAINTS = extern struct {
|
|
securityPropertyConstraints: ?*WS_SECURITY_PROPERTY_CONSTRAINT,
|
|
securityPropertyConstraintCount: u32,
|
|
securityBindingConstraints: ?*?*WS_SECURITY_BINDING_CONSTRAINT,
|
|
securityBindingConstraintCount: u32,
|
|
};
|
|
|
|
pub const WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_CONSTRAINT = extern struct {
|
|
bindingConstraint: WS_SECURITY_BINDING_CONSTRAINT,
|
|
bindingUsage: WS_MESSAGE_SECURITY_USAGE,
|
|
bootstrapSecurityConstraint: ?*WS_SECURITY_CONSTRAINTS,
|
|
};
|
|
|
|
pub const WS_CHANNEL_PROPERTY_CONSTRAINT = extern struct {
|
|
id: WS_CHANNEL_PROPERTY_ID,
|
|
allowedValues: ?*anyopaque,
|
|
allowedValuesSize: u32,
|
|
out: extern struct {
|
|
channelProperty: WS_CHANNEL_PROPERTY,
|
|
},
|
|
};
|
|
|
|
pub const WS_POLICY_EXTENSION = extern struct {
|
|
type: WS_POLICY_EXTENSION_TYPE,
|
|
};
|
|
|
|
pub const WS_ENDPOINT_POLICY_EXTENSION = extern struct {
|
|
policyExtension: WS_POLICY_EXTENSION,
|
|
assertionName: ?*WS_XML_STRING,
|
|
assertionNs: ?*WS_XML_STRING,
|
|
out: extern struct {
|
|
assertionValue: ?*WS_XML_BUFFER,
|
|
},
|
|
};
|
|
|
|
pub const WS_POLICY_CONSTRAINTS = extern struct {
|
|
channelBinding: WS_CHANNEL_BINDING,
|
|
channelPropertyConstraints: ?*WS_CHANNEL_PROPERTY_CONSTRAINT,
|
|
channelPropertyConstraintCount: u32,
|
|
securityConstraints: ?*WS_SECURITY_CONSTRAINTS,
|
|
policyExtensions: ?*?*WS_POLICY_EXTENSION,
|
|
policyExtensionCount: u32,
|
|
};
|
|
|
|
pub const WS_HTTP_POLICY_DESCRIPTION = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
};
|
|
|
|
pub const WS_SSL_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION = extern struct {
|
|
securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
|
|
};
|
|
|
|
pub const WS_HTTP_SSL_POLICY_DESCRIPTION = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
};
|
|
|
|
pub const WS_HTTP_HEADER_AUTH_SECURITY_BINDING_POLICY_DESCRIPTION = extern struct {
|
|
securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
|
|
};
|
|
|
|
pub const WS_HTTP_HEADER_AUTH_POLICY_DESCRIPTION = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
httpHeaderAuthSecurityBinding: WS_HTTP_HEADER_AUTH_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
};
|
|
|
|
pub const WS_HTTP_SSL_HEADER_AUTH_POLICY_DESCRIPTION = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
httpHeaderAuthSecurityBinding: WS_HTTP_HEADER_AUTH_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
};
|
|
|
|
pub const WS_USERNAME_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION = extern struct {
|
|
securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
|
|
bindingUsage: WS_MESSAGE_SECURITY_USAGE,
|
|
};
|
|
|
|
pub const WS_HTTP_SSL_USERNAME_POLICY_DESCRIPTION = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
usernameMessageSecurityBinding: WS_USERNAME_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
};
|
|
|
|
pub const WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION = extern struct {
|
|
securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
|
|
bindingUsage: WS_MESSAGE_SECURITY_USAGE,
|
|
};
|
|
|
|
pub const WS_HTTP_SSL_KERBEROS_APREQ_POLICY_DESCRIPTION = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
kerberosApreqMessageSecurityBinding: WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
};
|
|
|
|
pub const WS_TCP_POLICY_DESCRIPTION = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
};
|
|
|
|
pub const WS_SSPI_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION = extern struct {
|
|
securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
|
|
};
|
|
|
|
pub const WS_TCP_SSPI_POLICY_DESCRIPTION = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sspiTransportSecurityBinding: WS_SSPI_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
};
|
|
|
|
pub const WS_TCP_SSPI_USERNAME_POLICY_DESCRIPTION = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sspiTransportSecurityBinding: WS_SSPI_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
usernameMessageSecurityBinding: WS_USERNAME_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
};
|
|
|
|
pub const WS_TCP_SSPI_KERBEROS_APREQ_POLICY_DESCRIPTION = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sspiTransportSecurityBinding: WS_SSPI_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
kerberosApreqMessageSecurityBinding: WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
};
|
|
|
|
pub const WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION = extern struct {
|
|
securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
|
|
bindingUsage: WS_MESSAGE_SECURITY_USAGE,
|
|
};
|
|
|
|
pub const WS_SECURITY_CONTEXT_SECURITY_BINDING_POLICY_DESCRIPTION = extern struct {
|
|
securityContextMessageSecurityBinding: WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
};
|
|
|
|
pub const WS_TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_POLICY_DESCRIPTION = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sspiTransportSecurityBinding: WS_SSPI_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
kerberosApreqMessageSecurityBinding: WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
securityContextSecurityBinding: WS_SECURITY_CONTEXT_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
};
|
|
|
|
pub const WS_TCP_SSPI_USERNAME_SECURITY_CONTEXT_POLICY_DESCRIPTION = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sspiTransportSecurityBinding: WS_SSPI_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
usernameMessageSecurityBinding: WS_USERNAME_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
securityContextSecurityBinding: WS_SECURITY_CONTEXT_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
};
|
|
|
|
pub const WS_HTTP_SSL_USERNAME_SECURITY_CONTEXT_POLICY_DESCRIPTION = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
usernameMessageSecurityBinding: WS_USERNAME_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
securityContextSecurityBinding: WS_SECURITY_CONTEXT_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
};
|
|
|
|
pub const WS_HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_POLICY_DESCRIPTION = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
kerberosApreqMessageSecurityBinding: WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
securityContextSecurityBinding: WS_SECURITY_CONTEXT_SECURITY_BINDING_POLICY_DESCRIPTION,
|
|
};
|
|
|
|
pub const WS_HTTP_BINDING_TEMPLATE = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
};
|
|
|
|
pub const WS_TCP_BINDING_TEMPLATE = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
};
|
|
|
|
pub const WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE = extern struct {
|
|
securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
|
|
localCertCredential: ?*WS_CERT_CREDENTIAL,
|
|
};
|
|
|
|
pub const WS_HTTP_SSL_BINDING_TEMPLATE = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE,
|
|
};
|
|
|
|
pub const WS_HTTP_HEADER_AUTH_SECURITY_BINDING_TEMPLATE = extern struct {
|
|
securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
|
|
clientCredential: ?*WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
|
|
};
|
|
|
|
pub const WS_HTTP_HEADER_AUTH_BINDING_TEMPLATE = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
httpHeaderAuthSecurityBinding: WS_HTTP_HEADER_AUTH_SECURITY_BINDING_TEMPLATE,
|
|
};
|
|
|
|
pub const WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TEMPLATE = extern struct {
|
|
securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
|
|
clientCredential: ?*WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
|
|
};
|
|
|
|
pub const WS_TCP_SSPI_BINDING_TEMPLATE = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sspiTransportSecurityBinding: WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TEMPLATE,
|
|
};
|
|
|
|
pub const WS_HTTP_SSL_HEADER_AUTH_BINDING_TEMPLATE = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE,
|
|
httpHeaderAuthSecurityBinding: WS_HTTP_HEADER_AUTH_SECURITY_BINDING_TEMPLATE,
|
|
};
|
|
|
|
pub const WS_USERNAME_MESSAGE_SECURITY_BINDING_TEMPLATE = extern struct {
|
|
securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
|
|
clientCredential: ?*WS_USERNAME_CREDENTIAL,
|
|
passwordValidator: ?WS_VALIDATE_PASSWORD_CALLBACK,
|
|
passwordValidatorCallbackState: ?*anyopaque,
|
|
};
|
|
|
|
pub const WS_HTTP_SSL_USERNAME_BINDING_TEMPLATE = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE,
|
|
usernameMessageSecurityBinding: WS_USERNAME_MESSAGE_SECURITY_BINDING_TEMPLATE,
|
|
};
|
|
|
|
pub const WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TEMPLATE = extern struct {
|
|
securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
|
|
clientCredential: ?*WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
|
|
};
|
|
|
|
pub const WS_HTTP_SSL_KERBEROS_APREQ_BINDING_TEMPLATE = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE,
|
|
kerberosApreqMessageSecurityBinding: WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TEMPLATE,
|
|
};
|
|
|
|
pub const WS_TCP_SSPI_USERNAME_BINDING_TEMPLATE = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sspiTransportSecurityBinding: WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TEMPLATE,
|
|
usernameMessageSecurityBinding: WS_USERNAME_MESSAGE_SECURITY_BINDING_TEMPLATE,
|
|
};
|
|
|
|
pub const WS_TCP_SSPI_KERBEROS_APREQ_BINDING_TEMPLATE = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sspiTransportSecurityBinding: WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TEMPLATE,
|
|
kerberosApreqMessageSecurityBinding: WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TEMPLATE,
|
|
};
|
|
|
|
pub const WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_TEMPLATE = extern struct {
|
|
securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
|
|
};
|
|
|
|
pub const WS_SECURITY_CONTEXT_SECURITY_BINDING_TEMPLATE = extern struct {
|
|
securityContextMessageSecurityBinding: WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_TEMPLATE,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
};
|
|
|
|
pub const WS_HTTP_SSL_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE,
|
|
usernameMessageSecurityBinding: WS_USERNAME_MESSAGE_SECURITY_BINDING_TEMPLATE,
|
|
securityContextSecurityBinding: WS_SECURITY_CONTEXT_SECURITY_BINDING_TEMPLATE,
|
|
};
|
|
|
|
pub const WS_HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE,
|
|
kerberosApreqMessageSecurityBinding: WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TEMPLATE,
|
|
securityContextSecurityBinding: WS_SECURITY_CONTEXT_SECURITY_BINDING_TEMPLATE,
|
|
};
|
|
|
|
pub const WS_TCP_SSPI_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sspiTransportSecurityBinding: WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TEMPLATE,
|
|
usernameMessageSecurityBinding: WS_USERNAME_MESSAGE_SECURITY_BINDING_TEMPLATE,
|
|
securityContextSecurityBinding: WS_SECURITY_CONTEXT_SECURITY_BINDING_TEMPLATE,
|
|
};
|
|
|
|
pub const WS_TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE = extern struct {
|
|
channelProperties: WS_CHANNEL_PROPERTIES,
|
|
securityProperties: WS_SECURITY_PROPERTIES,
|
|
sspiTransportSecurityBinding: WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TEMPLATE,
|
|
kerberosApreqMessageSecurityBinding: WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TEMPLATE,
|
|
securityContextSecurityBinding: WS_SECURITY_CONTEXT_SECURITY_BINDING_TEMPLATE,
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows8.1'
|
|
const IID_IContentPrefetcherTaskTrigger_Value = Guid.initString("1b35a14a-6094-4799-a60e-e474e15d4dc9");
|
|
pub const IID_IContentPrefetcherTaskTrigger = &IID_IContentPrefetcherTaskTrigger_Value;
|
|
pub const IContentPrefetcherTaskTrigger = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IInspectable.VTable,
|
|
TriggerContentPrefetcherTask: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IContentPrefetcherTaskTrigger,
|
|
packageFullName: ?[*:0]const u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IContentPrefetcherTaskTrigger,
|
|
packageFullName: ?[*:0]const u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
IsRegisteredForContentPrefetch: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IContentPrefetcherTaskTrigger,
|
|
packageFullName: ?[*:0]const u16,
|
|
isRegistered: ?*u8,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IContentPrefetcherTaskTrigger,
|
|
packageFullName: ?[*:0]const u16,
|
|
isRegistered: ?*u8,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IInspectable.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IContentPrefetcherTaskTrigger_TriggerContentPrefetcherTask(self: *const T, packageFullName: ?[*:0]const u16) callconv(.Inline) HRESULT {
|
|
return @as(*const IContentPrefetcherTaskTrigger.VTable, @ptrCast(self.vtable)).TriggerContentPrefetcherTask(@as(*const IContentPrefetcherTaskTrigger, @ptrCast(self)), packageFullName);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IContentPrefetcherTaskTrigger_IsRegisteredForContentPrefetch(self: *const T, packageFullName: ?[*:0]const u16, isRegistered: ?*u8) callconv(.Inline) HRESULT {
|
|
return @as(*const IContentPrefetcherTaskTrigger.VTable, @ptrCast(self.vtable)).IsRegisteredForContentPrefetch(@as(*const IContentPrefetcherTaskTrigger, @ptrCast(self)), packageFullName, isRegistered);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
pub const WEBAUTHN_RP_ENTITY_INFORMATION = extern struct {
|
|
dwVersion: u32,
|
|
pwszId: ?[*:0]const u16,
|
|
pwszName: ?[*:0]const u16,
|
|
pwszIcon: ?[*:0]const u16,
|
|
};
|
|
|
|
pub const WEBAUTHN_USER_ENTITY_INFORMATION = extern struct {
|
|
dwVersion: u32,
|
|
cbId: u32,
|
|
pbId: ?*u8,
|
|
pwszName: ?[*:0]const u16,
|
|
pwszIcon: ?[*:0]const u16,
|
|
pwszDisplayName: ?[*:0]const u16,
|
|
};
|
|
|
|
pub const WEBAUTHN_CLIENT_DATA = extern struct {
|
|
dwVersion: u32,
|
|
cbClientDataJSON: u32,
|
|
pbClientDataJSON: ?*u8,
|
|
pwszHashAlgId: ?[*:0]const u16,
|
|
};
|
|
|
|
pub const WEBAUTHN_COSE_CREDENTIAL_PARAMETER = extern struct {
|
|
dwVersion: u32,
|
|
pwszCredentialType: ?[*:0]const u16,
|
|
lAlg: i32,
|
|
};
|
|
|
|
pub const WEBAUTHN_COSE_CREDENTIAL_PARAMETERS = extern struct {
|
|
cCredentialParameters: u32,
|
|
pCredentialParameters: ?*WEBAUTHN_COSE_CREDENTIAL_PARAMETER,
|
|
};
|
|
|
|
pub const WEBAUTHN_CREDENTIAL = extern struct {
|
|
dwVersion: u32,
|
|
cbId: u32,
|
|
pbId: ?*u8,
|
|
pwszCredentialType: ?[*:0]const u16,
|
|
};
|
|
|
|
pub const WEBAUTHN_CREDENTIALS = extern struct {
|
|
cCredentials: u32,
|
|
pCredentials: ?*WEBAUTHN_CREDENTIAL,
|
|
};
|
|
|
|
pub const WEBAUTHN_CREDENTIAL_EX = extern struct {
|
|
dwVersion: u32,
|
|
cbId: u32,
|
|
pbId: ?*u8,
|
|
pwszCredentialType: ?[*:0]const u16,
|
|
dwTransports: u32,
|
|
};
|
|
|
|
pub const WEBAUTHN_CREDENTIAL_LIST = extern struct {
|
|
cCredentials: u32,
|
|
ppCredentials: ?*?*WEBAUTHN_CREDENTIAL_EX,
|
|
};
|
|
|
|
pub const WEBAUTHN_CRED_PROTECT_EXTENSION_IN = extern struct {
|
|
dwCredProtect: u32,
|
|
bRequireCredProtect: BOOL,
|
|
};
|
|
|
|
pub const WEBAUTHN_CRED_BLOB_EXTENSION = extern struct {
|
|
cbCredBlob: u32,
|
|
pbCredBlob: ?*u8,
|
|
};
|
|
|
|
pub const WEBAUTHN_EXTENSION = extern struct {
|
|
pwszExtensionIdentifier: ?[*:0]const u16,
|
|
cbExtension: u32,
|
|
pvExtension: ?*anyopaque,
|
|
};
|
|
|
|
pub const WEBAUTHN_EXTENSIONS = extern struct {
|
|
cExtensions: u32,
|
|
pExtensions: ?*WEBAUTHN_EXTENSION,
|
|
};
|
|
|
|
pub const WEBAUTHN_AUTHENTICATOR_MAKE_CREDENTIAL_OPTIONS = extern struct {
|
|
dwVersion: u32,
|
|
dwTimeoutMilliseconds: u32,
|
|
CredentialList: WEBAUTHN_CREDENTIALS,
|
|
Extensions: WEBAUTHN_EXTENSIONS,
|
|
dwAuthenticatorAttachment: u32,
|
|
bRequireResidentKey: BOOL,
|
|
dwUserVerificationRequirement: u32,
|
|
dwAttestationConveyancePreference: u32,
|
|
dwFlags: u32,
|
|
pCancellationId: ?*Guid,
|
|
pExcludeCredentialList: ?*WEBAUTHN_CREDENTIAL_LIST,
|
|
dwEnterpriseAttestation: u32,
|
|
dwLargeBlobSupport: u32,
|
|
bPreferResidentKey: BOOL,
|
|
};
|
|
|
|
pub const WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS = extern struct {
|
|
dwVersion: u32,
|
|
dwTimeoutMilliseconds: u32,
|
|
CredentialList: WEBAUTHN_CREDENTIALS,
|
|
Extensions: WEBAUTHN_EXTENSIONS,
|
|
dwAuthenticatorAttachment: u32,
|
|
dwUserVerificationRequirement: u32,
|
|
dwFlags: u32,
|
|
pwszU2fAppId: ?[*:0]const u16,
|
|
pbU2fAppId: ?*BOOL,
|
|
pCancellationId: ?*Guid,
|
|
pAllowCredentialList: ?*WEBAUTHN_CREDENTIAL_LIST,
|
|
dwCredLargeBlobOperation: u32,
|
|
cbCredLargeBlob: u32,
|
|
pbCredLargeBlob: ?*u8,
|
|
};
|
|
|
|
pub const WEBAUTHN_X5C = extern struct {
|
|
cbData: u32,
|
|
pbData: ?*u8,
|
|
};
|
|
|
|
pub const WEBAUTHN_COMMON_ATTESTATION = extern struct {
|
|
dwVersion: u32,
|
|
pwszAlg: ?[*:0]const u16,
|
|
lAlg: i32,
|
|
cbSignature: u32,
|
|
pbSignature: ?*u8,
|
|
cX5c: u32,
|
|
pX5c: ?*WEBAUTHN_X5C,
|
|
pwszVer: ?[*:0]const u16,
|
|
cbCertInfo: u32,
|
|
pbCertInfo: ?*u8,
|
|
cbPubArea: u32,
|
|
pbPubArea: ?*u8,
|
|
};
|
|
|
|
pub const WEBAUTHN_CREDENTIAL_ATTESTATION = extern struct {
|
|
dwVersion: u32,
|
|
pwszFormatType: ?[*:0]const u16,
|
|
cbAuthenticatorData: u32,
|
|
pbAuthenticatorData: ?*u8,
|
|
cbAttestation: u32,
|
|
pbAttestation: ?*u8,
|
|
dwAttestationDecodeType: u32,
|
|
pvAttestationDecode: ?*anyopaque,
|
|
cbAttestationObject: u32,
|
|
pbAttestationObject: ?*u8,
|
|
cbCredentialId: u32,
|
|
pbCredentialId: ?*u8,
|
|
Extensions: WEBAUTHN_EXTENSIONS,
|
|
dwUsedTransport: u32,
|
|
bEpAtt: BOOL,
|
|
bLargeBlobSupported: BOOL,
|
|
bResidentKey: BOOL,
|
|
};
|
|
|
|
pub const WEBAUTHN_ASSERTION = extern struct {
|
|
dwVersion: u32,
|
|
cbAuthenticatorData: u32,
|
|
pbAuthenticatorData: ?*u8,
|
|
cbSignature: u32,
|
|
pbSignature: ?*u8,
|
|
Credential: WEBAUTHN_CREDENTIAL,
|
|
cbUserId: u32,
|
|
pbUserId: ?*u8,
|
|
Extensions: WEBAUTHN_EXTENSIONS,
|
|
cbCredLargeBlob: u32,
|
|
pbCredLargeBlob: ?*u8,
|
|
dwCredLargeBlobStatus: u32,
|
|
};
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// Section: Functions (203)
|
|
//--------------------------------------------------------------------------------
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsStartReaderCanonicalization(
|
|
reader: ?*WS_XML_READER,
|
|
writeCallback: ?WS_WRITE_CALLBACK,
|
|
writeCallbackState: ?*anyopaque,
|
|
properties: ?[*]const WS_XML_CANONICALIZATION_PROPERTY,
|
|
propertyCount: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsEndReaderCanonicalization(
|
|
reader: ?*WS_XML_READER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsStartWriterCanonicalization(
|
|
writer: ?*WS_XML_WRITER,
|
|
writeCallback: ?WS_WRITE_CALLBACK,
|
|
writeCallbackState: ?*anyopaque,
|
|
properties: ?[*]const WS_XML_CANONICALIZATION_PROPERTY,
|
|
propertyCount: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsEndWriterCanonicalization(
|
|
writer: ?*WS_XML_WRITER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCreateXmlBuffer(
|
|
heap: ?*WS_HEAP,
|
|
properties: ?[*]const WS_XML_BUFFER_PROPERTY,
|
|
propertyCount: u32,
|
|
buffer: ?*?*WS_XML_BUFFER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsRemoveNode(
|
|
nodePosition: ?*const WS_XML_NODE_POSITION,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCreateReader(
|
|
properties: ?[*]const WS_XML_READER_PROPERTY,
|
|
propertyCount: u32,
|
|
reader: ?*?*WS_XML_READER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsSetInput(
|
|
reader: ?*WS_XML_READER,
|
|
encoding: ?*const WS_XML_READER_ENCODING,
|
|
input: ?*const WS_XML_READER_INPUT,
|
|
properties: ?[*]const WS_XML_READER_PROPERTY,
|
|
propertyCount: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsSetInputToBuffer(
|
|
reader: ?*WS_XML_READER,
|
|
buffer: ?*WS_XML_BUFFER,
|
|
properties: ?[*]const WS_XML_READER_PROPERTY,
|
|
propertyCount: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsFreeReader(
|
|
reader: ?*WS_XML_READER,
|
|
) callconv(@import("std").os.windows.WINAPI) void;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetReaderProperty(
|
|
reader: ?*WS_XML_READER,
|
|
id: WS_XML_READER_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetReaderNode(
|
|
xmlReader: ?*WS_XML_READER,
|
|
node: ?*const ?*WS_XML_NODE,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsFillReader(
|
|
reader: ?*WS_XML_READER,
|
|
minSize: u32,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadStartElement(
|
|
reader: ?*WS_XML_READER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadToStartElement(
|
|
reader: ?*WS_XML_READER,
|
|
localName: ?*const WS_XML_STRING,
|
|
ns: ?*const WS_XML_STRING,
|
|
found: ?*BOOL,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadStartAttribute(
|
|
reader: ?*WS_XML_READER,
|
|
attributeIndex: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadEndAttribute(
|
|
reader: ?*WS_XML_READER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadNode(
|
|
reader: ?*WS_XML_READER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsSkipNode(
|
|
reader: ?*WS_XML_READER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadEndElement(
|
|
reader: ?*WS_XML_READER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsFindAttribute(
|
|
reader: ?*WS_XML_READER,
|
|
localName: ?*const WS_XML_STRING,
|
|
ns: ?*const WS_XML_STRING,
|
|
required: BOOL,
|
|
attributeIndex: ?*u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadValue(
|
|
reader: ?*WS_XML_READER,
|
|
valueType: WS_VALUE_TYPE,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadChars(
|
|
reader: ?*WS_XML_READER,
|
|
chars: [*:0]u16,
|
|
maxCharCount: u32,
|
|
actualCharCount: ?*u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadCharsUtf8(
|
|
reader: ?*WS_XML_READER,
|
|
bytes: [*:0]u8,
|
|
maxByteCount: u32,
|
|
actualByteCount: ?*u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadBytes(
|
|
reader: ?*WS_XML_READER,
|
|
// TODO: what to do with BytesParamIndex 2?
|
|
bytes: ?*anyopaque,
|
|
maxByteCount: u32,
|
|
actualByteCount: ?*u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadArray(
|
|
reader: ?*WS_XML_READER,
|
|
localName: ?*const WS_XML_STRING,
|
|
ns: ?*const WS_XML_STRING,
|
|
valueType: WS_VALUE_TYPE,
|
|
// TODO: what to do with BytesParamIndex 5?
|
|
array: ?*anyopaque,
|
|
arraySize: u32,
|
|
itemOffset: u32,
|
|
itemCount: u32,
|
|
actualItemCount: ?*u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetReaderPosition(
|
|
reader: ?*WS_XML_READER,
|
|
nodePosition: ?*WS_XML_NODE_POSITION,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsSetReaderPosition(
|
|
reader: ?*WS_XML_READER,
|
|
nodePosition: ?*const WS_XML_NODE_POSITION,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsMoveReader(
|
|
reader: ?*WS_XML_READER,
|
|
moveTo: WS_MOVE_TO,
|
|
found: ?*BOOL,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCreateWriter(
|
|
properties: ?[*]const WS_XML_WRITER_PROPERTY,
|
|
propertyCount: u32,
|
|
writer: ?*?*WS_XML_WRITER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsFreeWriter(
|
|
writer: ?*WS_XML_WRITER,
|
|
) callconv(@import("std").os.windows.WINAPI) void;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsSetOutput(
|
|
writer: ?*WS_XML_WRITER,
|
|
encoding: ?*const WS_XML_WRITER_ENCODING,
|
|
output: ?*const WS_XML_WRITER_OUTPUT,
|
|
properties: ?[*]const WS_XML_WRITER_PROPERTY,
|
|
propertyCount: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsSetOutputToBuffer(
|
|
writer: ?*WS_XML_WRITER,
|
|
buffer: ?*WS_XML_BUFFER,
|
|
properties: ?[*]const WS_XML_WRITER_PROPERTY,
|
|
propertyCount: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetWriterProperty(
|
|
writer: ?*WS_XML_WRITER,
|
|
id: WS_XML_WRITER_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsFlushWriter(
|
|
writer: ?*WS_XML_WRITER,
|
|
minSize: u32,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteStartElement(
|
|
writer: ?*WS_XML_WRITER,
|
|
prefix: ?*const WS_XML_STRING,
|
|
localName: ?*const WS_XML_STRING,
|
|
ns: ?*const WS_XML_STRING,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteEndStartElement(
|
|
writer: ?*WS_XML_WRITER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteXmlnsAttribute(
|
|
writer: ?*WS_XML_WRITER,
|
|
prefix: ?*const WS_XML_STRING,
|
|
ns: ?*const WS_XML_STRING,
|
|
singleQuote: BOOL,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteStartAttribute(
|
|
writer: ?*WS_XML_WRITER,
|
|
prefix: ?*const WS_XML_STRING,
|
|
localName: ?*const WS_XML_STRING,
|
|
ns: ?*const WS_XML_STRING,
|
|
singleQuote: BOOL,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteEndAttribute(
|
|
writer: ?*WS_XML_WRITER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteValue(
|
|
writer: ?*WS_XML_WRITER,
|
|
valueType: WS_VALUE_TYPE,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteXmlBuffer(
|
|
writer: ?*WS_XML_WRITER,
|
|
xmlBuffer: ?*WS_XML_BUFFER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadXmlBuffer(
|
|
reader: ?*WS_XML_READER,
|
|
heap: ?*WS_HEAP,
|
|
xmlBuffer: ?*?*WS_XML_BUFFER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteXmlBufferToBytes(
|
|
writer: ?*WS_XML_WRITER,
|
|
xmlBuffer: ?*WS_XML_BUFFER,
|
|
encoding: ?*const WS_XML_WRITER_ENCODING,
|
|
properties: ?[*]const WS_XML_WRITER_PROPERTY,
|
|
propertyCount: u32,
|
|
heap: ?*WS_HEAP,
|
|
bytes: ?*?*anyopaque,
|
|
byteCount: ?*u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadXmlBufferFromBytes(
|
|
reader: ?*WS_XML_READER,
|
|
encoding: ?*const WS_XML_READER_ENCODING,
|
|
properties: ?[*]const WS_XML_READER_PROPERTY,
|
|
propertyCount: u32,
|
|
// TODO: what to do with BytesParamIndex 5?
|
|
bytes: ?*const anyopaque,
|
|
byteCount: u32,
|
|
heap: ?*WS_HEAP,
|
|
xmlBuffer: ?*?*WS_XML_BUFFER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteArray(
|
|
writer: ?*WS_XML_WRITER,
|
|
localName: ?*const WS_XML_STRING,
|
|
ns: ?*const WS_XML_STRING,
|
|
valueType: WS_VALUE_TYPE,
|
|
// TODO: what to do with BytesParamIndex 5?
|
|
array: ?*const anyopaque,
|
|
arraySize: u32,
|
|
itemOffset: u32,
|
|
itemCount: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteQualifiedName(
|
|
writer: ?*WS_XML_WRITER,
|
|
prefix: ?*const WS_XML_STRING,
|
|
localName: ?*const WS_XML_STRING,
|
|
ns: ?*const WS_XML_STRING,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteChars(
|
|
writer: ?*WS_XML_WRITER,
|
|
chars: [*:0]const u16,
|
|
charCount: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteCharsUtf8(
|
|
writer: ?*WS_XML_WRITER,
|
|
bytes: [*:0]const u8,
|
|
byteCount: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteBytes(
|
|
writer: ?*WS_XML_WRITER,
|
|
// TODO: what to do with BytesParamIndex 2?
|
|
bytes: ?*const anyopaque,
|
|
byteCount: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsPushBytes(
|
|
writer: ?*WS_XML_WRITER,
|
|
callback: ?WS_PUSH_BYTES_CALLBACK,
|
|
callbackState: ?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsPullBytes(
|
|
writer: ?*WS_XML_WRITER,
|
|
callback: ?WS_PULL_BYTES_CALLBACK,
|
|
callbackState: ?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteEndElement(
|
|
writer: ?*WS_XML_WRITER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteText(
|
|
writer: ?*WS_XML_WRITER,
|
|
text: ?*const WS_XML_TEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteStartCData(
|
|
writer: ?*WS_XML_WRITER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteEndCData(
|
|
writer: ?*WS_XML_WRITER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteNode(
|
|
writer: ?*WS_XML_WRITER,
|
|
node: ?*const WS_XML_NODE,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetPrefixFromNamespace(
|
|
writer: ?*WS_XML_WRITER,
|
|
ns: ?*const WS_XML_STRING,
|
|
required: BOOL,
|
|
prefix: ?*const ?*WS_XML_STRING,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetWriterPosition(
|
|
writer: ?*WS_XML_WRITER,
|
|
nodePosition: ?*WS_XML_NODE_POSITION,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsSetWriterPosition(
|
|
writer: ?*WS_XML_WRITER,
|
|
nodePosition: ?*const WS_XML_NODE_POSITION,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsMoveWriter(
|
|
writer: ?*WS_XML_WRITER,
|
|
moveTo: WS_MOVE_TO,
|
|
found: ?*BOOL,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsTrimXmlWhitespace(
|
|
chars: [*:0]u16,
|
|
charCount: u32,
|
|
trimmedChars: ?*?*u16,
|
|
trimmedCount: ?*u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsVerifyXmlNCName(
|
|
ncNameChars: [*:0]const u16,
|
|
ncNameCharCount: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsXmlStringEquals(
|
|
string1: ?*const WS_XML_STRING,
|
|
string2: ?*const WS_XML_STRING,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetNamespaceFromPrefix(
|
|
reader: ?*WS_XML_READER,
|
|
prefix: ?*const WS_XML_STRING,
|
|
required: BOOL,
|
|
ns: ?*const ?*WS_XML_STRING,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadQualifiedName(
|
|
reader: ?*WS_XML_READER,
|
|
heap: ?*WS_HEAP,
|
|
prefix: ?*WS_XML_STRING,
|
|
localName: ?*WS_XML_STRING,
|
|
ns: ?*WS_XML_STRING,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetXmlAttribute(
|
|
reader: ?*WS_XML_READER,
|
|
localName: ?*const WS_XML_STRING,
|
|
heap: ?*WS_HEAP,
|
|
valueChars: ?*?*u16,
|
|
valueCharCount: ?*u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCopyNode(
|
|
writer: ?*WS_XML_WRITER,
|
|
reader: ?*WS_XML_READER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsAsyncExecute(
|
|
asyncState: ?*WS_ASYNC_STATE,
|
|
operation: ?WS_ASYNC_FUNCTION,
|
|
callbackModel: WS_CALLBACK_MODEL,
|
|
callbackState: ?*anyopaque,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCreateChannel(
|
|
channelType: WS_CHANNEL_TYPE,
|
|
channelBinding: WS_CHANNEL_BINDING,
|
|
properties: ?[*]const WS_CHANNEL_PROPERTY,
|
|
propertyCount: u32,
|
|
securityDescription: ?*const WS_SECURITY_DESCRIPTION,
|
|
channel: ?*?*WS_CHANNEL,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsOpenChannel(
|
|
channel: ?*WS_CHANNEL,
|
|
endpointAddress: ?*const WS_ENDPOINT_ADDRESS,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsSendMessage(
|
|
channel: ?*WS_CHANNEL,
|
|
message: ?*WS_MESSAGE,
|
|
messageDescription: ?*const WS_MESSAGE_DESCRIPTION,
|
|
writeOption: WS_WRITE_OPTION,
|
|
// TODO: what to do with BytesParamIndex 5?
|
|
bodyValue: ?*const anyopaque,
|
|
bodyValueSize: u32,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReceiveMessage(
|
|
channel: ?*WS_CHANNEL,
|
|
message: ?*WS_MESSAGE,
|
|
messageDescriptions: [*]const ?*const WS_MESSAGE_DESCRIPTION,
|
|
messageDescriptionCount: u32,
|
|
receiveOption: WS_RECEIVE_OPTION,
|
|
readBodyOption: WS_READ_OPTION,
|
|
heap: ?*WS_HEAP,
|
|
// TODO: what to do with BytesParamIndex 8?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
index: ?*u32,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsRequestReply(
|
|
channel: ?*WS_CHANNEL,
|
|
requestMessage: ?*WS_MESSAGE,
|
|
requestMessageDescription: ?*const WS_MESSAGE_DESCRIPTION,
|
|
writeOption: WS_WRITE_OPTION,
|
|
// TODO: what to do with BytesParamIndex 5?
|
|
requestBodyValue: ?*const anyopaque,
|
|
requestBodyValueSize: u32,
|
|
replyMessage: ?*WS_MESSAGE,
|
|
replyMessageDescription: ?*const WS_MESSAGE_DESCRIPTION,
|
|
readOption: WS_READ_OPTION,
|
|
heap: ?*WS_HEAP,
|
|
// TODO: what to do with BytesParamIndex 11?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsSendReplyMessage(
|
|
channel: ?*WS_CHANNEL,
|
|
replyMessage: ?*WS_MESSAGE,
|
|
replyMessageDescription: ?*const WS_MESSAGE_DESCRIPTION,
|
|
writeOption: WS_WRITE_OPTION,
|
|
// TODO: what to do with BytesParamIndex 5?
|
|
replyBodyValue: ?*const anyopaque,
|
|
replyBodyValueSize: u32,
|
|
requestMessage: ?*WS_MESSAGE,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsSendFaultMessageForError(
|
|
channel: ?*WS_CHANNEL,
|
|
replyMessage: ?*WS_MESSAGE,
|
|
faultError: ?*WS_ERROR,
|
|
faultErrorCode: HRESULT,
|
|
faultDisclosure: WS_FAULT_DISCLOSURE,
|
|
requestMessage: ?*WS_MESSAGE,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetChannelProperty(
|
|
channel: ?*WS_CHANNEL,
|
|
id: WS_CHANNEL_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsSetChannelProperty(
|
|
channel: ?*WS_CHANNEL,
|
|
id: WS_CHANNEL_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteMessageStart(
|
|
channel: ?*WS_CHANNEL,
|
|
message: ?*WS_MESSAGE,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteMessageEnd(
|
|
channel: ?*WS_CHANNEL,
|
|
message: ?*WS_MESSAGE,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadMessageStart(
|
|
channel: ?*WS_CHANNEL,
|
|
message: ?*WS_MESSAGE,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadMessageEnd(
|
|
channel: ?*WS_CHANNEL,
|
|
message: ?*WS_MESSAGE,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCloseChannel(
|
|
channel: ?*WS_CHANNEL,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsAbortChannel(
|
|
channel: ?*WS_CHANNEL,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsFreeChannel(
|
|
channel: ?*WS_CHANNEL,
|
|
) callconv(@import("std").os.windows.WINAPI) void;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsResetChannel(
|
|
channel: ?*WS_CHANNEL,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsAbandonMessage(
|
|
channel: ?*WS_CHANNEL,
|
|
message: ?*WS_MESSAGE,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsShutdownSessionChannel(
|
|
channel: ?*WS_CHANNEL,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetOperationContextProperty(
|
|
context: ?*const WS_OPERATION_CONTEXT,
|
|
id: WS_OPERATION_CONTEXT_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetDictionary(
|
|
encoding: WS_ENCODING,
|
|
dictionary: ?*?*WS_XML_DICTIONARY,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadEndpointAddressExtension(
|
|
reader: ?*WS_XML_READER,
|
|
endpointAddress: ?*WS_ENDPOINT_ADDRESS,
|
|
extensionType: WS_ENDPOINT_ADDRESS_EXTENSION_TYPE,
|
|
readOption: WS_READ_OPTION,
|
|
heap: ?*WS_HEAP,
|
|
// TODO: what to do with BytesParamIndex 6?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCreateError(
|
|
properties: ?[*]const WS_ERROR_PROPERTY,
|
|
propertyCount: u32,
|
|
@"error": ?*?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsAddErrorString(
|
|
@"error": ?*WS_ERROR,
|
|
string: ?*const WS_STRING,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetErrorString(
|
|
@"error": ?*WS_ERROR,
|
|
index: u32,
|
|
string: ?*WS_STRING,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCopyError(
|
|
source: ?*WS_ERROR,
|
|
destination: ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetErrorProperty(
|
|
@"error": ?*WS_ERROR,
|
|
id: WS_ERROR_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
buffer: ?*anyopaque,
|
|
bufferSize: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsSetErrorProperty(
|
|
@"error": ?*WS_ERROR,
|
|
id: WS_ERROR_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsResetError(
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsFreeError(
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) void;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetFaultErrorProperty(
|
|
@"error": ?*WS_ERROR,
|
|
id: WS_FAULT_ERROR_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
buffer: ?*anyopaque,
|
|
bufferSize: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsSetFaultErrorProperty(
|
|
@"error": ?*WS_ERROR,
|
|
id: WS_FAULT_ERROR_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCreateFaultFromError(
|
|
@"error": ?*WS_ERROR,
|
|
faultErrorCode: HRESULT,
|
|
faultDisclosure: WS_FAULT_DISCLOSURE,
|
|
heap: ?*WS_HEAP,
|
|
fault: ?*WS_FAULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsSetFaultErrorDetail(
|
|
@"error": ?*WS_ERROR,
|
|
faultDetailDescription: ?*const WS_FAULT_DETAIL_DESCRIPTION,
|
|
writeOption: WS_WRITE_OPTION,
|
|
// TODO: what to do with BytesParamIndex 4?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetFaultErrorDetail(
|
|
@"error": ?*WS_ERROR,
|
|
faultDetailDescription: ?*const WS_FAULT_DETAIL_DESCRIPTION,
|
|
readOption: WS_READ_OPTION,
|
|
heap: ?*WS_HEAP,
|
|
// TODO: what to do with BytesParamIndex 5?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCreateHeap(
|
|
maxSize: usize,
|
|
trimSize: usize,
|
|
properties: ?*const WS_HEAP_PROPERTY,
|
|
propertyCount: u32,
|
|
heap: ?*?*WS_HEAP,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsAlloc(
|
|
heap: ?*WS_HEAP,
|
|
size: usize,
|
|
ptr: ?*?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetHeapProperty(
|
|
heap: ?*WS_HEAP,
|
|
id: WS_HEAP_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsResetHeap(
|
|
heap: ?*WS_HEAP,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsFreeHeap(
|
|
heap: ?*WS_HEAP,
|
|
) callconv(@import("std").os.windows.WINAPI) void;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCreateListener(
|
|
channelType: WS_CHANNEL_TYPE,
|
|
channelBinding: WS_CHANNEL_BINDING,
|
|
properties: ?[*]const WS_LISTENER_PROPERTY,
|
|
propertyCount: u32,
|
|
securityDescription: ?*const WS_SECURITY_DESCRIPTION,
|
|
listener: ?*?*WS_LISTENER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsOpenListener(
|
|
listener: ?*WS_LISTENER,
|
|
url: ?*const WS_STRING,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsAcceptChannel(
|
|
listener: ?*WS_LISTENER,
|
|
channel: ?*WS_CHANNEL,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCloseListener(
|
|
listener: ?*WS_LISTENER,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsAbortListener(
|
|
listener: ?*WS_LISTENER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsResetListener(
|
|
listener: ?*WS_LISTENER,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsFreeListener(
|
|
listener: ?*WS_LISTENER,
|
|
) callconv(@import("std").os.windows.WINAPI) void;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetListenerProperty(
|
|
listener: ?*WS_LISTENER,
|
|
id: WS_LISTENER_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsSetListenerProperty(
|
|
listener: ?*WS_LISTENER,
|
|
id: WS_LISTENER_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCreateChannelForListener(
|
|
listener: ?*WS_LISTENER,
|
|
properties: ?[*]const WS_CHANNEL_PROPERTY,
|
|
propertyCount: u32,
|
|
channel: ?*?*WS_CHANNEL,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCreateMessage(
|
|
envelopeVersion: WS_ENVELOPE_VERSION,
|
|
addressingVersion: WS_ADDRESSING_VERSION,
|
|
properties: ?[*]const WS_MESSAGE_PROPERTY,
|
|
propertyCount: u32,
|
|
message: ?*?*WS_MESSAGE,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCreateMessageForChannel(
|
|
channel: ?*WS_CHANNEL,
|
|
properties: ?[*]const WS_MESSAGE_PROPERTY,
|
|
propertyCount: u32,
|
|
message: ?*?*WS_MESSAGE,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsInitializeMessage(
|
|
message: ?*WS_MESSAGE,
|
|
initialization: WS_MESSAGE_INITIALIZATION,
|
|
sourceMessage: ?*WS_MESSAGE,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsResetMessage(
|
|
message: ?*WS_MESSAGE,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsFreeMessage(
|
|
message: ?*WS_MESSAGE,
|
|
) callconv(@import("std").os.windows.WINAPI) void;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetHeaderAttributes(
|
|
message: ?*WS_MESSAGE,
|
|
reader: ?*WS_XML_READER,
|
|
headerAttributes: ?*u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetHeader(
|
|
message: ?*WS_MESSAGE,
|
|
headerType: WS_HEADER_TYPE,
|
|
valueType: WS_TYPE,
|
|
readOption: WS_READ_OPTION,
|
|
heap: ?*WS_HEAP,
|
|
// TODO: what to do with BytesParamIndex 6?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetCustomHeader(
|
|
message: ?*WS_MESSAGE,
|
|
customHeaderDescription: ?*const WS_ELEMENT_DESCRIPTION,
|
|
repeatingOption: WS_REPEATING_HEADER_OPTION,
|
|
headerIndex: u32,
|
|
readOption: WS_READ_OPTION,
|
|
heap: ?*WS_HEAP,
|
|
// TODO: what to do with BytesParamIndex 7?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
headerAttributes: ?*u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsRemoveHeader(
|
|
message: ?*WS_MESSAGE,
|
|
headerType: WS_HEADER_TYPE,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsSetHeader(
|
|
message: ?*WS_MESSAGE,
|
|
headerType: WS_HEADER_TYPE,
|
|
valueType: WS_TYPE,
|
|
writeOption: WS_WRITE_OPTION,
|
|
// TODO: what to do with BytesParamIndex 5?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsRemoveCustomHeader(
|
|
message: ?*WS_MESSAGE,
|
|
headerName: ?*const WS_XML_STRING,
|
|
headerNs: ?*const WS_XML_STRING,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsAddCustomHeader(
|
|
message: ?*WS_MESSAGE,
|
|
headerDescription: ?*const WS_ELEMENT_DESCRIPTION,
|
|
writeOption: WS_WRITE_OPTION,
|
|
// TODO: what to do with BytesParamIndex 4?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
headerAttributes: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsAddMappedHeader(
|
|
message: ?*WS_MESSAGE,
|
|
headerName: ?*const WS_XML_STRING,
|
|
valueType: WS_TYPE,
|
|
writeOption: WS_WRITE_OPTION,
|
|
// TODO: what to do with BytesParamIndex 5?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsRemoveMappedHeader(
|
|
message: ?*WS_MESSAGE,
|
|
headerName: ?*const WS_XML_STRING,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetMappedHeader(
|
|
message: ?*WS_MESSAGE,
|
|
headerName: ?*const WS_XML_STRING,
|
|
repeatingOption: WS_REPEATING_HEADER_OPTION,
|
|
headerIndex: u32,
|
|
valueType: WS_TYPE,
|
|
readOption: WS_READ_OPTION,
|
|
heap: ?*WS_HEAP,
|
|
// TODO: what to do with BytesParamIndex 8?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteBody(
|
|
message: ?*WS_MESSAGE,
|
|
bodyDescription: ?*const WS_ELEMENT_DESCRIPTION,
|
|
writeOption: WS_WRITE_OPTION,
|
|
// TODO: what to do with BytesParamIndex 4?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadBody(
|
|
message: ?*WS_MESSAGE,
|
|
bodyDescription: ?*const WS_ELEMENT_DESCRIPTION,
|
|
readOption: WS_READ_OPTION,
|
|
heap: ?*WS_HEAP,
|
|
// TODO: what to do with BytesParamIndex 5?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteEnvelopeStart(
|
|
message: ?*WS_MESSAGE,
|
|
writer: ?*WS_XML_WRITER,
|
|
doneCallback: ?WS_MESSAGE_DONE_CALLBACK,
|
|
doneCallbackState: ?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteEnvelopeEnd(
|
|
message: ?*WS_MESSAGE,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadEnvelopeStart(
|
|
message: ?*WS_MESSAGE,
|
|
reader: ?*WS_XML_READER,
|
|
doneCallback: ?WS_MESSAGE_DONE_CALLBACK,
|
|
doneCallbackState: ?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadEnvelopeEnd(
|
|
message: ?*WS_MESSAGE,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetMessageProperty(
|
|
message: ?*WS_MESSAGE,
|
|
id: WS_MESSAGE_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsSetMessageProperty(
|
|
message: ?*WS_MESSAGE,
|
|
id: WS_MESSAGE_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsAddressMessage(
|
|
message: ?*WS_MESSAGE,
|
|
address: ?*const WS_ENDPOINT_ADDRESS,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCheckMustUnderstandHeaders(
|
|
message: ?*WS_MESSAGE,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsMarkHeaderAsUnderstood(
|
|
message: ?*WS_MESSAGE,
|
|
headerPosition: ?*const WS_XML_NODE_POSITION,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsFillBody(
|
|
message: ?*WS_MESSAGE,
|
|
minSize: u32,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsFlushBody(
|
|
message: ?*WS_MESSAGE,
|
|
minSize: u32,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsRequestSecurityToken(
|
|
channel: ?*WS_CHANNEL,
|
|
properties: ?[*]const WS_REQUEST_SECURITY_TOKEN_PROPERTY,
|
|
propertyCount: u32,
|
|
token: ?*?*WS_SECURITY_TOKEN,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetSecurityTokenProperty(
|
|
securityToken: ?*WS_SECURITY_TOKEN,
|
|
id: WS_SECURITY_TOKEN_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
heap: ?*WS_HEAP,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCreateXmlSecurityToken(
|
|
tokenXml: ?*WS_XML_BUFFER,
|
|
tokenKey: ?*WS_SECURITY_KEY_HANDLE,
|
|
properties: ?[*]const WS_XML_SECURITY_TOKEN_PROPERTY,
|
|
propertyCount: u32,
|
|
token: ?*?*WS_SECURITY_TOKEN,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsFreeSecurityToken(
|
|
token: ?*WS_SECURITY_TOKEN,
|
|
) callconv(@import("std").os.windows.WINAPI) void;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsRevokeSecurityContext(
|
|
securityContext: ?*WS_SECURITY_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetSecurityContextProperty(
|
|
securityContext: ?*WS_SECURITY_CONTEXT,
|
|
id: WS_SECURITY_CONTEXT_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadElement(
|
|
reader: ?*WS_XML_READER,
|
|
elementDescription: ?*const WS_ELEMENT_DESCRIPTION,
|
|
readOption: WS_READ_OPTION,
|
|
heap: ?*WS_HEAP,
|
|
// TODO: what to do with BytesParamIndex 5?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadAttribute(
|
|
reader: ?*WS_XML_READER,
|
|
attributeDescription: ?*const WS_ATTRIBUTE_DESCRIPTION,
|
|
readOption: WS_READ_OPTION,
|
|
heap: ?*WS_HEAP,
|
|
// TODO: what to do with BytesParamIndex 5?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadType(
|
|
reader: ?*WS_XML_READER,
|
|
typeMapping: WS_TYPE_MAPPING,
|
|
type: WS_TYPE,
|
|
typeDescription: ?*const anyopaque,
|
|
readOption: WS_READ_OPTION,
|
|
heap: ?*WS_HEAP,
|
|
// TODO: what to do with BytesParamIndex 7?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteElement(
|
|
writer: ?*WS_XML_WRITER,
|
|
elementDescription: ?*const WS_ELEMENT_DESCRIPTION,
|
|
writeOption: WS_WRITE_OPTION,
|
|
// TODO: what to do with BytesParamIndex 4?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteAttribute(
|
|
writer: ?*WS_XML_WRITER,
|
|
attributeDescription: ?*const WS_ATTRIBUTE_DESCRIPTION,
|
|
writeOption: WS_WRITE_OPTION,
|
|
// TODO: what to do with BytesParamIndex 4?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsWriteType(
|
|
writer: ?*WS_XML_WRITER,
|
|
typeMapping: WS_TYPE_MAPPING,
|
|
type: WS_TYPE,
|
|
typeDescription: ?*const anyopaque,
|
|
writeOption: WS_WRITE_OPTION,
|
|
// TODO: what to do with BytesParamIndex 6?
|
|
value: ?*const anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsRegisterOperationForCancel(
|
|
context: ?*const WS_OPERATION_CONTEXT,
|
|
cancelCallback: ?WS_OPERATION_CANCEL_CALLBACK,
|
|
freestateCallback: ?WS_OPERATION_FREE_STATE_CALLBACK,
|
|
userState: ?*anyopaque,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetServiceHostProperty(
|
|
serviceHost: ?*WS_SERVICE_HOST,
|
|
id: WS_SERVICE_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCreateServiceHost(
|
|
endpoints: ?[*]const ?*const WS_SERVICE_ENDPOINT,
|
|
endpointCount: u16,
|
|
serviceProperties: ?[*]const WS_SERVICE_PROPERTY,
|
|
servicePropertyCount: u32,
|
|
serviceHost: ?*?*WS_SERVICE_HOST,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsOpenServiceHost(
|
|
serviceHost: ?*WS_SERVICE_HOST,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCloseServiceHost(
|
|
serviceHost: ?*WS_SERVICE_HOST,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsAbortServiceHost(
|
|
serviceHost: ?*WS_SERVICE_HOST,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsFreeServiceHost(
|
|
serviceHost: ?*WS_SERVICE_HOST,
|
|
) callconv(@import("std").os.windows.WINAPI) void;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsResetServiceHost(
|
|
serviceHost: ?*WS_SERVICE_HOST,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetServiceProxyProperty(
|
|
serviceProxy: ?*WS_SERVICE_PROXY,
|
|
id: WS_PROXY_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCreateServiceProxy(
|
|
channelType: WS_CHANNEL_TYPE,
|
|
channelBinding: WS_CHANNEL_BINDING,
|
|
securityDescription: ?*const WS_SECURITY_DESCRIPTION,
|
|
properties: ?[*]const WS_PROXY_PROPERTY,
|
|
propertyCount: u32,
|
|
channelProperties: ?[*]const WS_CHANNEL_PROPERTY,
|
|
channelPropertyCount: u32,
|
|
serviceProxy: ?*?*WS_SERVICE_PROXY,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsOpenServiceProxy(
|
|
serviceProxy: ?*WS_SERVICE_PROXY,
|
|
address: ?*const WS_ENDPOINT_ADDRESS,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCloseServiceProxy(
|
|
serviceProxy: ?*WS_SERVICE_PROXY,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsAbortServiceProxy(
|
|
serviceProxy: ?*WS_SERVICE_PROXY,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsFreeServiceProxy(
|
|
serviceProxy: ?*WS_SERVICE_PROXY,
|
|
) callconv(@import("std").os.windows.WINAPI) void;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsResetServiceProxy(
|
|
serviceProxy: ?*WS_SERVICE_PROXY,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsAbandonCall(
|
|
serviceProxy: ?*WS_SERVICE_PROXY,
|
|
callId: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCall(
|
|
serviceProxy: ?*WS_SERVICE_PROXY,
|
|
operation: ?*const WS_OPERATION_DESCRIPTION,
|
|
arguments: ?*const ?*anyopaque,
|
|
heap: ?*WS_HEAP,
|
|
callProperties: ?[*]const WS_CALL_PROPERTY,
|
|
callPropertyCount: u32,
|
|
asyncContext: ?*const WS_ASYNC_CONTEXT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsDecodeUrl(
|
|
url: ?*const WS_STRING,
|
|
flags: u32,
|
|
heap: ?*WS_HEAP,
|
|
outUrl: ?*?*WS_URL,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsEncodeUrl(
|
|
url: ?*const WS_URL,
|
|
flags: u32,
|
|
heap: ?*WS_HEAP,
|
|
outUrl: ?*WS_STRING,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCombineUrl(
|
|
baseUrl: ?*const WS_STRING,
|
|
referenceUrl: ?*const WS_STRING,
|
|
flags: u32,
|
|
heap: ?*WS_HEAP,
|
|
resultUrl: ?*WS_STRING,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsDateTimeToFileTime(
|
|
dateTime: ?*const WS_DATETIME,
|
|
fileTime: ?*FILETIME,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsFileTimeToDateTime(
|
|
fileTime: ?*const FILETIME,
|
|
dateTime: ?*WS_DATETIME,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCreateMetadata(
|
|
properties: ?[*]const WS_METADATA_PROPERTY,
|
|
propertyCount: u32,
|
|
metadata: ?*?*WS_METADATA,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsReadMetadata(
|
|
metadata: ?*WS_METADATA,
|
|
reader: ?*WS_XML_READER,
|
|
url: ?*const WS_STRING,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsFreeMetadata(
|
|
metadata: ?*WS_METADATA,
|
|
) callconv(@import("std").os.windows.WINAPI) void;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsResetMetadata(
|
|
metadata: ?*WS_METADATA,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetMetadataProperty(
|
|
metadata: ?*WS_METADATA,
|
|
id: WS_METADATA_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetMissingMetadataDocumentAddress(
|
|
metadata: ?*WS_METADATA,
|
|
address: ?*?*WS_ENDPOINT_ADDRESS,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetMetadataEndpoints(
|
|
metadata: ?*WS_METADATA,
|
|
endpoints: ?*WS_METADATA_ENDPOINTS,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsMatchPolicyAlternative(
|
|
policy: ?*WS_POLICY,
|
|
alternativeIndex: u32,
|
|
policyConstraints: ?*WS_POLICY_CONSTRAINTS,
|
|
matchRequired: BOOL,
|
|
heap: ?*WS_HEAP,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetPolicyProperty(
|
|
policy: ?*WS_POLICY,
|
|
id: WS_POLICY_PROPERTY_ID,
|
|
// TODO: what to do with BytesParamIndex 3?
|
|
value: ?*anyopaque,
|
|
valueSize: u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsGetPolicyAlternativeCount(
|
|
policy: ?*WS_POLICY,
|
|
count: ?*u32,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCreateServiceProxyFromTemplate(
|
|
channelType: WS_CHANNEL_TYPE,
|
|
properties: ?[*]const WS_PROXY_PROPERTY,
|
|
propertyCount: u32,
|
|
templateType: WS_BINDING_TEMPLATE_TYPE,
|
|
// TODO: what to do with BytesParamIndex 5?
|
|
templateValue: ?*anyopaque,
|
|
templateSize: u32,
|
|
templateDescription: ?*const anyopaque,
|
|
templateDescriptionSize: u32,
|
|
serviceProxy: ?*?*WS_SERVICE_PROXY,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows6.1'
|
|
pub extern "webservices" fn WsCreateServiceEndpointFromTemplate(
|
|
channelType: WS_CHANNEL_TYPE,
|
|
properties: ?[*]const WS_SERVICE_ENDPOINT_PROPERTY,
|
|
propertyCount: u32,
|
|
addressUrl: ?*const WS_STRING,
|
|
contract: ?*const WS_SERVICE_CONTRACT,
|
|
authorizationCallback: ?WS_SERVICE_SECURITY_CALLBACK,
|
|
heap: ?*WS_HEAP,
|
|
templateType: WS_BINDING_TEMPLATE_TYPE,
|
|
// TODO: what to do with BytesParamIndex 9?
|
|
templateValue: ?*anyopaque,
|
|
templateSize: u32,
|
|
templateDescription: ?*const anyopaque,
|
|
templateDescriptionSize: u32,
|
|
serviceEndpoint: ?*?*WS_SERVICE_ENDPOINT,
|
|
@"error": ?*WS_ERROR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
pub extern "webauthn" fn WebAuthNGetApiVersionNumber(
|
|
) callconv(@import("std").os.windows.WINAPI) u32;
|
|
|
|
pub extern "webauthn" fn WebAuthNIsUserVerifyingPlatformAuthenticatorAvailable(
|
|
pbIsUserVerifyingPlatformAuthenticatorAvailable: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
pub extern "webauthn" fn WebAuthNAuthenticatorMakeCredential(
|
|
hWnd: ?HWND,
|
|
pRpInformation: ?*WEBAUTHN_RP_ENTITY_INFORMATION,
|
|
pUserInformation: ?*WEBAUTHN_USER_ENTITY_INFORMATION,
|
|
pPubKeyCredParams: ?*WEBAUTHN_COSE_CREDENTIAL_PARAMETERS,
|
|
pWebAuthNClientData: ?*WEBAUTHN_CLIENT_DATA,
|
|
pWebAuthNMakeCredentialOptions: ?*WEBAUTHN_AUTHENTICATOR_MAKE_CREDENTIAL_OPTIONS,
|
|
ppWebAuthNCredentialAttestation: ?*?*WEBAUTHN_CREDENTIAL_ATTESTATION,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
pub extern "webauthn" fn WebAuthNAuthenticatorGetAssertion(
|
|
hWnd: ?HWND,
|
|
pwszRpId: ?[*:0]const u16,
|
|
pWebAuthNClientData: ?*WEBAUTHN_CLIENT_DATA,
|
|
pWebAuthNGetAssertionOptions: ?*WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS,
|
|
ppWebAuthNAssertion: ?*?*WEBAUTHN_ASSERTION,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
pub extern "webauthn" fn WebAuthNFreeCredentialAttestation(
|
|
pWebAuthNCredentialAttestation: ?*WEBAUTHN_CREDENTIAL_ATTESTATION,
|
|
) callconv(@import("std").os.windows.WINAPI) void;
|
|
|
|
pub extern "webauthn" fn WebAuthNFreeAssertion(
|
|
pWebAuthNAssertion: ?*WEBAUTHN_ASSERTION,
|
|
) callconv(@import("std").os.windows.WINAPI) void;
|
|
|
|
pub extern "webauthn" fn WebAuthNGetCancellationId(
|
|
pCancellationId: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
pub extern "webauthn" fn WebAuthNCancelCurrentOperation(
|
|
pCancellationId: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
pub extern "webauthn" fn WebAuthNGetErrorName(
|
|
hr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) ?PWSTR;
|
|
|
|
pub extern "webauthn" fn WebAuthNGetW3CExceptionDOMError(
|
|
hr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// Section: Unicode Aliases (0)
|
|
//--------------------------------------------------------------------------------
|
|
const thismodule = @This();
|
|
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
|
|
.ansi => struct {
|
|
},
|
|
.wide => struct {
|
|
},
|
|
.unspecified => if (@import("builtin").is_test) struct {
|
|
} else struct {
|
|
},
|
|
};
|
|
//--------------------------------------------------------------------------------
|
|
// Section: Imports (12)
|
|
//--------------------------------------------------------------------------------
|
|
const Guid = @import("../zig.zig").Guid;
|
|
const BOOL = @import("../foundation.zig").BOOL;
|
|
const CERT_CONTEXT = @import("../security/cryptography.zig").CERT_CONTEXT;
|
|
const CHAR = @import("../foundation.zig").CHAR;
|
|
const DECIMAL = @import("../foundation.zig").DECIMAL;
|
|
const FILETIME = @import("../foundation.zig").FILETIME;
|
|
const HRESULT = @import("../foundation.zig").HRESULT;
|
|
const HWND = @import("../foundation.zig").HWND;
|
|
const IInspectable = @import("../system/win_rt.zig").IInspectable;
|
|
const NCRYPT_KEY_HANDLE = @import("../security/cryptography.zig").NCRYPT_KEY_HANDLE;
|
|
const PWSTR = @import("../foundation.zig").PWSTR;
|
|
const SecPkgContext_IssuerListInfoEx = @import("../security/authentication/identity.zig").SecPkgContext_IssuerListInfoEx;
|
|
|
|
test {
|
|
// The following '_ = <FuncPtrType>' lines are a workaround for https://github.com/ziglang/zig/issues/4476
|
|
if (@hasDecl(@This(), "WS_READ_CALLBACK")) { _ = WS_READ_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_WRITE_CALLBACK")) { _ = WS_WRITE_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_PUSH_BYTES_CALLBACK")) { _ = WS_PUSH_BYTES_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_PULL_BYTES_CALLBACK")) { _ = WS_PULL_BYTES_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_DYNAMIC_STRING_CALLBACK")) { _ = WS_DYNAMIC_STRING_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_ASYNC_CALLBACK")) { _ = WS_ASYNC_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_CREATE_CHANNEL_CALLBACK")) { _ = WS_CREATE_CHANNEL_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_FREE_CHANNEL_CALLBACK")) { _ = WS_FREE_CHANNEL_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_RESET_CHANNEL_CALLBACK")) { _ = WS_RESET_CHANNEL_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_ABORT_CHANNEL_CALLBACK")) { _ = WS_ABORT_CHANNEL_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_OPEN_CHANNEL_CALLBACK")) { _ = WS_OPEN_CHANNEL_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_CLOSE_CHANNEL_CALLBACK")) { _ = WS_CLOSE_CHANNEL_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_SET_CHANNEL_PROPERTY_CALLBACK")) { _ = WS_SET_CHANNEL_PROPERTY_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_GET_CHANNEL_PROPERTY_CALLBACK")) { _ = WS_GET_CHANNEL_PROPERTY_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_READ_MESSAGE_START_CALLBACK")) { _ = WS_READ_MESSAGE_START_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_READ_MESSAGE_END_CALLBACK")) { _ = WS_READ_MESSAGE_END_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_WRITE_MESSAGE_START_CALLBACK")) { _ = WS_WRITE_MESSAGE_START_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_WRITE_MESSAGE_END_CALLBACK")) { _ = WS_WRITE_MESSAGE_END_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_ABANDON_MESSAGE_CALLBACK")) { _ = WS_ABANDON_MESSAGE_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_SHUTDOWN_SESSION_CHANNEL_CALLBACK")) { _ = WS_SHUTDOWN_SESSION_CHANNEL_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_CREATE_ENCODER_CALLBACK")) { _ = WS_CREATE_ENCODER_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_ENCODER_GET_CONTENT_TYPE_CALLBACK")) { _ = WS_ENCODER_GET_CONTENT_TYPE_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_ENCODER_START_CALLBACK")) { _ = WS_ENCODER_START_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_ENCODER_ENCODE_CALLBACK")) { _ = WS_ENCODER_ENCODE_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_ENCODER_END_CALLBACK")) { _ = WS_ENCODER_END_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_FREE_ENCODER_CALLBACK")) { _ = WS_FREE_ENCODER_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_CREATE_DECODER_CALLBACK")) { _ = WS_CREATE_DECODER_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_DECODER_GET_CONTENT_TYPE_CALLBACK")) { _ = WS_DECODER_GET_CONTENT_TYPE_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_DECODER_START_CALLBACK")) { _ = WS_DECODER_START_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_DECODER_DECODE_CALLBACK")) { _ = WS_DECODER_DECODE_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_DECODER_END_CALLBACK")) { _ = WS_DECODER_END_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_FREE_DECODER_CALLBACK")) { _ = WS_FREE_DECODER_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_HTTP_REDIRECT_CALLBACK")) { _ = WS_HTTP_REDIRECT_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_CREATE_LISTENER_CALLBACK")) { _ = WS_CREATE_LISTENER_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_FREE_LISTENER_CALLBACK")) { _ = WS_FREE_LISTENER_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_RESET_LISTENER_CALLBACK")) { _ = WS_RESET_LISTENER_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_OPEN_LISTENER_CALLBACK")) { _ = WS_OPEN_LISTENER_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_CLOSE_LISTENER_CALLBACK")) { _ = WS_CLOSE_LISTENER_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_GET_LISTENER_PROPERTY_CALLBACK")) { _ = WS_GET_LISTENER_PROPERTY_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_SET_LISTENER_PROPERTY_CALLBACK")) { _ = WS_SET_LISTENER_PROPERTY_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_ACCEPT_CHANNEL_CALLBACK")) { _ = WS_ACCEPT_CHANNEL_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_ABORT_LISTENER_CALLBACK")) { _ = WS_ABORT_LISTENER_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_CREATE_CHANNEL_FOR_LISTENER_CALLBACK")) { _ = WS_CREATE_CHANNEL_FOR_LISTENER_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_MESSAGE_DONE_CALLBACK")) { _ = WS_MESSAGE_DONE_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_CERTIFICATE_VALIDATION_CALLBACK")) { _ = WS_CERTIFICATE_VALIDATION_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_GET_CERT_CALLBACK")) { _ = WS_GET_CERT_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_CERT_ISSUER_LIST_NOTIFICATION_CALLBACK")) { _ = WS_CERT_ISSUER_LIST_NOTIFICATION_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_VALIDATE_PASSWORD_CALLBACK")) { _ = WS_VALIDATE_PASSWORD_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_VALIDATE_SAML_CALLBACK")) { _ = WS_VALIDATE_SAML_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_DURATION_COMPARISON_CALLBACK")) { _ = WS_DURATION_COMPARISON_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_READ_TYPE_CALLBACK")) { _ = WS_READ_TYPE_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_WRITE_TYPE_CALLBACK")) { _ = WS_WRITE_TYPE_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_IS_DEFAULT_VALUE_CALLBACK")) { _ = WS_IS_DEFAULT_VALUE_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_SERVICE_MESSAGE_RECEIVE_CALLBACK")) { _ = WS_SERVICE_MESSAGE_RECEIVE_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_OPERATION_CANCEL_CALLBACK")) { _ = WS_OPERATION_CANCEL_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_OPERATION_FREE_STATE_CALLBACK")) { _ = WS_OPERATION_FREE_STATE_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_SERVICE_STUB_CALLBACK")) { _ = WS_SERVICE_STUB_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_SERVICE_ACCEPT_CHANNEL_CALLBACK")) { _ = WS_SERVICE_ACCEPT_CHANNEL_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_SERVICE_CLOSE_CHANNEL_CALLBACK")) { _ = WS_SERVICE_CLOSE_CHANNEL_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_SERVICE_SECURITY_CALLBACK")) { _ = WS_SERVICE_SECURITY_CALLBACK; }
|
|
if (@hasDecl(@This(), "WS_PROXY_MESSAGE_CALLBACK")) { _ = WS_PROXY_MESSAGE_CALLBACK; }
|
|
|
|
@setEvalBranchQuota(
|
|
comptime @import("std").meta.declarations(@This()).len * 3
|
|
);
|
|
|
|
// reference all the pub declarations
|
|
if (!@import("builtin").is_test) return;
|
|
inline for (comptime @import("std").meta.declarations(@This())) |decl| {
|
|
_ = @field(@This(), decl.name);
|
|
}
|
|
}
|