]> git.proxmox.com Git - rustc.git/blame - vendor/windows-sys-0.28.0/src/Windows/Win32/Networking/WindowsWebServices/mod.rs
projects / rustc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
New upstream version 1.66.0+dfsg1
[rustc.git] / vendor / windows-sys-0.28.0 / src / Windows / Win32 / Networking / WindowsWebServices / mod.rs
CommitLineData
064997fb
FG		 1#![allow(non_snake_case, non_camel_case_types, non_upper_case_globals, clashing_extern_declarations, clippy::all)]
2#[link(name = "windows")]
3extern "system" {
4 #[cfg(feature = "Win32_Foundation")]
5 pub fn WebAuthNAuthenticatorGetAssertion(hwnd: super::super::Foundation::HWND, pwszrpid: super::super::Foundation::PWSTR, pwebauthnclientdata: *const WEBAUTHN_CLIENT_DATA, pwebauthngetassertionoptions: *const WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS, ppwebauthnassertion: *mut *mut WEBAUTHN_ASSERTION) -> ::windows_sys::core::HRESULT;
6 #[cfg(feature = "Win32_Foundation")]
7 pub fn WebAuthNAuthenticatorMakeCredential(
8 hwnd: super::super::Foundation::HWND,
9 prpinformation: *const WEBAUTHN_RP_ENTITY_INFORMATION,
10 puserinformation: *const WEBAUTHN_USER_ENTITY_INFORMATION,
11 ppubkeycredparams: *const WEBAUTHN_COSE_CREDENTIAL_PARAMETERS,
12 pwebauthnclientdata: *const WEBAUTHN_CLIENT_DATA,
13 pwebauthnmakecredentialoptions: *const WEBAUTHN_AUTHENTICATOR_MAKE_CREDENTIAL_OPTIONS,
14 ppwebauthncredentialattestation: *mut *mut WEBAUTHN_CREDENTIAL_ATTESTATION,
15 ) -> ::windows_sys::core::HRESULT;
16 pub fn WebAuthNCancelCurrentOperation(pcancellationid: *const ::windows_sys::core::GUID) -> ::windows_sys::core::HRESULT;
17 #[cfg(feature = "Win32_Foundation")]
18 pub fn WebAuthNFreeAssertion(pwebauthnassertion: *const WEBAUTHN_ASSERTION);
19 #[cfg(feature = "Win32_Foundation")]
20 pub fn WebAuthNFreeCredentialAttestation(pwebauthncredentialattestation: *const WEBAUTHN_CREDENTIAL_ATTESTATION);
21 pub fn WebAuthNGetApiVersionNumber() -> u32;
22 pub fn WebAuthNGetCancellationId(pcancellationid: *mut ::windows_sys::core::GUID) -> ::windows_sys::core::HRESULT;
23 #[cfg(feature = "Win32_Foundation")]
24 pub fn WebAuthNGetErrorName(hr: ::windows_sys::core::HRESULT) -> super::super::Foundation::PWSTR;
25 pub fn WebAuthNGetW3CExceptionDOMError(hr: ::windows_sys::core::HRESULT) -> ::windows_sys::core::HRESULT;
26 #[cfg(feature = "Win32_Foundation")]
27 pub fn WebAuthNIsUserVerifyingPlatformAuthenticatorAvailable(pbisuserverifyingplatformauthenticatoravailable: *mut super::super::Foundation::BOOL) -> ::windows_sys::core::HRESULT;
28 pub fn WsAbandonCall(serviceproxy: *const WS_SERVICE_PROXY, callid: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
29 pub fn WsAbandonMessage(channel: *const WS_CHANNEL, message: *const WS_MESSAGE, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
30 pub fn WsAbortChannel(channel: *const WS_CHANNEL, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
31 pub fn WsAbortListener(listener: *const WS_LISTENER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
32 pub fn WsAbortServiceHost(servicehost: *const WS_SERVICE_HOST, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
33 pub fn WsAbortServiceProxy(serviceproxy: *const WS_SERVICE_PROXY, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
34 pub fn WsAcceptChannel(listener: *const WS_LISTENER, channel: *const WS_CHANNEL, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
35 #[cfg(feature = "Win32_Foundation")]
36 pub fn WsAddCustomHeader(message: *const WS_MESSAGE, headerdescription: *const WS_ELEMENT_DESCRIPTION, writeoption: WS_WRITE_OPTION, value: *const ::core::ffi::c_void, valuesize: u32, headerattributes: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
37 #[cfg(feature = "Win32_Foundation")]
38 pub fn WsAddErrorString(error: *const WS_ERROR, string: *const WS_STRING) -> ::windows_sys::core::HRESULT;
39 #[cfg(feature = "Win32_Foundation")]
40 pub fn WsAddMappedHeader(message: *const WS_MESSAGE, headername: *const WS_XML_STRING, valuetype: WS_TYPE, writeoption: WS_WRITE_OPTION, value: *const ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
41 #[cfg(feature = "Win32_Foundation")]
42 pub fn WsAddressMessage(message: *const WS_MESSAGE, address: *const WS_ENDPOINT_ADDRESS, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
43 pub fn WsAlloc(heap: *const WS_HEAP, size: usize, ptr: *mut *mut ::core::ffi::c_void, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
44 pub fn WsAsyncExecute(asyncstate: *const WS_ASYNC_STATE, operation: ::core::option::Option<WS_ASYNC_FUNCTION>, callbackmodel: WS_CALLBACK_MODEL, callbackstate: *const ::core::ffi::c_void, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
45 #[cfg(feature = "Win32_Foundation")]
46 pub fn WsCall(serviceproxy: *const WS_SERVICE_PROXY, operation: *const WS_OPERATION_DESCRIPTION, arguments: *const *const ::core::ffi::c_void, heap: *const WS_HEAP, callproperties: *const WS_CALL_PROPERTY, callpropertycount: u32, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
47 pub fn WsCheckMustUnderstandHeaders(message: *const WS_MESSAGE, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
48 pub fn WsCloseChannel(channel: *const WS_CHANNEL, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
49 pub fn WsCloseListener(listener: *const WS_LISTENER, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
50 pub fn WsCloseServiceHost(servicehost: *const WS_SERVICE_HOST, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
51 pub fn WsCloseServiceProxy(serviceproxy: *const WS_SERVICE_PROXY, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
52 #[cfg(feature = "Win32_Foundation")]
53 pub fn WsCombineUrl(baseurl: *const WS_STRING, referenceurl: *const WS_STRING, flags: u32, heap: *const WS_HEAP, resulturl: *mut WS_STRING, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
54 pub fn WsCopyError(source: *const WS_ERROR, destination: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
55 pub fn WsCopyNode(writer: *const WS_XML_WRITER, reader: *const WS_XML_READER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
56 pub fn WsCreateChannel(channeltype: WS_CHANNEL_TYPE, channelbinding: WS_CHANNEL_BINDING, properties: *const WS_CHANNEL_PROPERTY, propertycount: u32, securitydescription: *const WS_SECURITY_DESCRIPTION, channel: *mut *mut WS_CHANNEL, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
57 pub fn WsCreateChannelForListener(listener: *const WS_LISTENER, properties: *const WS_CHANNEL_PROPERTY, propertycount: u32, channel: *mut *mut WS_CHANNEL, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
58 pub fn WsCreateError(properties: *const WS_ERROR_PROPERTY, propertycount: u32, error: *mut *mut WS_ERROR) -> ::windows_sys::core::HRESULT;
59 #[cfg(feature = "Win32_Foundation")]
60 pub fn WsCreateFaultFromError(error: *const WS_ERROR, faulterrorcode: ::windows_sys::core::HRESULT, faultdisclosure: WS_FAULT_DISCLOSURE, heap: *const WS_HEAP, fault: *mut WS_FAULT) -> ::windows_sys::core::HRESULT;
61 pub fn WsCreateHeap(maxsize: usize, trimsize: usize, properties: *const WS_HEAP_PROPERTY, propertycount: u32, heap: *mut *mut WS_HEAP, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
62 pub fn WsCreateListener(channeltype: WS_CHANNEL_TYPE, channelbinding: WS_CHANNEL_BINDING, properties: *const WS_LISTENER_PROPERTY, propertycount: u32, securitydescription: *const WS_SECURITY_DESCRIPTION, listener: *mut *mut WS_LISTENER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
63 pub fn WsCreateMessage(envelopeversion: WS_ENVELOPE_VERSION, addressingversion: WS_ADDRESSING_VERSION, properties: *const WS_MESSAGE_PROPERTY, propertycount: u32, message: *mut *mut WS_MESSAGE, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
64 pub fn WsCreateMessageForChannel(channel: *const WS_CHANNEL, properties: *const WS_MESSAGE_PROPERTY, propertycount: u32, message: *mut *mut WS_MESSAGE, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
65 pub fn WsCreateMetadata(properties: *const WS_METADATA_PROPERTY, propertycount: u32, metadata: *mut *mut WS_METADATA, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
66 pub fn WsCreateReader(properties: *const WS_XML_READER_PROPERTY, propertycount: u32, reader: *mut *mut WS_XML_READER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
67 #[cfg(feature = "Win32_Foundation")]
68 pub fn WsCreateServiceEndpointFromTemplate(
69 channeltype: WS_CHANNEL_TYPE,
70 properties: *const WS_SERVICE_ENDPOINT_PROPERTY,
71 propertycount: u32,
72 addressurl: *const WS_STRING,
73 contract: *const WS_SERVICE_CONTRACT,
74 authorizationcallback: ::core::option::Option<WS_SERVICE_SECURITY_CALLBACK>,
75 heap: *const WS_HEAP,
76 templatetype: WS_BINDING_TEMPLATE_TYPE,
77 templatevalue: *const ::core::ffi::c_void,
78 templatesize: u32,
79 templatedescription: *const ::core::ffi::c_void,
80 templatedescriptionsize: u32,
81 serviceendpoint: *mut *mut WS_SERVICE_ENDPOINT,
82 error: *const WS_ERROR,
83 ) -> ::windows_sys::core::HRESULT;
84 #[cfg(feature = "Win32_Foundation")]
85 pub fn WsCreateServiceHost(endpoints: *const *const WS_SERVICE_ENDPOINT, endpointcount: u16, serviceproperties: *const WS_SERVICE_PROPERTY, servicepropertycount: u32, servicehost: *mut *mut WS_SERVICE_HOST, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
86 pub 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: *mut *mut WS_SERVICE_PROXY, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
87 pub fn WsCreateServiceProxyFromTemplate(channeltype: WS_CHANNEL_TYPE, properties: *const WS_PROXY_PROPERTY, propertycount: u32, templatetype: WS_BINDING_TEMPLATE_TYPE, templatevalue: *const ::core::ffi::c_void, templatesize: u32, templatedescription: *const ::core::ffi::c_void, templatedescriptionsize: u32, serviceproxy: *mut *mut WS_SERVICE_PROXY, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
88 pub fn WsCreateWriter(properties: *const WS_XML_WRITER_PROPERTY, propertycount: u32, writer: *mut *mut WS_XML_WRITER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
89 pub fn WsCreateXmlBuffer(heap: *const WS_HEAP, properties: *const WS_XML_BUFFER_PROPERTY, propertycount: u32, buffer: *mut *mut WS_XML_BUFFER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
90 pub fn WsCreateXmlSecurityToken(tokenxml: *const WS_XML_BUFFER, tokenkey: *const WS_SECURITY_KEY_HANDLE, properties: *const WS_XML_SECURITY_TOKEN_PROPERTY, propertycount: u32, token: *mut *mut WS_SECURITY_TOKEN, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
91 #[cfg(feature = "Win32_Foundation")]
92 pub fn WsDateTimeToFileTime(datetime: *const WS_DATETIME, filetime: *mut super::super::Foundation::FILETIME, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
93 #[cfg(feature = "Win32_Foundation")]
94 pub fn WsDecodeUrl(url: *const WS_STRING, flags: u32, heap: *const WS_HEAP, outurl: *mut *mut WS_URL, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
95 #[cfg(feature = "Win32_Foundation")]
96 pub fn WsEncodeUrl(url: *const WS_URL, flags: u32, heap: *const WS_HEAP, outurl: *mut WS_STRING, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
97 pub fn WsEndReaderCanonicalization(reader: *const WS_XML_READER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
98 pub fn WsEndWriterCanonicalization(writer: *const WS_XML_WRITER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
99 #[cfg(feature = "Win32_Foundation")]
100 pub fn WsFileTimeToDateTime(filetime: *const super::super::Foundation::FILETIME, datetime: *mut WS_DATETIME, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
101 pub fn WsFillBody(message: *const WS_MESSAGE, minsize: u32, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
102 pub fn WsFillReader(reader: *const WS_XML_READER, minsize: u32, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
103 #[cfg(feature = "Win32_Foundation")]
104 pub fn WsFindAttribute(reader: *const WS_XML_READER, localname: *const WS_XML_STRING, ns: *const WS_XML_STRING, required: super::super::Foundation::BOOL, attributeindex: *mut u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
105 pub fn WsFlushBody(message: *const WS_MESSAGE, minsize: u32, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
106 pub fn WsFlushWriter(writer: *const WS_XML_WRITER, minsize: u32, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
107 pub fn WsFreeChannel(channel: *const WS_CHANNEL);
108 pub fn WsFreeError(error: *const WS_ERROR);
109 pub fn WsFreeHeap(heap: *const WS_HEAP);
110 pub fn WsFreeListener(listener: *const WS_LISTENER);
111 pub fn WsFreeMessage(message: *const WS_MESSAGE);
112 pub fn WsFreeMetadata(metadata: *const WS_METADATA);
113 pub fn WsFreeReader(reader: *const WS_XML_READER);
114 pub fn WsFreeSecurityToken(token: *const WS_SECURITY_TOKEN);
115 pub fn WsFreeServiceHost(servicehost: *const WS_SERVICE_HOST);
116 pub fn WsFreeServiceProxy(serviceproxy: *const WS_SERVICE_PROXY);
117 pub fn WsFreeWriter(writer: *const WS_XML_WRITER);
118 pub fn WsGetChannelProperty(channel: *const WS_CHANNEL, id: WS_CHANNEL_PROPERTY_ID, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
119 #[cfg(feature = "Win32_Foundation")]
120 pub fn WsGetCustomHeader(message: *const WS_MESSAGE, customheaderdescription: *const WS_ELEMENT_DESCRIPTION, repeatingoption: WS_REPEATING_HEADER_OPTION, headerindex: u32, readoption: WS_READ_OPTION, heap: *const WS_HEAP, value: *mut ::core::ffi::c_void, valuesize: u32, headerattributes: *mut u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
121 #[cfg(feature = "Win32_Foundation")]
122 pub fn WsGetDictionary(encoding: WS_ENCODING, dictionary: *mut *mut WS_XML_DICTIONARY, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
123 pub fn WsGetErrorProperty(error: *const WS_ERROR, id: WS_ERROR_PROPERTY_ID, buffer: *mut ::core::ffi::c_void, buffersize: u32) -> ::windows_sys::core::HRESULT;
124 #[cfg(feature = "Win32_Foundation")]
125 pub fn WsGetErrorString(error: *const WS_ERROR, index: u32, string: *mut WS_STRING) -> ::windows_sys::core::HRESULT;
126 #[cfg(feature = "Win32_Foundation")]
127 pub fn WsGetFaultErrorDetail(error: *const WS_ERROR, faultdetaildescription: *const WS_FAULT_DETAIL_DESCRIPTION, readoption: WS_READ_OPTION, heap: *const WS_HEAP, value: *mut ::core::ffi::c_void, valuesize: u32) -> ::windows_sys::core::HRESULT;
128 pub fn WsGetFaultErrorProperty(error: *const WS_ERROR, id: WS_FAULT_ERROR_PROPERTY_ID, buffer: *mut ::core::ffi::c_void, buffersize: u32) -> ::windows_sys::core::HRESULT;
129 pub fn WsGetHeader(message: *const WS_MESSAGE, headertype: WS_HEADER_TYPE, valuetype: WS_TYPE, readoption: WS_READ_OPTION, heap: *const WS_HEAP, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
130 pub fn WsGetHeaderAttributes(message: *const WS_MESSAGE, reader: *const WS_XML_READER, headerattributes: *mut u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
131 pub fn WsGetHeapProperty(heap: *const WS_HEAP, id: WS_HEAP_PROPERTY_ID, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
132 pub fn WsGetListenerProperty(listener: *const WS_LISTENER, id: WS_LISTENER_PROPERTY_ID, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
133 #[cfg(feature = "Win32_Foundation")]
134 pub fn WsGetMappedHeader(message: *const WS_MESSAGE, headername: *const WS_XML_STRING, repeatingoption: WS_REPEATING_HEADER_OPTION, headerindex: u32, valuetype: WS_TYPE, readoption: WS_READ_OPTION, heap: *const WS_HEAP, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
135 pub fn WsGetMessageProperty(message: *const WS_MESSAGE, id: WS_MESSAGE_PROPERTY_ID, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
136 #[cfg(feature = "Win32_Foundation")]
137 pub fn WsGetMetadataEndpoints(metadata: *const WS_METADATA, endpoints: *mut WS_METADATA_ENDPOINTS, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
138 pub fn WsGetMetadataProperty(metadata: *const WS_METADATA, id: WS_METADATA_PROPERTY_ID, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
139 #[cfg(feature = "Win32_Foundation")]
140 pub fn WsGetMissingMetadataDocumentAddress(metadata: *const WS_METADATA, address: *mut *mut WS_ENDPOINT_ADDRESS, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
141 #[cfg(feature = "Win32_Foundation")]
142 pub fn WsGetNamespaceFromPrefix(reader: *const WS_XML_READER, prefix: *const WS_XML_STRING, required: super::super::Foundation::BOOL, ns: *mut *mut WS_XML_STRING, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
143 pub fn WsGetOperationContextProperty(context: *const WS_OPERATION_CONTEXT, id: WS_OPERATION_CONTEXT_PROPERTY_ID, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
144 pub fn WsGetPolicyAlternativeCount(policy: *const WS_POLICY, count: *mut u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
145 pub fn WsGetPolicyProperty(policy: *const WS_POLICY, id: WS_POLICY_PROPERTY_ID, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
146 #[cfg(feature = "Win32_Foundation")]
147 pub fn WsGetPrefixFromNamespace(writer: *const WS_XML_WRITER, ns: *const WS_XML_STRING, required: super::super::Foundation::BOOL, prefix: *mut *mut WS_XML_STRING, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
148 pub fn WsGetReaderNode(xmlreader: *const WS_XML_READER, node: *mut *mut WS_XML_NODE, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
149 pub fn WsGetReaderPosition(reader: *const WS_XML_READER, nodeposition: *mut WS_XML_NODE_POSITION, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
150 pub fn WsGetReaderProperty(reader: *const WS_XML_READER, id: WS_XML_READER_PROPERTY_ID, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
151 pub fn WsGetSecurityContextProperty(securitycontext: *const WS_SECURITY_CONTEXT, id: WS_SECURITY_CONTEXT_PROPERTY_ID, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
152 pub fn WsGetSecurityTokenProperty(securitytoken: *const WS_SECURITY_TOKEN, id: WS_SECURITY_TOKEN_PROPERTY_ID, value: *mut ::core::ffi::c_void, valuesize: u32, heap: *const WS_HEAP, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
153 pub fn WsGetServiceHostProperty(servicehost: *const WS_SERVICE_HOST, id: WS_SERVICE_PROPERTY_ID, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
154 pub fn WsGetServiceProxyProperty(serviceproxy: *const WS_SERVICE_PROXY, id: WS_PROXY_PROPERTY_ID, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
155 pub fn WsGetWriterPosition(writer: *const WS_XML_WRITER, nodeposition: *mut WS_XML_NODE_POSITION, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
156 pub fn WsGetWriterProperty(writer: *const WS_XML_WRITER, id: WS_XML_WRITER_PROPERTY_ID, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
157 #[cfg(feature = "Win32_Foundation")]
158 pub fn WsGetXmlAttribute(reader: *const WS_XML_READER, localname: *const WS_XML_STRING, heap: *const WS_HEAP, valuechars: *mut *mut u16, valuecharcount: *mut u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
159 pub fn WsInitializeMessage(message: *const WS_MESSAGE, initialization: WS_MESSAGE_INITIALIZATION, sourcemessage: *const WS_MESSAGE, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
160 pub fn WsMarkHeaderAsUnderstood(message: *const WS_MESSAGE, headerposition: *const WS_XML_NODE_POSITION, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
161 #[cfg(feature = "Win32_Foundation")]
162 pub fn WsMatchPolicyAlternative(policy: *const WS_POLICY, alternativeindex: u32, policyconstraints: *const WS_POLICY_CONSTRAINTS, matchrequired: super::super::Foundation::BOOL, heap: *const WS_HEAP, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
163 #[cfg(feature = "Win32_Foundation")]
164 pub fn WsMoveReader(reader: *const WS_XML_READER, moveto: WS_MOVE_TO, found: *mut super::super::Foundation::BOOL, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
165 #[cfg(feature = "Win32_Foundation")]
166 pub fn WsMoveWriter(writer: *const WS_XML_WRITER, moveto: WS_MOVE_TO, found: *mut super::super::Foundation::BOOL, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
167 #[cfg(feature = "Win32_Foundation")]
168 pub fn WsOpenChannel(channel: *const WS_CHANNEL, endpointaddress: *const WS_ENDPOINT_ADDRESS, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
169 #[cfg(feature = "Win32_Foundation")]
170 pub fn WsOpenListener(listener: *const WS_LISTENER, url: *const WS_STRING, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
171 pub fn WsOpenServiceHost(servicehost: *const WS_SERVICE_HOST, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
172 #[cfg(feature = "Win32_Foundation")]
173 pub fn WsOpenServiceProxy(serviceproxy: *const WS_SERVICE_PROXY, address: *const WS_ENDPOINT_ADDRESS, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
174 pub fn WsPullBytes(writer: *const WS_XML_WRITER, callback: ::core::option::Option<WS_PULL_BYTES_CALLBACK>, callbackstate: *const ::core::ffi::c_void, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
175 pub fn WsPushBytes(writer: *const WS_XML_WRITER, callback: ::core::option::Option<WS_PUSH_BYTES_CALLBACK>, callbackstate: *const ::core::ffi::c_void, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
176 #[cfg(feature = "Win32_Foundation")]
177 pub fn WsReadArray(reader: *const WS_XML_READER, localname: *const WS_XML_STRING, ns: *const WS_XML_STRING, valuetype: WS_VALUE_TYPE, array: *mut ::core::ffi::c_void, arraysize: u32, itemoffset: u32, itemcount: u32, actualitemcount: *mut u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
178 #[cfg(feature = "Win32_Foundation")]
179 pub fn WsReadAttribute(reader: *const WS_XML_READER, attributedescription: *const WS_ATTRIBUTE_DESCRIPTION, readoption: WS_READ_OPTION, heap: *const WS_HEAP, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
180 #[cfg(feature = "Win32_Foundation")]
181 pub fn WsReadBody(message: *const WS_MESSAGE, bodydescription: *const WS_ELEMENT_DESCRIPTION, readoption: WS_READ_OPTION, heap: *const WS_HEAP, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
182 pub fn WsReadBytes(reader: *const WS_XML_READER, bytes: *mut ::core::ffi::c_void, maxbytecount: u32, actualbytecount: *mut u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
183 #[cfg(feature = "Win32_Foundation")]
184 pub fn WsReadChars(reader: *const WS_XML_READER, chars: super::super::Foundation::PWSTR, maxcharcount: u32, actualcharcount: *mut u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
185 pub fn WsReadCharsUtf8(reader: *const WS_XML_READER, bytes: *mut u8, maxbytecount: u32, actualbytecount: *mut u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
186 #[cfg(feature = "Win32_Foundation")]
187 pub fn WsReadElement(reader: *const WS_XML_READER, elementdescription: *const WS_ELEMENT_DESCRIPTION, readoption: WS_READ_OPTION, heap: *const WS_HEAP, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
188 pub fn WsReadEndAttribute(reader: *const WS_XML_READER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
189 pub fn WsReadEndElement(reader: *const WS_XML_READER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
190 #[cfg(feature = "Win32_Foundation")]
191 pub fn WsReadEndpointAddressExtension(reader: *const WS_XML_READER, endpointaddress: *const WS_ENDPOINT_ADDRESS, extensiontype: WS_ENDPOINT_ADDRESS_EXTENSION_TYPE, readoption: WS_READ_OPTION, heap: *const WS_HEAP, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
192 pub fn WsReadEnvelopeEnd(message: *const WS_MESSAGE, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
193 pub fn WsReadEnvelopeStart(message: *const WS_MESSAGE, reader: *const WS_XML_READER, donecallback: ::core::option::Option<WS_MESSAGE_DONE_CALLBACK>, donecallbackstate: *const ::core::ffi::c_void, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
194 pub fn WsReadMessageEnd(channel: *const WS_CHANNEL, message: *const WS_MESSAGE, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
195 pub fn WsReadMessageStart(channel: *const WS_CHANNEL, message: *const WS_MESSAGE, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
196 #[cfg(feature = "Win32_Foundation")]
197 pub fn WsReadMetadata(metadata: *const WS_METADATA, reader: *const WS_XML_READER, url: *const WS_STRING, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
198 pub fn WsReadNode(reader: *const WS_XML_READER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
199 #[cfg(feature = "Win32_Foundation")]
200 pub fn WsReadQualifiedName(reader: *const WS_XML_READER, heap: *const WS_HEAP, prefix: *mut WS_XML_STRING, localname: *mut WS_XML_STRING, ns: *mut WS_XML_STRING, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
201 pub fn WsReadStartAttribute(reader: *const WS_XML_READER, attributeindex: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
202 pub fn WsReadStartElement(reader: *const WS_XML_READER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
203 #[cfg(feature = "Win32_Foundation")]
204 pub fn WsReadToStartElement(reader: *const WS_XML_READER, localname: *const WS_XML_STRING, ns: *const WS_XML_STRING, found: *mut super::super::Foundation::BOOL, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
205 pub fn WsReadType(reader: *const WS_XML_READER, typemapping: WS_TYPE_MAPPING, r#type: WS_TYPE, typedescription: *const ::core::ffi::c_void, readoption: WS_READ_OPTION, heap: *const WS_HEAP, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
206 pub fn WsReadValue(reader: *const WS_XML_READER, valuetype: WS_VALUE_TYPE, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
207 pub fn WsReadXmlBuffer(reader: *const WS_XML_READER, heap: *const WS_HEAP, xmlbuffer: *mut *mut WS_XML_BUFFER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
208 pub fn WsReadXmlBufferFromBytes(reader: *const WS_XML_READER, encoding: *const WS_XML_READER_ENCODING, properties: *const WS_XML_READER_PROPERTY, propertycount: u32, bytes: *const ::core::ffi::c_void, bytecount: u32, heap: *const WS_HEAP, xmlbuffer: *mut *mut WS_XML_BUFFER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
209 #[cfg(feature = "Win32_Foundation")]
210 pub fn WsReceiveMessage(channel: *const WS_CHANNEL, message: *const WS_MESSAGE, messagedescriptions: *const *const WS_MESSAGE_DESCRIPTION, messagedescriptioncount: u32, receiveoption: WS_RECEIVE_OPTION, readbodyoption: WS_READ_OPTION, heap: *const WS_HEAP, value: *mut ::core::ffi::c_void, valuesize: u32, index: *mut u32, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
211 pub fn WsRegisterOperationForCancel(context: *const WS_OPERATION_CONTEXT, cancelcallback: ::core::option::Option<WS_OPERATION_CANCEL_CALLBACK>, freestatecallback: ::core::option::Option<WS_OPERATION_FREE_STATE_CALLBACK>, userstate: *const ::core::ffi::c_void, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
212 #[cfg(feature = "Win32_Foundation")]
213 pub fn WsRemoveCustomHeader(message: *const WS_MESSAGE, headername: *const WS_XML_STRING, headerns: *const WS_XML_STRING, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
214 pub fn WsRemoveHeader(message: *const WS_MESSAGE, headertype: WS_HEADER_TYPE, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
215 #[cfg(feature = "Win32_Foundation")]
216 pub fn WsRemoveMappedHeader(message: *const WS_MESSAGE, headername: *const WS_XML_STRING, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
217 pub fn WsRemoveNode(nodeposition: *const WS_XML_NODE_POSITION, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
218 #[cfg(feature = "Win32_Foundation")]
219 pub fn WsRequestReply(
220 channel: *const WS_CHANNEL,
221 requestmessage: *const WS_MESSAGE,
222 requestmessagedescription: *const WS_MESSAGE_DESCRIPTION,
223 writeoption: WS_WRITE_OPTION,
224 requestbodyvalue: *const ::core::ffi::c_void,
225 requestbodyvaluesize: u32,
226 replymessage: *const WS_MESSAGE,
227 replymessagedescription: *const WS_MESSAGE_DESCRIPTION,
228 readoption: WS_READ_OPTION,
229 heap: *const WS_HEAP,
230 value: *mut ::core::ffi::c_void,
231 valuesize: u32,
232 asynccontext: *const WS_ASYNC_CONTEXT,
233 error: *const WS_ERROR,
234 ) -> ::windows_sys::core::HRESULT;
235 pub fn WsRequestSecurityToken(channel: *const WS_CHANNEL, properties: *const WS_REQUEST_SECURITY_TOKEN_PROPERTY, propertycount: u32, token: *mut *mut WS_SECURITY_TOKEN, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
236 pub fn WsResetChannel(channel: *const WS_CHANNEL, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
237 pub fn WsResetError(error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
238 pub fn WsResetHeap(heap: *const WS_HEAP, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
239 pub fn WsResetListener(listener: *const WS_LISTENER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
240 pub fn WsResetMessage(message: *const WS_MESSAGE, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
241 pub fn WsResetMetadata(metadata: *const WS_METADATA, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
242 pub fn WsResetServiceHost(servicehost: *const WS_SERVICE_HOST, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
243 pub fn WsResetServiceProxy(serviceproxy: *const WS_SERVICE_PROXY, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
244 pub fn WsRevokeSecurityContext(securitycontext: *const WS_SECURITY_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
245 pub fn WsSendFaultMessageForError(channel: *const WS_CHANNEL, replymessage: *const WS_MESSAGE, faulterror: *const WS_ERROR, faulterrorcode: ::windows_sys::core::HRESULT, faultdisclosure: WS_FAULT_DISCLOSURE, requestmessage: *const WS_MESSAGE, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
246 #[cfg(feature = "Win32_Foundation")]
247 pub fn WsSendMessage(channel: *const WS_CHANNEL, message: *const WS_MESSAGE, messagedescription: *const WS_MESSAGE_DESCRIPTION, writeoption: WS_WRITE_OPTION, bodyvalue: *const ::core::ffi::c_void, bodyvaluesize: u32, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
248 #[cfg(feature = "Win32_Foundation")]
249 pub fn WsSendReplyMessage(channel: *const WS_CHANNEL, replymessage: *const WS_MESSAGE, replymessagedescription: *const WS_MESSAGE_DESCRIPTION, writeoption: WS_WRITE_OPTION, replybodyvalue: *const ::core::ffi::c_void, replybodyvaluesize: u32, requestmessage: *const WS_MESSAGE, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
250 pub fn WsSetChannelProperty(channel: *const WS_CHANNEL, id: WS_CHANNEL_PROPERTY_ID, value: *const ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
251 pub fn WsSetErrorProperty(error: *const WS_ERROR, id: WS_ERROR_PROPERTY_ID, value: *const ::core::ffi::c_void, valuesize: u32) -> ::windows_sys::core::HRESULT;
252 #[cfg(feature = "Win32_Foundation")]
253 pub fn WsSetFaultErrorDetail(error: *const WS_ERROR, faultdetaildescription: *const WS_FAULT_DETAIL_DESCRIPTION, writeoption: WS_WRITE_OPTION, value: *const ::core::ffi::c_void, valuesize: u32) -> ::windows_sys::core::HRESULT;
254 pub fn WsSetFaultErrorProperty(error: *const WS_ERROR, id: WS_FAULT_ERROR_PROPERTY_ID, value: *const ::core::ffi::c_void, valuesize: u32) -> ::windows_sys::core::HRESULT;
255 pub fn WsSetHeader(message: *const WS_MESSAGE, headertype: WS_HEADER_TYPE, valuetype: WS_TYPE, writeoption: WS_WRITE_OPTION, value: *const ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
256 pub fn WsSetInput(reader: *const WS_XML_READER, encoding: *const WS_XML_READER_ENCODING, input: *const WS_XML_READER_INPUT, properties: *const WS_XML_READER_PROPERTY, propertycount: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
257 pub fn WsSetInputToBuffer(reader: *const WS_XML_READER, buffer: *const WS_XML_BUFFER, properties: *const WS_XML_READER_PROPERTY, propertycount: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
258 pub fn WsSetListenerProperty(listener: *const WS_LISTENER, id: WS_LISTENER_PROPERTY_ID, value: *const ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
259 pub fn WsSetMessageProperty(message: *const WS_MESSAGE, id: WS_MESSAGE_PROPERTY_ID, value: *const ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
260 pub fn WsSetOutput(writer: *const WS_XML_WRITER, encoding: *const WS_XML_WRITER_ENCODING, output: *const WS_XML_WRITER_OUTPUT, properties: *const WS_XML_WRITER_PROPERTY, propertycount: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
261 pub fn WsSetOutputToBuffer(writer: *const WS_XML_WRITER, buffer: *const WS_XML_BUFFER, properties: *const WS_XML_WRITER_PROPERTY, propertycount: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
262 pub fn WsSetReaderPosition(reader: *const WS_XML_READER, nodeposition: *const WS_XML_NODE_POSITION, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
263 pub fn WsSetWriterPosition(writer: *const WS_XML_WRITER, nodeposition: *const WS_XML_NODE_POSITION, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
264 pub fn WsShutdownSessionChannel(channel: *const WS_CHANNEL, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
265 pub fn WsSkipNode(reader: *const WS_XML_READER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
266 pub fn WsStartReaderCanonicalization(reader: *const WS_XML_READER, writecallback: ::core::option::Option<WS_WRITE_CALLBACK>, writecallbackstate: *const ::core::ffi::c_void, properties: *const WS_XML_CANONICALIZATION_PROPERTY, propertycount: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
267 pub fn WsStartWriterCanonicalization(writer: *const WS_XML_WRITER, writecallback: ::core::option::Option<WS_WRITE_CALLBACK>, writecallbackstate: *const ::core::ffi::c_void, properties: *const WS_XML_CANONICALIZATION_PROPERTY, propertycount: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
268 #[cfg(feature = "Win32_Foundation")]
269 pub fn WsTrimXmlWhitespace(chars: super::super::Foundation::PWSTR, charcount: u32, trimmedchars: *mut *mut u16, trimmedcount: *mut u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
270 #[cfg(feature = "Win32_Foundation")]
271 pub fn WsVerifyXmlNCName(ncnamechars: super::super::Foundation::PWSTR, ncnamecharcount: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
272 #[cfg(feature = "Win32_Foundation")]
273 pub fn WsWriteArray(writer: *const WS_XML_WRITER, localname: *const WS_XML_STRING, ns: *const WS_XML_STRING, valuetype: WS_VALUE_TYPE, array: *const ::core::ffi::c_void, arraysize: u32, itemoffset: u32, itemcount: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
274 #[cfg(feature = "Win32_Foundation")]
275 pub fn WsWriteAttribute(writer: *const WS_XML_WRITER, attributedescription: *const WS_ATTRIBUTE_DESCRIPTION, writeoption: WS_WRITE_OPTION, value: *const ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
276 #[cfg(feature = "Win32_Foundation")]
277 pub fn WsWriteBody(message: *const WS_MESSAGE, bodydescription: *const WS_ELEMENT_DESCRIPTION, writeoption: WS_WRITE_OPTION, value: *const ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
278 pub fn WsWriteBytes(writer: *const WS_XML_WRITER, bytes: *const ::core::ffi::c_void, bytecount: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
279 #[cfg(feature = "Win32_Foundation")]
280 pub fn WsWriteChars(writer: *const WS_XML_WRITER, chars: super::super::Foundation::PWSTR, charcount: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
281 pub fn WsWriteCharsUtf8(writer: *const WS_XML_WRITER, bytes: *const u8, bytecount: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
282 #[cfg(feature = "Win32_Foundation")]
283 pub fn WsWriteElement(writer: *const WS_XML_WRITER, elementdescription: *const WS_ELEMENT_DESCRIPTION, writeoption: WS_WRITE_OPTION, value: *const ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
284 pub fn WsWriteEndAttribute(writer: *const WS_XML_WRITER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
285 pub fn WsWriteEndCData(writer: *const WS_XML_WRITER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
286 pub fn WsWriteEndElement(writer: *const WS_XML_WRITER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
287 pub fn WsWriteEndStartElement(writer: *const WS_XML_WRITER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
288 pub fn WsWriteEnvelopeEnd(message: *const WS_MESSAGE, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
289 pub fn WsWriteEnvelopeStart(message: *const WS_MESSAGE, writer: *const WS_XML_WRITER, donecallback: ::core::option::Option<WS_MESSAGE_DONE_CALLBACK>, donecallbackstate: *const ::core::ffi::c_void, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
290 pub fn WsWriteMessageEnd(channel: *const WS_CHANNEL, message: *const WS_MESSAGE, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
291 pub fn WsWriteMessageStart(channel: *const WS_CHANNEL, message: *const WS_MESSAGE, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
292 pub fn WsWriteNode(writer: *const WS_XML_WRITER, node: *const WS_XML_NODE, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
293 #[cfg(feature = "Win32_Foundation")]
294 pub fn WsWriteQualifiedName(writer: *const WS_XML_WRITER, prefix: *const WS_XML_STRING, localname: *const WS_XML_STRING, ns: *const WS_XML_STRING, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
295 #[cfg(feature = "Win32_Foundation")]
296 pub fn WsWriteStartAttribute(writer: *const WS_XML_WRITER, prefix: *const WS_XML_STRING, localname: *const WS_XML_STRING, ns: *const WS_XML_STRING, singlequote: super::super::Foundation::BOOL, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
297 pub fn WsWriteStartCData(writer: *const WS_XML_WRITER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
298 #[cfg(feature = "Win32_Foundation")]
299 pub fn WsWriteStartElement(writer: *const WS_XML_WRITER, prefix: *const WS_XML_STRING, localname: *const WS_XML_STRING, ns: *const WS_XML_STRING, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
300 pub fn WsWriteText(writer: *const WS_XML_WRITER, text: *const WS_XML_TEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
301 pub fn WsWriteType(writer: *const WS_XML_WRITER, typemapping: WS_TYPE_MAPPING, r#type: WS_TYPE, typedescription: *const ::core::ffi::c_void, writeoption: WS_WRITE_OPTION, value: *const ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
302 pub fn WsWriteValue(writer: *const WS_XML_WRITER, valuetype: WS_VALUE_TYPE, value: *const ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
303 pub fn WsWriteXmlBuffer(writer: *const WS_XML_WRITER, xmlbuffer: *const WS_XML_BUFFER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
304 pub fn WsWriteXmlBufferToBytes(writer: *const WS_XML_WRITER, xmlbuffer: *const WS_XML_BUFFER, encoding: *const WS_XML_WRITER_ENCODING, properties: *const WS_XML_WRITER_PROPERTY, propertycount: u32, heap: *const WS_HEAP, bytes: *mut *mut ::core::ffi::c_void, bytecount: *mut u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
305 #[cfg(feature = "Win32_Foundation")]
306 pub fn WsWriteXmlnsAttribute(writer: *const WS_XML_WRITER, prefix: *const WS_XML_STRING, ns: *const WS_XML_STRING, singlequote: super::super::Foundation::BOOL, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
307 #[cfg(feature = "Win32_Foundation")]
308 pub fn WsXmlStringEquals(string1: *const WS_XML_STRING, string2: *const WS_XML_STRING, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
309}
310pub type IContentPrefetcherTaskTrigger = *mut ::core::ffi::c_void;
311pub const WEBAUTHN_API_CURRENT_VERSION: u32 = 3u32;
312pub const WEBAUTHN_API_VERSION_1: u32 = 1u32;
313pub const WEBAUTHN_API_VERSION_2: u32 = 2u32;
314pub const WEBAUTHN_API_VERSION_3: u32 = 3u32;
315#[repr(C)]
316#[cfg(feature = "Win32_Foundation")]
317pub struct WEBAUTHN_ASSERTION {
318 pub dwVersion: u32,
319 pub cbAuthenticatorData: u32,
320 pub pbAuthenticatorData: *mut u8,
321 pub cbSignature: u32,
322 pub pbSignature: *mut u8,
323 pub Credential: WEBAUTHN_CREDENTIAL,
324 pub cbUserId: u32,
325 pub pbUserId: *mut u8,
326 pub Extensions: WEBAUTHN_EXTENSIONS,
327 pub cbCredLargeBlob: u32,
328 pub pbCredLargeBlob: *mut u8,
329 pub dwCredLargeBlobStatus: u32,
330}
331#[cfg(feature = "Win32_Foundation")]
332impl ::core::marker::Copy for WEBAUTHN_ASSERTION {}
333#[cfg(feature = "Win32_Foundation")]
334impl ::core::clone::Clone for WEBAUTHN_ASSERTION {
335 fn clone(&self) -> Self {
336 *self
337 }
338}
339pub const WEBAUTHN_ASSERTION_CURRENT_VERSION: u32 = 2u32;
340pub const WEBAUTHN_ASSERTION_VERSION_1: u32 = 1u32;
341pub const WEBAUTHN_ASSERTION_VERSION_2: u32 = 2u32;
342pub const WEBAUTHN_ATTESTATION_CONVEYANCE_PREFERENCE_ANY: u32 = 0u32;
343pub const WEBAUTHN_ATTESTATION_CONVEYANCE_PREFERENCE_DIRECT: u32 = 3u32;
344pub const WEBAUTHN_ATTESTATION_CONVEYANCE_PREFERENCE_INDIRECT: u32 = 2u32;
345pub const WEBAUTHN_ATTESTATION_CONVEYANCE_PREFERENCE_NONE: u32 = 1u32;
346pub const WEBAUTHN_ATTESTATION_DECODE_COMMON: u32 = 1u32;
347pub const WEBAUTHN_ATTESTATION_DECODE_NONE: u32 = 0u32;
348pub const WEBAUTHN_AUTHENTICATOR_ATTACHMENT_ANY: u32 = 0u32;
349pub const WEBAUTHN_AUTHENTICATOR_ATTACHMENT_CROSS_PLATFORM: u32 = 2u32;
350pub const WEBAUTHN_AUTHENTICATOR_ATTACHMENT_CROSS_PLATFORM_U2F_V2: u32 = 3u32;
351pub const WEBAUTHN_AUTHENTICATOR_ATTACHMENT_PLATFORM: u32 = 1u32;
352#[repr(C)]
353#[cfg(feature = "Win32_Foundation")]
354pub struct WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS {
355 pub dwVersion: u32,
356 pub dwTimeoutMilliseconds: u32,
357 pub CredentialList: WEBAUTHN_CREDENTIALS,
358 pub Extensions: WEBAUTHN_EXTENSIONS,
359 pub dwAuthenticatorAttachment: u32,
360 pub dwUserVerificationRequirement: u32,
361 pub dwFlags: u32,
362 pub pwszU2fAppId: super::super::Foundation::PWSTR,
363 pub pbU2fAppId: *mut super::super::Foundation::BOOL,
364 pub pCancellationId: *mut ::windows_sys::core::GUID,
365 pub pAllowCredentialList: *mut WEBAUTHN_CREDENTIAL_LIST,
366 pub dwCredLargeBlobOperation: u32,
367 pub cbCredLargeBlob: u32,
368 pub pbCredLargeBlob: *mut u8,
369}
370#[cfg(feature = "Win32_Foundation")]
371impl ::core::marker::Copy for WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS {}
372#[cfg(feature = "Win32_Foundation")]
373impl ::core::clone::Clone for WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS {
374 fn clone(&self) -> Self {
375 *self
376 }
377}
378pub const WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS_CURRENT_VERSION: u32 = 5u32;
379pub const WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS_VERSION_1: u32 = 1u32;
380pub const WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS_VERSION_2: u32 = 2u32;
381pub const WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS_VERSION_3: u32 = 3u32;
382pub const WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS_VERSION_4: u32 = 4u32;
383pub const WEBAUTHN_AUTHENTICATOR_GET_ASSERTION_OPTIONS_VERSION_5: u32 = 5u32;
384#[repr(C)]
385#[cfg(feature = "Win32_Foundation")]
386pub struct WEBAUTHN_AUTHENTICATOR_MAKE_CREDENTIAL_OPTIONS {
387 pub dwVersion: u32,
388 pub dwTimeoutMilliseconds: u32,
389 pub CredentialList: WEBAUTHN_CREDENTIALS,
390 pub Extensions: WEBAUTHN_EXTENSIONS,
391 pub dwAuthenticatorAttachment: u32,
392 pub bRequireResidentKey: super::super::Foundation::BOOL,
393 pub dwUserVerificationRequirement: u32,
394 pub dwAttestationConveyancePreference: u32,
395 pub dwFlags: u32,
396 pub pCancellationId: *mut ::windows_sys::core::GUID,
397 pub pExcludeCredentialList: *mut WEBAUTHN_CREDENTIAL_LIST,
398 pub dwEnterpriseAttestation: u32,
399 pub dwLargeBlobSupport: u32,
400 pub bPreferResidentKey: super::super::Foundation::BOOL,
401}
402#[cfg(feature = "Win32_Foundation")]
403impl ::core::marker::Copy for WEBAUTHN_AUTHENTICATOR_MAKE_CREDENTIAL_OPTIONS {}
404#[cfg(feature = "Win32_Foundation")]
405impl ::core::clone::Clone for WEBAUTHN_AUTHENTICATOR_MAKE_CREDENTIAL_OPTIONS {
406 fn clone(&self) -> Self {
407 *self
408 }
409}
410pub const WEBAUTHN_AUTHENTICATOR_MAKE_CREDENTIAL_OPTIONS_CURRENT_VERSION: u32 = 4u32;
411pub const WEBAUTHN_AUTHENTICATOR_MAKE_CREDENTIAL_OPTIONS_VERSION_1: u32 = 1u32;
412pub const WEBAUTHN_AUTHENTICATOR_MAKE_CREDENTIAL_OPTIONS_VERSION_2: u32 = 2u32;
413pub const WEBAUTHN_AUTHENTICATOR_MAKE_CREDENTIAL_OPTIONS_VERSION_3: u32 = 3u32;
414pub const WEBAUTHN_AUTHENTICATOR_MAKE_CREDENTIAL_OPTIONS_VERSION_4: u32 = 4u32;
415#[repr(C)]
416#[cfg(feature = "Win32_Foundation")]
417pub struct WEBAUTHN_CLIENT_DATA {
418 pub dwVersion: u32,
419 pub cbClientDataJSON: u32,
420 pub pbClientDataJSON: *mut u8,
421 pub pwszHashAlgId: super::super::Foundation::PWSTR,
422}
423#[cfg(feature = "Win32_Foundation")]
424impl ::core::marker::Copy for WEBAUTHN_CLIENT_DATA {}
425#[cfg(feature = "Win32_Foundation")]
426impl ::core::clone::Clone for WEBAUTHN_CLIENT_DATA {
427 fn clone(&self) -> Self {
428 *self
429 }
430}
431pub const WEBAUTHN_CLIENT_DATA_CURRENT_VERSION: u32 = 1u32;
432#[repr(C)]
433#[cfg(feature = "Win32_Foundation")]
434pub struct WEBAUTHN_COMMON_ATTESTATION {
435 pub dwVersion: u32,
436 pub pwszAlg: super::super::Foundation::PWSTR,
437 pub lAlg: i32,
438 pub cbSignature: u32,
439 pub pbSignature: *mut u8,
440 pub cX5c: u32,
441 pub pX5c: *mut WEBAUTHN_X5C,
442 pub pwszVer: super::super::Foundation::PWSTR,
443 pub cbCertInfo: u32,
444 pub pbCertInfo: *mut u8,
445 pub cbPubArea: u32,
446 pub pbPubArea: *mut u8,
447}
448#[cfg(feature = "Win32_Foundation")]
449impl ::core::marker::Copy for WEBAUTHN_COMMON_ATTESTATION {}
450#[cfg(feature = "Win32_Foundation")]
451impl ::core::clone::Clone for WEBAUTHN_COMMON_ATTESTATION {
452 fn clone(&self) -> Self {
453 *self
454 }
455}
456pub const WEBAUTHN_COMMON_ATTESTATION_CURRENT_VERSION: u32 = 1u32;
457pub const WEBAUTHN_COSE_ALGORITHM_ECDSA_P256_WITH_SHA256: i32 = -7i32;
458pub const WEBAUTHN_COSE_ALGORITHM_ECDSA_P384_WITH_SHA384: i32 = -35i32;
459pub const WEBAUTHN_COSE_ALGORITHM_ECDSA_P521_WITH_SHA512: i32 = -36i32;
460pub const WEBAUTHN_COSE_ALGORITHM_RSASSA_PKCS1_V1_5_WITH_SHA256: i32 = -257i32;
461pub const WEBAUTHN_COSE_ALGORITHM_RSASSA_PKCS1_V1_5_WITH_SHA384: i32 = -258i32;
462pub const WEBAUTHN_COSE_ALGORITHM_RSASSA_PKCS1_V1_5_WITH_SHA512: i32 = -259i32;
463pub const WEBAUTHN_COSE_ALGORITHM_RSA_PSS_WITH_SHA256: i32 = -37i32;
464pub const WEBAUTHN_COSE_ALGORITHM_RSA_PSS_WITH_SHA384: i32 = -38i32;
465pub const WEBAUTHN_COSE_ALGORITHM_RSA_PSS_WITH_SHA512: i32 = -39i32;
466#[repr(C)]
467#[cfg(feature = "Win32_Foundation")]
468pub struct WEBAUTHN_COSE_CREDENTIAL_PARAMETER {
469 pub dwVersion: u32,
470 pub pwszCredentialType: super::super::Foundation::PWSTR,
471 pub lAlg: i32,
472}
473#[cfg(feature = "Win32_Foundation")]
474impl ::core::marker::Copy for WEBAUTHN_COSE_CREDENTIAL_PARAMETER {}
475#[cfg(feature = "Win32_Foundation")]
476impl ::core::clone::Clone for WEBAUTHN_COSE_CREDENTIAL_PARAMETER {
477 fn clone(&self) -> Self {
478 *self
479 }
480}
481#[repr(C)]
482#[cfg(feature = "Win32_Foundation")]
483pub struct WEBAUTHN_COSE_CREDENTIAL_PARAMETERS {
484 pub cCredentialParameters: u32,
485 pub pCredentialParameters: *mut WEBAUTHN_COSE_CREDENTIAL_PARAMETER,
486}
487#[cfg(feature = "Win32_Foundation")]
488impl ::core::marker::Copy for WEBAUTHN_COSE_CREDENTIAL_PARAMETERS {}
489#[cfg(feature = "Win32_Foundation")]
490impl ::core::clone::Clone for WEBAUTHN_COSE_CREDENTIAL_PARAMETERS {
491 fn clone(&self) -> Self {
492 *self
493 }
494}
495pub const WEBAUTHN_COSE_CREDENTIAL_PARAMETER_CURRENT_VERSION: u32 = 1u32;
496#[repr(C)]
497#[cfg(feature = "Win32_Foundation")]
498pub struct WEBAUTHN_CREDENTIAL {
499 pub dwVersion: u32,
500 pub cbId: u32,
501 pub pbId: *mut u8,
502 pub pwszCredentialType: super::super::Foundation::PWSTR,
503}
504#[cfg(feature = "Win32_Foundation")]
505impl ::core::marker::Copy for WEBAUTHN_CREDENTIAL {}
506#[cfg(feature = "Win32_Foundation")]
507impl ::core::clone::Clone for WEBAUTHN_CREDENTIAL {
508 fn clone(&self) -> Self {
509 *self
510 }
511}
512#[repr(C)]
513#[cfg(feature = "Win32_Foundation")]
514pub struct WEBAUTHN_CREDENTIALS {
515 pub cCredentials: u32,
516 pub pCredentials: *mut WEBAUTHN_CREDENTIAL,
517}
518#[cfg(feature = "Win32_Foundation")]
519impl ::core::marker::Copy for WEBAUTHN_CREDENTIALS {}
520#[cfg(feature = "Win32_Foundation")]
521impl ::core::clone::Clone for WEBAUTHN_CREDENTIALS {
522 fn clone(&self) -> Self {
523 *self
524 }
525}
526#[repr(C)]
527#[cfg(feature = "Win32_Foundation")]
528pub struct WEBAUTHN_CREDENTIAL_ATTESTATION {
529 pub dwVersion: u32,
530 pub pwszFormatType: super::super::Foundation::PWSTR,
531 pub cbAuthenticatorData: u32,
532 pub pbAuthenticatorData: *mut u8,
533 pub cbAttestation: u32,
534 pub pbAttestation: *mut u8,
535 pub dwAttestationDecodeType: u32,
536 pub pvAttestationDecode: *mut ::core::ffi::c_void,
537 pub cbAttestationObject: u32,
538 pub pbAttestationObject: *mut u8,
539 pub cbCredentialId: u32,
540 pub pbCredentialId: *mut u8,
541 pub Extensions: WEBAUTHN_EXTENSIONS,
542 pub dwUsedTransport: u32,
543 pub bEpAtt: super::super::Foundation::BOOL,
544 pub bLargeBlobSupported: super::super::Foundation::BOOL,
545 pub bResidentKey: super::super::Foundation::BOOL,
546}
547#[cfg(feature = "Win32_Foundation")]
548impl ::core::marker::Copy for WEBAUTHN_CREDENTIAL_ATTESTATION {}
549#[cfg(feature = "Win32_Foundation")]
550impl ::core::clone::Clone for WEBAUTHN_CREDENTIAL_ATTESTATION {
551 fn clone(&self) -> Self {
552 *self
553 }
554}
555pub const WEBAUTHN_CREDENTIAL_ATTESTATION_CURRENT_VERSION: u32 = 4u32;
556pub const WEBAUTHN_CREDENTIAL_ATTESTATION_VERSION_1: u32 = 1u32;
557pub const WEBAUTHN_CREDENTIAL_ATTESTATION_VERSION_2: u32 = 2u32;
558pub const WEBAUTHN_CREDENTIAL_ATTESTATION_VERSION_3: u32 = 3u32;
559pub const WEBAUTHN_CREDENTIAL_ATTESTATION_VERSION_4: u32 = 4u32;
560pub const WEBAUTHN_CREDENTIAL_CURRENT_VERSION: u32 = 1u32;
561#[repr(C)]
562#[cfg(feature = "Win32_Foundation")]
563pub struct WEBAUTHN_CREDENTIAL_EX {
564 pub dwVersion: u32,
565 pub cbId: u32,
566 pub pbId: *mut u8,
567 pub pwszCredentialType: super::super::Foundation::PWSTR,
568 pub dwTransports: u32,
569}
570#[cfg(feature = "Win32_Foundation")]
571impl ::core::marker::Copy for WEBAUTHN_CREDENTIAL_EX {}
572#[cfg(feature = "Win32_Foundation")]
573impl ::core::clone::Clone for WEBAUTHN_CREDENTIAL_EX {
574 fn clone(&self) -> Self {
575 *self
576 }
577}
578pub const WEBAUTHN_CREDENTIAL_EX_CURRENT_VERSION: u32 = 1u32;
579#[repr(C)]
580#[cfg(feature = "Win32_Foundation")]
581pub struct WEBAUTHN_CREDENTIAL_LIST {
582 pub cCredentials: u32,
583 pub ppCredentials: *mut *mut WEBAUTHN_CREDENTIAL_EX,
584}
585#[cfg(feature = "Win32_Foundation")]
586impl ::core::marker::Copy for WEBAUTHN_CREDENTIAL_LIST {}
587#[cfg(feature = "Win32_Foundation")]
588impl ::core::clone::Clone for WEBAUTHN_CREDENTIAL_LIST {
589 fn clone(&self) -> Self {
590 *self
591 }
592}
593#[repr(C)]
594pub struct WEBAUTHN_CRED_BLOB_EXTENSION {
595 pub cbCredBlob: u32,
596 pub pbCredBlob: *mut u8,
597}
598impl ::core::marker::Copy for WEBAUTHN_CRED_BLOB_EXTENSION {}
599impl ::core::clone::Clone for WEBAUTHN_CRED_BLOB_EXTENSION {
600 fn clone(&self) -> Self {
601 *self
602 }
603}
604pub const WEBAUTHN_CRED_LARGE_BLOB_OPERATION_DELETE: u32 = 3u32;
605pub const WEBAUTHN_CRED_LARGE_BLOB_OPERATION_GET: u32 = 1u32;
606pub const WEBAUTHN_CRED_LARGE_BLOB_OPERATION_NONE: u32 = 0u32;
607pub const WEBAUTHN_CRED_LARGE_BLOB_OPERATION_SET: u32 = 2u32;
608pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_AUTHENTICATOR_ERROR: u32 = 9u32;
609pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_INVALID_DATA: u32 = 3u32;
610pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_INVALID_PARAMETER: u32 = 4u32;
611pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_LACK_OF_SPACE: u32 = 7u32;
612pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_MULTIPLE_CREDENTIALS: u32 = 6u32;
613pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_NONE: u32 = 0u32;
614pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_NOT_FOUND: u32 = 5u32;
615pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_NOT_SUPPORTED: u32 = 2u32;
616pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_PLATFORM_ERROR: u32 = 8u32;
617pub const WEBAUTHN_CRED_LARGE_BLOB_STATUS_SUCCESS: u32 = 1u32;
618#[repr(C)]
619#[cfg(feature = "Win32_Foundation")]
620pub struct WEBAUTHN_CRED_PROTECT_EXTENSION_IN {
621 pub dwCredProtect: u32,
622 pub bRequireCredProtect: super::super::Foundation::BOOL,
623}
624#[cfg(feature = "Win32_Foundation")]
625impl ::core::marker::Copy for WEBAUTHN_CRED_PROTECT_EXTENSION_IN {}
626#[cfg(feature = "Win32_Foundation")]
627impl ::core::clone::Clone for WEBAUTHN_CRED_PROTECT_EXTENSION_IN {
628 fn clone(&self) -> Self {
629 *self
630 }
631}
632pub const WEBAUTHN_CTAP_TRANSPORT_BLE: u32 = 4u32;
633pub const WEBAUTHN_CTAP_TRANSPORT_FLAGS_MASK: u32 = 31u32;
634pub const WEBAUTHN_CTAP_TRANSPORT_INTERNAL: u32 = 16u32;
635pub const WEBAUTHN_CTAP_TRANSPORT_NFC: u32 = 2u32;
636pub const WEBAUTHN_CTAP_TRANSPORT_TEST: u32 = 8u32;
637pub const WEBAUTHN_CTAP_TRANSPORT_USB: u32 = 1u32;
638pub const WEBAUTHN_ENTERPRISE_ATTESTATION_NONE: u32 = 0u32;
639pub const WEBAUTHN_ENTERPRISE_ATTESTATION_PLATFORM_MANAGED: u32 = 2u32;
640pub const WEBAUTHN_ENTERPRISE_ATTESTATION_VENDOR_FACILITATED: u32 = 1u32;
641#[repr(C)]
642#[cfg(feature = "Win32_Foundation")]
643pub struct WEBAUTHN_EXTENSION {
644 pub pwszExtensionIdentifier: super::super::Foundation::PWSTR,
645 pub cbExtension: u32,
646 pub pvExtension: *mut ::core::ffi::c_void,
647}
648#[cfg(feature = "Win32_Foundation")]
649impl ::core::marker::Copy for WEBAUTHN_EXTENSION {}
650#[cfg(feature = "Win32_Foundation")]
651impl ::core::clone::Clone for WEBAUTHN_EXTENSION {
652 fn clone(&self) -> Self {
653 *self
654 }
655}
656#[repr(C)]
657#[cfg(feature = "Win32_Foundation")]
658pub struct WEBAUTHN_EXTENSIONS {
659 pub cExtensions: u32,
660 pub pExtensions: *mut WEBAUTHN_EXTENSION,
661}
662#[cfg(feature = "Win32_Foundation")]
663impl ::core::marker::Copy for WEBAUTHN_EXTENSIONS {}
664#[cfg(feature = "Win32_Foundation")]
665impl ::core::clone::Clone for WEBAUTHN_EXTENSIONS {
666 fn clone(&self) -> Self {
667 *self
668 }
669}
670pub const WEBAUTHN_LARGE_BLOB_SUPPORT_NONE: u32 = 0u32;
671pub const WEBAUTHN_LARGE_BLOB_SUPPORT_PREFERRED: u32 = 2u32;
672pub const WEBAUTHN_LARGE_BLOB_SUPPORT_REQUIRED: u32 = 1u32;
673pub const WEBAUTHN_MAX_USER_ID_LENGTH: u32 = 64u32;
674#[repr(C)]
675#[cfg(feature = "Win32_Foundation")]
676pub struct WEBAUTHN_RP_ENTITY_INFORMATION {
677 pub dwVersion: u32,
678 pub pwszId: super::super::Foundation::PWSTR,
679 pub pwszName: super::super::Foundation::PWSTR,
680 pub pwszIcon: super::super::Foundation::PWSTR,
681}
682#[cfg(feature = "Win32_Foundation")]
683impl ::core::marker::Copy for WEBAUTHN_RP_ENTITY_INFORMATION {}
684#[cfg(feature = "Win32_Foundation")]
685impl ::core::clone::Clone for WEBAUTHN_RP_ENTITY_INFORMATION {
686 fn clone(&self) -> Self {
687 *self
688 }
689}
690pub const WEBAUTHN_RP_ENTITY_INFORMATION_CURRENT_VERSION: u32 = 1u32;
691#[repr(C)]
692#[cfg(feature = "Win32_Foundation")]
693pub struct WEBAUTHN_USER_ENTITY_INFORMATION {
694 pub dwVersion: u32,
695 pub cbId: u32,
696 pub pbId: *mut u8,
697 pub pwszName: super::super::Foundation::PWSTR,
698 pub pwszIcon: super::super::Foundation::PWSTR,
699 pub pwszDisplayName: super::super::Foundation::PWSTR,
700}
701#[cfg(feature = "Win32_Foundation")]
702impl ::core::marker::Copy for WEBAUTHN_USER_ENTITY_INFORMATION {}
703#[cfg(feature = "Win32_Foundation")]
704impl ::core::clone::Clone for WEBAUTHN_USER_ENTITY_INFORMATION {
705 fn clone(&self) -> Self {
706 *self
707 }
708}
709pub const WEBAUTHN_USER_ENTITY_INFORMATION_CURRENT_VERSION: u32 = 1u32;
710pub const WEBAUTHN_USER_VERIFICATION_ANY: u32 = 0u32;
711pub const WEBAUTHN_USER_VERIFICATION_OPTIONAL: u32 = 1u32;
712pub const WEBAUTHN_USER_VERIFICATION_OPTIONAL_WITH_CREDENTIAL_ID_LIST: u32 = 2u32;
713pub const WEBAUTHN_USER_VERIFICATION_REQUIRED: u32 = 3u32;
714pub const WEBAUTHN_USER_VERIFICATION_REQUIREMENT_ANY: u32 = 0u32;
715pub const WEBAUTHN_USER_VERIFICATION_REQUIREMENT_DISCOURAGED: u32 = 3u32;
716pub const WEBAUTHN_USER_VERIFICATION_REQUIREMENT_PREFERRED: u32 = 2u32;
717pub const WEBAUTHN_USER_VERIFICATION_REQUIREMENT_REQUIRED: u32 = 1u32;
718#[repr(C)]
719pub struct WEBAUTHN_X5C {
720 pub cbData: u32,
721 pub pbData: *mut u8,
722}
723impl ::core::marker::Copy for WEBAUTHN_X5C {}
724impl ::core::clone::Clone for WEBAUTHN_X5C {
725 fn clone(&self) -> Self {
726 *self
727 }
728}
729pub type WS_ABANDON_MESSAGE_CALLBACK = unsafe extern "system" fn(channelinstance: *const ::core::ffi::c_void, message: *const WS_MESSAGE, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
730pub type WS_ABORT_CHANNEL_CALLBACK = unsafe extern "system" fn(channelinstance: *const ::core::ffi::c_void, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
731pub type WS_ABORT_LISTENER_CALLBACK = unsafe extern "system" fn(listenerinstance: *const ::core::ffi::c_void, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
732pub type WS_ACCEPT_CHANNEL_CALLBACK = unsafe extern "system" fn(listenerinstance: *const ::core::ffi::c_void, channelinstance: *const ::core::ffi::c_void, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
733pub type WS_ADDRESSING_VERSION = i32;
734pub const WS_ADDRESSING_VERSION_0_9: WS_ADDRESSING_VERSION = 1i32;
735pub const WS_ADDRESSING_VERSION_1_0: WS_ADDRESSING_VERSION = 2i32;
736pub const WS_ADDRESSING_VERSION_TRANSPORT: WS_ADDRESSING_VERSION = 3i32;
737#[repr(C)]
738#[cfg(feature = "Win32_Foundation")]
739pub struct WS_ANY_ATTRIBUTE {
740 pub localName: WS_XML_STRING,
741 pub ns: WS_XML_STRING,
742 pub value: *mut WS_XML_TEXT,
743}
744#[cfg(feature = "Win32_Foundation")]
745impl ::core::marker::Copy for WS_ANY_ATTRIBUTE {}
746#[cfg(feature = "Win32_Foundation")]
747impl ::core::clone::Clone for WS_ANY_ATTRIBUTE {
748 fn clone(&self) -> Self {
749 *self
750 }
751}
752#[repr(C)]
753#[cfg(feature = "Win32_Foundation")]
754pub struct WS_ANY_ATTRIBUTES {
755 pub attributes: *mut WS_ANY_ATTRIBUTE,
756 pub attributeCount: u32,
757}
758#[cfg(feature = "Win32_Foundation")]
759impl ::core::marker::Copy for WS_ANY_ATTRIBUTES {}
760#[cfg(feature = "Win32_Foundation")]
761impl ::core::clone::Clone for WS_ANY_ATTRIBUTES {
762 fn clone(&self) -> Self {
763 *self
764 }
765}
766pub type WS_ASYNC_CALLBACK = unsafe extern "system" fn(errorcode: ::windows_sys::core::HRESULT, callbackmodel: WS_CALLBACK_MODEL, callbackstate: *const ::core::ffi::c_void);
767#[repr(C)]
768pub struct WS_ASYNC_CONTEXT {
769 pub callback: WS_ASYNC_CALLBACK,
770 pub callbackState: *mut ::core::ffi::c_void,
771}
772impl ::core::marker::Copy for WS_ASYNC_CONTEXT {}
773impl ::core::clone::Clone for WS_ASYNC_CONTEXT {
774 fn clone(&self) -> Self {
775 *self
776 }
777}
778pub type WS_ASYNC_FUNCTION = unsafe extern "system" fn(hr: ::windows_sys::core::HRESULT, callbackmodel: WS_CALLBACK_MODEL, callbackstate: *const ::core::ffi::c_void, next: *mut WS_ASYNC_OPERATION, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
779#[repr(C)]
780pub struct WS_ASYNC_OPERATION {
781 pub function: WS_ASYNC_FUNCTION,
782}
783impl ::core::marker::Copy for WS_ASYNC_OPERATION {}
784impl ::core::clone::Clone for WS_ASYNC_OPERATION {
785 fn clone(&self) -> Self {
786 *self
787 }
788}
789#[repr(C)]
790pub struct WS_ASYNC_STATE {
791 pub internal0: *mut ::core::ffi::c_void,
792 pub internal1: *mut ::core::ffi::c_void,
793 pub internal2: *mut ::core::ffi::c_void,
794 pub internal3: *mut ::core::ffi::c_void,
795 pub internal4: *mut ::core::ffi::c_void,
796}
797impl ::core::marker::Copy for WS_ASYNC_STATE {}
798impl ::core::clone::Clone for WS_ASYNC_STATE {
799 fn clone(&self) -> Self {
800 *self
801 }
802}
803#[repr(C)]
804#[cfg(feature = "Win32_Foundation")]
805pub struct WS_ATTRIBUTE_DESCRIPTION {
806 pub attributeLocalName: *mut WS_XML_STRING,
807 pub attributeNs: *mut WS_XML_STRING,
808 pub r#type: WS_TYPE,
809 pub typeDescription: *mut ::core::ffi::c_void,
810}
811#[cfg(feature = "Win32_Foundation")]
812impl ::core::marker::Copy for WS_ATTRIBUTE_DESCRIPTION {}
813#[cfg(feature = "Win32_Foundation")]
814impl ::core::clone::Clone for WS_ATTRIBUTE_DESCRIPTION {
815 fn clone(&self) -> Self {
816 *self
817 }
818}
819pub type WS_BINDING_TEMPLATE_TYPE = i32;
820pub const WS_HTTP_BINDING_TEMPLATE_TYPE: WS_BINDING_TEMPLATE_TYPE = 0i32;
821pub const WS_HTTP_SSL_BINDING_TEMPLATE_TYPE: WS_BINDING_TEMPLATE_TYPE = 1i32;
822pub const WS_HTTP_HEADER_AUTH_BINDING_TEMPLATE_TYPE: WS_BINDING_TEMPLATE_TYPE = 2i32;
823pub const WS_HTTP_SSL_HEADER_AUTH_BINDING_TEMPLATE_TYPE: WS_BINDING_TEMPLATE_TYPE = 3i32;
824pub const WS_HTTP_SSL_USERNAME_BINDING_TEMPLATE_TYPE: WS_BINDING_TEMPLATE_TYPE = 4i32;
825pub const WS_HTTP_SSL_KERBEROS_APREQ_BINDING_TEMPLATE_TYPE: WS_BINDING_TEMPLATE_TYPE = 5i32;
826pub const WS_TCP_BINDING_TEMPLATE_TYPE: WS_BINDING_TEMPLATE_TYPE = 6i32;
827pub const WS_TCP_SSPI_BINDING_TEMPLATE_TYPE: WS_BINDING_TEMPLATE_TYPE = 7i32;
828pub const WS_TCP_SSPI_USERNAME_BINDING_TEMPLATE_TYPE: WS_BINDING_TEMPLATE_TYPE = 8i32;
829pub const WS_TCP_SSPI_KERBEROS_APREQ_BINDING_TEMPLATE_TYPE: WS_BINDING_TEMPLATE_TYPE = 9i32;
830pub const WS_HTTP_SSL_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE: WS_BINDING_TEMPLATE_TYPE = 10i32;
831pub const WS_HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE: WS_BINDING_TEMPLATE_TYPE = 11i32;
832pub const WS_TCP_SSPI_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE: WS_BINDING_TEMPLATE_TYPE = 12i32;
833pub const WS_TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE_TYPE: WS_BINDING_TEMPLATE_TYPE = 13i32;
834#[repr(C)]
835#[cfg(feature = "Win32_Foundation")]
836pub struct WS_BOOL_DESCRIPTION {
837 pub value: super::super::Foundation::BOOL,
838}
839#[cfg(feature = "Win32_Foundation")]
840impl ::core::marker::Copy for WS_BOOL_DESCRIPTION {}
841#[cfg(feature = "Win32_Foundation")]
842impl ::core::clone::Clone for WS_BOOL_DESCRIPTION {
843 fn clone(&self) -> Self {
844 *self
845 }
846}
847#[repr(C)]
848pub struct WS_BUFFERS {
849 pub bufferCount: u32,
850 pub buffers: *mut WS_BYTES,
851}
852impl ::core::marker::Copy for WS_BUFFERS {}
853impl ::core::clone::Clone for WS_BUFFERS {
854 fn clone(&self) -> Self {
855 *self
856 }
857}
858#[repr(C)]
859pub struct WS_BYTES {
860 pub length: u32,
861 pub bytes: *mut u8,
862}
863impl ::core::marker::Copy for WS_BYTES {}
864impl ::core::clone::Clone for WS_BYTES {
865 fn clone(&self) -> Self {
866 *self
867 }
868}
869#[repr(C)]
870pub struct WS_BYTES_DESCRIPTION {
871 pub minByteCount: u32,
872 pub maxByteCount: u32,
873}
874impl ::core::marker::Copy for WS_BYTES_DESCRIPTION {}
875impl ::core::clone::Clone for WS_BYTES_DESCRIPTION {
876 fn clone(&self) -> Self {
877 *self
878 }
879}
880#[repr(C)]
881pub struct WS_BYTE_ARRAY_DESCRIPTION {
882 pub minByteCount: u32,
883 pub maxByteCount: u32,
884}
885impl ::core::marker::Copy for WS_BYTE_ARRAY_DESCRIPTION {}
886impl ::core::clone::Clone for WS_BYTE_ARRAY_DESCRIPTION {
887 fn clone(&self) -> Self {
888 *self
889 }
890}
891pub type WS_CALLBACK_MODEL = i32;
892pub const WS_SHORT_CALLBACK: WS_CALLBACK_MODEL = 0i32;
893pub const WS_LONG_CALLBACK: WS_CALLBACK_MODEL = 1i32;
894#[repr(C)]
895pub struct WS_CALL_PROPERTY {
896 pub id: WS_CALL_PROPERTY_ID,
897 pub value: *mut ::core::ffi::c_void,
898 pub valueSize: u32,
899}
900impl ::core::marker::Copy for WS_CALL_PROPERTY {}
901impl ::core::clone::Clone for WS_CALL_PROPERTY {
902 fn clone(&self) -> Self {
903 *self
904 }
905}
906pub type WS_CALL_PROPERTY_ID = i32;
907pub const WS_CALL_PROPERTY_CHECK_MUST_UNDERSTAND: WS_CALL_PROPERTY_ID = 0i32;
908pub const WS_CALL_PROPERTY_SEND_MESSAGE_CONTEXT: WS_CALL_PROPERTY_ID = 1i32;
909pub const WS_CALL_PROPERTY_RECEIVE_MESSAGE_CONTEXT: WS_CALL_PROPERTY_ID = 2i32;
910pub const WS_CALL_PROPERTY_CALL_ID: WS_CALL_PROPERTY_ID = 3i32;
911#[repr(C)]
912pub struct WS_CAPI_ASYMMETRIC_SECURITY_KEY_HANDLE {
913 pub keyHandle: WS_SECURITY_KEY_HANDLE,
914 pub provider: usize,
915 pub keySpec: u32,
916}
917impl ::core::marker::Copy for WS_CAPI_ASYMMETRIC_SECURITY_KEY_HANDLE {}
918impl ::core::clone::Clone for WS_CAPI_ASYMMETRIC_SECURITY_KEY_HANDLE {
919 fn clone(&self) -> Self {
920 *self
921 }
922}
923#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
924pub type WS_CERTIFICATE_VALIDATION_CALLBACK = unsafe extern "system" fn(certcontext: *const super::super::Security::Cryptography::CERT_CONTEXT, state: *const ::core::ffi::c_void) -> ::windows_sys::core::HRESULT;
925#[repr(C)]
926#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
927pub struct WS_CERTIFICATE_VALIDATION_CALLBACK_CONTEXT {
928 pub callback: WS_CERTIFICATE_VALIDATION_CALLBACK,
929 pub state: *mut ::core::ffi::c_void,
930}
931#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
932impl ::core::marker::Copy for WS_CERTIFICATE_VALIDATION_CALLBACK_CONTEXT {}
933#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
934impl ::core::clone::Clone for WS_CERTIFICATE_VALIDATION_CALLBACK_CONTEXT {
935 fn clone(&self) -> Self {
936 *self
937 }
938}
939#[repr(C)]
940pub struct WS_CERT_CREDENTIAL {
941 pub credentialType: WS_CERT_CREDENTIAL_TYPE,
942}
943impl ::core::marker::Copy for WS_CERT_CREDENTIAL {}
944impl ::core::clone::Clone for WS_CERT_CREDENTIAL {
945 fn clone(&self) -> Self {
946 *self
947 }
948}
949pub type WS_CERT_CREDENTIAL_TYPE = i32;
950pub const WS_SUBJECT_NAME_CERT_CREDENTIAL_TYPE: WS_CERT_CREDENTIAL_TYPE = 1i32;
951pub const WS_THUMBPRINT_CERT_CREDENTIAL_TYPE: WS_CERT_CREDENTIAL_TYPE = 2i32;
952pub const WS_CUSTOM_CERT_CREDENTIAL_TYPE: WS_CERT_CREDENTIAL_TYPE = 3i32;
953#[repr(C)]
954pub struct WS_CERT_ENDPOINT_IDENTITY {
955 pub identity: WS_ENDPOINT_IDENTITY,
956 pub rawCertificateData: WS_BYTES,
957}
958impl ::core::marker::Copy for WS_CERT_ENDPOINT_IDENTITY {}
959impl ::core::clone::Clone for WS_CERT_ENDPOINT_IDENTITY {
960 fn clone(&self) -> Self {
961 *self
962 }
963}
964pub const WS_CERT_FAILURE_CN_MISMATCH: i32 = 1i32;
965pub const WS_CERT_FAILURE_INVALID_DATE: i32 = 2i32;
966pub const WS_CERT_FAILURE_REVOCATION_OFFLINE: i32 = 16i32;
967pub const WS_CERT_FAILURE_UNTRUSTED_ROOT: i32 = 4i32;
968pub const WS_CERT_FAILURE_WRONG_USAGE: i32 = 8i32;
969#[cfg(all(feature = "Win32_Security_Authentication_Identity", feature = "Win32_Security_Cryptography"))]
970pub type WS_CERT_ISSUER_LIST_NOTIFICATION_CALLBACK = unsafe extern "system" fn(certissuerlistnotificationcallbackstate: *const ::core::ffi::c_void, issuerlist: *const super::super::Security::Authentication::Identity::SecPkgContext_IssuerListInfoEx, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
971#[repr(C)]
972pub struct WS_CERT_MESSAGE_SECURITY_BINDING_CONSTRAINT {
973 pub bindingConstraint: WS_SECURITY_BINDING_CONSTRAINT,
974 pub bindingUsage: WS_MESSAGE_SECURITY_USAGE,
975}
976impl ::core::marker::Copy for WS_CERT_MESSAGE_SECURITY_BINDING_CONSTRAINT {}
977impl ::core::clone::Clone for WS_CERT_MESSAGE_SECURITY_BINDING_CONSTRAINT {
978 fn clone(&self) -> Self {
979 *self
980 }
981}
982#[repr(C)]
983#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
984pub struct WS_CERT_SIGNED_SAML_AUTHENTICATOR {
985 pub authenticator: WS_SAML_AUTHENTICATOR,
986 pub trustedIssuerCerts: *mut *mut super::super::Security::Cryptography::CERT_CONTEXT,
987 pub trustedIssuerCertCount: u32,
988 pub decryptionCert: *mut super::super::Security::Cryptography::CERT_CONTEXT,
989 pub samlValidator: WS_VALIDATE_SAML_CALLBACK,
990 pub samlValidatorCallbackState: *mut ::core::ffi::c_void,
991}
992#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
993impl ::core::marker::Copy for WS_CERT_SIGNED_SAML_AUTHENTICATOR {}
994#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
995impl ::core::clone::Clone for WS_CERT_SIGNED_SAML_AUTHENTICATOR {
996 fn clone(&self) -> Self {
997 *self
998 }
999}
1000#[repr(C)]
1001pub struct WS_CHANNEL(pub u8);
1002pub type WS_CHANNEL_BINDING = i32;
1003pub const WS_HTTP_CHANNEL_BINDING: WS_CHANNEL_BINDING = 0i32;
1004pub const WS_TCP_CHANNEL_BINDING: WS_CHANNEL_BINDING = 1i32;
1005pub const WS_UDP_CHANNEL_BINDING: WS_CHANNEL_BINDING = 2i32;
1006pub const WS_CUSTOM_CHANNEL_BINDING: WS_CHANNEL_BINDING = 3i32;
1007pub const WS_NAMEDPIPE_CHANNEL_BINDING: WS_CHANNEL_BINDING = 4i32;
1008#[repr(C)]
1009#[cfg(feature = "Win32_Foundation")]
1010pub struct WS_CHANNEL_DECODER {
1011 pub createContext: *mut ::core::ffi::c_void,
1012 pub createDecoderCallback: WS_CREATE_DECODER_CALLBACK,
1013 pub decoderGetContentTypeCallback: WS_DECODER_GET_CONTENT_TYPE_CALLBACK,
1014 pub decoderStartCallback: WS_DECODER_START_CALLBACK,
1015 pub decoderDecodeCallback: WS_DECODER_DECODE_CALLBACK,
1016 pub decoderEndCallback: WS_DECODER_END_CALLBACK,
1017 pub freeDecoderCallback: WS_FREE_DECODER_CALLBACK,
1018}
1019#[cfg(feature = "Win32_Foundation")]
1020impl ::core::marker::Copy for WS_CHANNEL_DECODER {}
1021#[cfg(feature = "Win32_Foundation")]
1022impl ::core::clone::Clone for WS_CHANNEL_DECODER {
1023 fn clone(&self) -> Self {
1024 *self
1025 }
1026}
1027#[repr(C)]
1028#[cfg(feature = "Win32_Foundation")]
1029pub struct WS_CHANNEL_ENCODER {
1030 pub createContext: *mut ::core::ffi::c_void,
1031 pub createEncoderCallback: WS_CREATE_ENCODER_CALLBACK,
1032 pub encoderGetContentTypeCallback: WS_ENCODER_GET_CONTENT_TYPE_CALLBACK,
1033 pub encoderStartCallback: WS_ENCODER_START_CALLBACK,
1034 pub encoderEncodeCallback: WS_ENCODER_ENCODE_CALLBACK,
1035 pub encoderEndCallback: WS_ENCODER_END_CALLBACK,
1036 pub freeEncoderCallback: WS_FREE_ENCODER_CALLBACK,
1037}
1038#[cfg(feature = "Win32_Foundation")]
1039impl ::core::marker::Copy for WS_CHANNEL_ENCODER {}
1040#[cfg(feature = "Win32_Foundation")]
1041impl ::core::clone::Clone for WS_CHANNEL_ENCODER {
1042 fn clone(&self) -> Self {
1043 *self
1044 }
1045}
1046#[repr(C)]
1047pub struct WS_CHANNEL_PROPERTIES {
1048 pub properties: *mut WS_CHANNEL_PROPERTY,
1049 pub propertyCount: u32,
1050}
1051impl ::core::marker::Copy for WS_CHANNEL_PROPERTIES {}
1052impl ::core::clone::Clone for WS_CHANNEL_PROPERTIES {
1053 fn clone(&self) -> Self {
1054 *self
1055 }
1056}
1057#[repr(C)]
1058pub struct WS_CHANNEL_PROPERTY {
1059 pub id: WS_CHANNEL_PROPERTY_ID,
1060 pub value: *mut ::core::ffi::c_void,
1061 pub valueSize: u32,
1062}
1063impl ::core::marker::Copy for WS_CHANNEL_PROPERTY {}
1064impl ::core::clone::Clone for WS_CHANNEL_PROPERTY {
1065 fn clone(&self) -> Self {
1066 *self
1067 }
1068}
1069#[repr(C)]
1070pub struct WS_CHANNEL_PROPERTY_CONSTRAINT {
1071 pub id: WS_CHANNEL_PROPERTY_ID,
1072 pub allowedValues: *mut ::core::ffi::c_void,
1073 pub allowedValuesSize: u32,
1074 pub out: WS_CHANNEL_PROPERTY_CONSTRAINT_0,
1075}
1076impl ::core::marker::Copy for WS_CHANNEL_PROPERTY_CONSTRAINT {}
1077impl ::core::clone::Clone for WS_CHANNEL_PROPERTY_CONSTRAINT {
1078 fn clone(&self) -> Self {
1079 *self
1080 }
1081}
1082#[repr(C)]
1083pub struct WS_CHANNEL_PROPERTY_CONSTRAINT_0 {
1084 pub channelProperty: WS_CHANNEL_PROPERTY,
1085}
1086impl ::core::marker::Copy for WS_CHANNEL_PROPERTY_CONSTRAINT_0 {}
1087impl ::core::clone::Clone for WS_CHANNEL_PROPERTY_CONSTRAINT_0 {
1088 fn clone(&self) -> Self {
1089 *self
1090 }
1091}
1092pub type WS_CHANNEL_PROPERTY_ID = i32;
1093pub const WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE: WS_CHANNEL_PROPERTY_ID = 0i32;
1094pub const WS_CHANNEL_PROPERTY_MAX_STREAMED_MESSAGE_SIZE: WS_CHANNEL_PROPERTY_ID = 1i32;
1095pub const WS_CHANNEL_PROPERTY_MAX_STREAMED_START_SIZE: WS_CHANNEL_PROPERTY_ID = 2i32;
1096pub const WS_CHANNEL_PROPERTY_MAX_STREAMED_FLUSH_SIZE: WS_CHANNEL_PROPERTY_ID = 3i32;
1097pub const WS_CHANNEL_PROPERTY_ENCODING: WS_CHANNEL_PROPERTY_ID = 4i32;
1098pub const WS_CHANNEL_PROPERTY_ENVELOPE_VERSION: WS_CHANNEL_PROPERTY_ID = 5i32;
1099pub const WS_CHANNEL_PROPERTY_ADDRESSING_VERSION: WS_CHANNEL_PROPERTY_ID = 6i32;
1100pub const WS_CHANNEL_PROPERTY_MAX_SESSION_DICTIONARY_SIZE: WS_CHANNEL_PROPERTY_ID = 7i32;
1101pub const WS_CHANNEL_PROPERTY_STATE: WS_CHANNEL_PROPERTY_ID = 8i32;
1102pub const WS_CHANNEL_PROPERTY_ASYNC_CALLBACK_MODEL: WS_CHANNEL_PROPERTY_ID = 9i32;
1103pub const WS_CHANNEL_PROPERTY_IP_VERSION: WS_CHANNEL_PROPERTY_ID = 10i32;
1104pub const WS_CHANNEL_PROPERTY_RESOLVE_TIMEOUT: WS_CHANNEL_PROPERTY_ID = 11i32;
1105pub const WS_CHANNEL_PROPERTY_CONNECT_TIMEOUT: WS_CHANNEL_PROPERTY_ID = 12i32;
1106pub const WS_CHANNEL_PROPERTY_SEND_TIMEOUT: WS_CHANNEL_PROPERTY_ID = 13i32;
1107pub const WS_CHANNEL_PROPERTY_RECEIVE_RESPONSE_TIMEOUT: WS_CHANNEL_PROPERTY_ID = 14i32;
1108pub const WS_CHANNEL_PROPERTY_RECEIVE_TIMEOUT: WS_CHANNEL_PROPERTY_ID = 15i32;
1109pub const WS_CHANNEL_PROPERTY_CLOSE_TIMEOUT: WS_CHANNEL_PROPERTY_ID = 16i32;
1110pub const WS_CHANNEL_PROPERTY_ENABLE_TIMEOUTS: WS_CHANNEL_PROPERTY_ID = 17i32;
1111pub const WS_CHANNEL_PROPERTY_TRANSFER_MODE: WS_CHANNEL_PROPERTY_ID = 18i32;
1112pub const WS_CHANNEL_PROPERTY_MULTICAST_INTERFACE: WS_CHANNEL_PROPERTY_ID = 19i32;
1113pub const WS_CHANNEL_PROPERTY_MULTICAST_HOPS: WS_CHANNEL_PROPERTY_ID = 20i32;
1114pub const WS_CHANNEL_PROPERTY_REMOTE_ADDRESS: WS_CHANNEL_PROPERTY_ID = 21i32;
1115pub const WS_CHANNEL_PROPERTY_REMOTE_IP_ADDRESS: WS_CHANNEL_PROPERTY_ID = 22i32;
1116pub const WS_CHANNEL_PROPERTY_HTTP_CONNECTION_ID: WS_CHANNEL_PROPERTY_ID = 23i32;
1117pub const WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_CALLBACKS: WS_CHANNEL_PROPERTY_ID = 24i32;
1118pub const WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_PARAMETERS: WS_CHANNEL_PROPERTY_ID = 25i32;
1119pub const WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_INSTANCE: WS_CHANNEL_PROPERTY_ID = 26i32;
1120pub const WS_CHANNEL_PROPERTY_TRANSPORT_URL: WS_CHANNEL_PROPERTY_ID = 27i32;
1121pub const WS_CHANNEL_PROPERTY_NO_DELAY: WS_CHANNEL_PROPERTY_ID = 28i32;
1122pub const WS_CHANNEL_PROPERTY_SEND_KEEP_ALIVES: WS_CHANNEL_PROPERTY_ID = 29i32;
1123pub const WS_CHANNEL_PROPERTY_KEEP_ALIVE_TIME: WS_CHANNEL_PROPERTY_ID = 30i32;
1124pub const WS_CHANNEL_PROPERTY_KEEP_ALIVE_INTERVAL: WS_CHANNEL_PROPERTY_ID = 31i32;
1125pub const WS_CHANNEL_PROPERTY_MAX_HTTP_SERVER_CONNECTIONS: WS_CHANNEL_PROPERTY_ID = 32i32;
1126pub const WS_CHANNEL_PROPERTY_IS_SESSION_SHUT_DOWN: WS_CHANNEL_PROPERTY_ID = 33i32;
1127pub const WS_CHANNEL_PROPERTY_CHANNEL_TYPE: WS_CHANNEL_PROPERTY_ID = 34i32;
1128pub const WS_CHANNEL_PROPERTY_TRIM_BUFFERED_MESSAGE_SIZE: WS_CHANNEL_PROPERTY_ID = 35i32;
1129pub const WS_CHANNEL_PROPERTY_ENCODER: WS_CHANNEL_PROPERTY_ID = 36i32;
1130pub const WS_CHANNEL_PROPERTY_DECODER: WS_CHANNEL_PROPERTY_ID = 37i32;
1131pub const WS_CHANNEL_PROPERTY_PROTECTION_LEVEL: WS_CHANNEL_PROPERTY_ID = 38i32;
1132pub const WS_CHANNEL_PROPERTY_COOKIE_MODE: WS_CHANNEL_PROPERTY_ID = 39i32;
1133pub const WS_CHANNEL_PROPERTY_HTTP_PROXY_SETTING_MODE: WS_CHANNEL_PROPERTY_ID = 40i32;
1134pub const WS_CHANNEL_PROPERTY_CUSTOM_HTTP_PROXY: WS_CHANNEL_PROPERTY_ID = 41i32;
1135pub const WS_CHANNEL_PROPERTY_HTTP_MESSAGE_MAPPING: WS_CHANNEL_PROPERTY_ID = 42i32;
1136pub const WS_CHANNEL_PROPERTY_ENABLE_HTTP_REDIRECT: WS_CHANNEL_PROPERTY_ID = 43i32;
1137pub const WS_CHANNEL_PROPERTY_HTTP_REDIRECT_CALLBACK_CONTEXT: WS_CHANNEL_PROPERTY_ID = 44i32;
1138pub const WS_CHANNEL_PROPERTY_FAULTS_AS_ERRORS: WS_CHANNEL_PROPERTY_ID = 45i32;
1139pub const WS_CHANNEL_PROPERTY_ALLOW_UNSECURED_FAULTS: WS_CHANNEL_PROPERTY_ID = 46i32;
1140pub const WS_CHANNEL_PROPERTY_HTTP_SERVER_SPN: WS_CHANNEL_PROPERTY_ID = 47i32;
1141pub const WS_CHANNEL_PROPERTY_HTTP_PROXY_SPN: WS_CHANNEL_PROPERTY_ID = 48i32;
1142pub const WS_CHANNEL_PROPERTY_MAX_HTTP_REQUEST_HEADERS_BUFFER_SIZE: WS_CHANNEL_PROPERTY_ID = 49i32;
1143pub type WS_CHANNEL_STATE = i32;
1144pub const WS_CHANNEL_STATE_CREATED: WS_CHANNEL_STATE = 0i32;
1145pub const WS_CHANNEL_STATE_OPENING: WS_CHANNEL_STATE = 1i32;
1146pub const WS_CHANNEL_STATE_ACCEPTING: WS_CHANNEL_STATE = 2i32;
1147pub const WS_CHANNEL_STATE_OPEN: WS_CHANNEL_STATE = 3i32;
1148pub const WS_CHANNEL_STATE_FAULTED: WS_CHANNEL_STATE = 4i32;
1149pub const WS_CHANNEL_STATE_CLOSING: WS_CHANNEL_STATE = 5i32;
1150pub const WS_CHANNEL_STATE_CLOSED: WS_CHANNEL_STATE = 6i32;
1151pub type WS_CHANNEL_TYPE = i32;
1152pub const WS_CHANNEL_TYPE_INPUT: WS_CHANNEL_TYPE = 1i32;
1153pub const WS_CHANNEL_TYPE_OUTPUT: WS_CHANNEL_TYPE = 2i32;
1154pub const WS_CHANNEL_TYPE_SESSION: WS_CHANNEL_TYPE = 4i32;
1155pub const WS_CHANNEL_TYPE_INPUT_SESSION: WS_CHANNEL_TYPE = 5i32;
1156pub const WS_CHANNEL_TYPE_OUTPUT_SESSION: WS_CHANNEL_TYPE = 6i32;
1157pub const WS_CHANNEL_TYPE_DUPLEX: WS_CHANNEL_TYPE = 3i32;
1158pub const WS_CHANNEL_TYPE_DUPLEX_SESSION: WS_CHANNEL_TYPE = 7i32;
1159pub const WS_CHANNEL_TYPE_REQUEST: WS_CHANNEL_TYPE = 8i32;
1160pub const WS_CHANNEL_TYPE_REPLY: WS_CHANNEL_TYPE = 16i32;
1161pub type WS_CHARSET = i32;
1162pub const WS_CHARSET_AUTO: WS_CHARSET = 0i32;
1163pub const WS_CHARSET_UTF8: WS_CHARSET = 1i32;
1164pub const WS_CHARSET_UTF16LE: WS_CHARSET = 2i32;
1165pub const WS_CHARSET_UTF16BE: WS_CHARSET = 3i32;
1166#[repr(C)]
1167pub struct WS_CHAR_ARRAY_DESCRIPTION {
1168 pub minCharCount: u32,
1169 pub maxCharCount: u32,
1170}
1171impl ::core::marker::Copy for WS_CHAR_ARRAY_DESCRIPTION {}
1172impl ::core::clone::Clone for WS_CHAR_ARRAY_DESCRIPTION {
1173 fn clone(&self) -> Self {
1174 *self
1175 }
1176}
1177pub type WS_CLOSE_CHANNEL_CALLBACK = unsafe extern "system" fn(channelinstance: *const ::core::ffi::c_void, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1178pub type WS_CLOSE_LISTENER_CALLBACK = unsafe extern "system" fn(listenerinstance: *const ::core::ffi::c_void, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1179#[repr(C)]
1180#[cfg(feature = "Win32_Foundation")]
1181pub struct WS_CONTRACT_DESCRIPTION {
1182 pub operationCount: u32,
1183 pub operations: *mut *mut WS_OPERATION_DESCRIPTION,
1184}
1185#[cfg(feature = "Win32_Foundation")]
1186impl ::core::marker::Copy for WS_CONTRACT_DESCRIPTION {}
1187#[cfg(feature = "Win32_Foundation")]
1188impl ::core::clone::Clone for WS_CONTRACT_DESCRIPTION {
1189 fn clone(&self) -> Self {
1190 *self
1191 }
1192}
1193pub type WS_COOKIE_MODE = i32;
1194pub const WS_MANUAL_COOKIE_MODE: WS_COOKIE_MODE = 1i32;
1195pub const WS_AUTO_COOKIE_MODE: WS_COOKIE_MODE = 2i32;
1196pub type WS_CREATE_CHANNEL_CALLBACK = unsafe extern "system" fn(channeltype: WS_CHANNEL_TYPE, channelparameters: *const ::core::ffi::c_void, channelparameterssize: u32, channelinstance: *mut *mut ::core::ffi::c_void, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1197pub type WS_CREATE_CHANNEL_FOR_LISTENER_CALLBACK = unsafe extern "system" fn(listenerinstance: *const ::core::ffi::c_void, channelparameters: *const ::core::ffi::c_void, channelparameterssize: u32, channelinstance: *mut *mut ::core::ffi::c_void, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1198pub type WS_CREATE_DECODER_CALLBACK = unsafe extern "system" fn(createcontext: *const ::core::ffi::c_void, readcallback: ::core::option::Option<WS_READ_CALLBACK>, readcontext: *const ::core::ffi::c_void, decodercontext: *mut *mut ::core::ffi::c_void, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1199pub type WS_CREATE_ENCODER_CALLBACK = unsafe extern "system" fn(createcontext: *const ::core::ffi::c_void, writecallback: ::core::option::Option<WS_WRITE_CALLBACK>, writecontext: *const ::core::ffi::c_void, encodercontext: *mut *mut ::core::ffi::c_void, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1200pub type WS_CREATE_LISTENER_CALLBACK = unsafe extern "system" fn(channeltype: WS_CHANNEL_TYPE, listenerparameters: *const ::core::ffi::c_void, listenerparameterssize: u32, listenerinstance: *mut *mut ::core::ffi::c_void, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1201#[repr(C)]
1202#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Authentication_Identity", feature = "Win32_Security_Cryptography"))]
1203pub struct WS_CUSTOM_CERT_CREDENTIAL {
1204 pub credential: WS_CERT_CREDENTIAL,
1205 pub getCertCallback: WS_GET_CERT_CALLBACK,
1206 pub getCertCallbackState: *mut ::core::ffi::c_void,
1207 pub certIssuerListNotificationCallback: WS_CERT_ISSUER_LIST_NOTIFICATION_CALLBACK,
1208 pub certIssuerListNotificationCallbackState: *mut ::core::ffi::c_void,
1209}
1210#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Authentication_Identity", feature = "Win32_Security_Cryptography"))]
1211impl ::core::marker::Copy for WS_CUSTOM_CERT_CREDENTIAL {}
1212#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Authentication_Identity", feature = "Win32_Security_Cryptography"))]
1213impl ::core::clone::Clone for WS_CUSTOM_CERT_CREDENTIAL {
1214 fn clone(&self) -> Self {
1215 *self
1216 }
1217}
1218#[repr(C)]
1219#[cfg(feature = "Win32_Foundation")]
1220pub struct WS_CUSTOM_CHANNEL_CALLBACKS {
1221 pub createChannelCallback: WS_CREATE_CHANNEL_CALLBACK,
1222 pub freeChannelCallback: WS_FREE_CHANNEL_CALLBACK,
1223 pub resetChannelCallback: WS_RESET_CHANNEL_CALLBACK,
1224 pub openChannelCallback: WS_OPEN_CHANNEL_CALLBACK,
1225 pub closeChannelCallback: WS_CLOSE_CHANNEL_CALLBACK,
1226 pub abortChannelCallback: WS_ABORT_CHANNEL_CALLBACK,
1227 pub getChannelPropertyCallback: WS_GET_CHANNEL_PROPERTY_CALLBACK,
1228 pub setChannelPropertyCallback: WS_SET_CHANNEL_PROPERTY_CALLBACK,
1229 pub writeMessageStartCallback: WS_WRITE_MESSAGE_START_CALLBACK,
1230 pub writeMessageEndCallback: WS_WRITE_MESSAGE_END_CALLBACK,
1231 pub readMessageStartCallback: WS_READ_MESSAGE_START_CALLBACK,
1232 pub readMessageEndCallback: WS_READ_MESSAGE_END_CALLBACK,
1233 pub abandonMessageCallback: WS_ABANDON_MESSAGE_CALLBACK,
1234 pub shutdownSessionChannelCallback: WS_SHUTDOWN_SESSION_CHANNEL_CALLBACK,
1235}
1236#[cfg(feature = "Win32_Foundation")]
1237impl ::core::marker::Copy for WS_CUSTOM_CHANNEL_CALLBACKS {}
1238#[cfg(feature = "Win32_Foundation")]
1239impl ::core::clone::Clone for WS_CUSTOM_CHANNEL_CALLBACKS {
1240 fn clone(&self) -> Self {
1241 *self
1242 }
1243}
1244#[repr(C)]
1245#[cfg(feature = "Win32_Foundation")]
1246pub struct WS_CUSTOM_HTTP_PROXY {
1247 pub servers: WS_STRING,
1248 pub bypass: WS_STRING,
1249}
1250#[cfg(feature = "Win32_Foundation")]
1251impl ::core::marker::Copy for WS_CUSTOM_HTTP_PROXY {}
1252#[cfg(feature = "Win32_Foundation")]
1253impl ::core::clone::Clone for WS_CUSTOM_HTTP_PROXY {
1254 fn clone(&self) -> Self {
1255 *self
1256 }
1257}
1258#[repr(C)]
1259#[cfg(feature = "Win32_Foundation")]
1260pub struct WS_CUSTOM_LISTENER_CALLBACKS {
1261 pub createListenerCallback: WS_CREATE_LISTENER_CALLBACK,
1262 pub freeListenerCallback: WS_FREE_LISTENER_CALLBACK,
1263 pub resetListenerCallback: WS_RESET_LISTENER_CALLBACK,
1264 pub openListenerCallback: WS_OPEN_LISTENER_CALLBACK,
1265 pub closeListenerCallback: WS_CLOSE_LISTENER_CALLBACK,
1266 pub abortListenerCallback: WS_ABORT_LISTENER_CALLBACK,
1267 pub getListenerPropertyCallback: WS_GET_LISTENER_PROPERTY_CALLBACK,
1268 pub setListenerPropertyCallback: WS_SET_LISTENER_PROPERTY_CALLBACK,
1269 pub createChannelForListenerCallback: WS_CREATE_CHANNEL_FOR_LISTENER_CALLBACK,
1270 pub acceptChannelCallback: WS_ACCEPT_CHANNEL_CALLBACK,
1271}
1272#[cfg(feature = "Win32_Foundation")]
1273impl ::core::marker::Copy for WS_CUSTOM_LISTENER_CALLBACKS {}
1274#[cfg(feature = "Win32_Foundation")]
1275impl ::core::clone::Clone for WS_CUSTOM_LISTENER_CALLBACKS {
1276 fn clone(&self) -> Self {
1277 *self
1278 }
1279}
1280#[repr(C)]
1281#[cfg(feature = "Win32_Foundation")]
1282pub struct WS_CUSTOM_TYPE_DESCRIPTION {
1283 pub size: u32,
1284 pub alignment: u32,
1285 pub readCallback: WS_READ_TYPE_CALLBACK,
1286 pub writeCallback: WS_WRITE_TYPE_CALLBACK,
1287 pub descriptionData: *mut ::core::ffi::c_void,
1288 pub isDefaultValueCallback: WS_IS_DEFAULT_VALUE_CALLBACK,
1289}
1290#[cfg(feature = "Win32_Foundation")]
1291impl ::core::marker::Copy for WS_CUSTOM_TYPE_DESCRIPTION {}
1292#[cfg(feature = "Win32_Foundation")]
1293impl ::core::clone::Clone for WS_CUSTOM_TYPE_DESCRIPTION {
1294 fn clone(&self) -> Self {
1295 *self
1296 }
1297}
1298#[repr(C)]
1299pub struct WS_DATETIME {
1300 pub ticks: u64,
1301 pub format: WS_DATETIME_FORMAT,
1302}
1303impl ::core::marker::Copy for WS_DATETIME {}
1304impl ::core::clone::Clone for WS_DATETIME {
1305 fn clone(&self) -> Self {
1306 *self
1307 }
1308}
1309#[repr(C)]
1310pub struct WS_DATETIME_DESCRIPTION {
1311 pub minValue: WS_DATETIME,
1312 pub maxValue: WS_DATETIME,
1313}
1314impl ::core::marker::Copy for WS_DATETIME_DESCRIPTION {}
1315impl ::core::clone::Clone for WS_DATETIME_DESCRIPTION {
1316 fn clone(&self) -> Self {
1317 *self
1318 }
1319}
1320pub type WS_DATETIME_FORMAT = i32;
1321pub const WS_DATETIME_FORMAT_UTC: WS_DATETIME_FORMAT = 0i32;
1322pub const WS_DATETIME_FORMAT_LOCAL: WS_DATETIME_FORMAT = 1i32;
1323pub const WS_DATETIME_FORMAT_NONE: WS_DATETIME_FORMAT = 2i32;
1324#[repr(C)]
1325#[cfg(feature = "Win32_Foundation")]
1326pub struct WS_DECIMAL_DESCRIPTION {
1327 pub minValue: super::super::Foundation::DECIMAL,
1328 pub maxValue: super::super::Foundation::DECIMAL,
1329}
1330#[cfg(feature = "Win32_Foundation")]
1331impl ::core::marker::Copy for WS_DECIMAL_DESCRIPTION {}
1332#[cfg(feature = "Win32_Foundation")]
1333impl ::core::clone::Clone for WS_DECIMAL_DESCRIPTION {
1334 fn clone(&self) -> Self {
1335 *self
1336 }
1337}
1338pub type WS_DECODER_DECODE_CALLBACK = unsafe extern "system" fn(encodercontext: *const ::core::ffi::c_void, buffer: *mut ::core::ffi::c_void, maxlength: u32, length: *mut u32, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1339pub type WS_DECODER_END_CALLBACK = unsafe extern "system" fn(encodercontext: *const ::core::ffi::c_void, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1340#[cfg(feature = "Win32_Foundation")]
1341pub type WS_DECODER_GET_CONTENT_TYPE_CALLBACK = unsafe extern "system" fn(decodercontext: *const ::core::ffi::c_void, contenttype: *const WS_STRING, contentencoding: *const WS_STRING, newcontenttype: *mut WS_STRING, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1342pub type WS_DECODER_START_CALLBACK = unsafe extern "system" fn(encodercontext: *const ::core::ffi::c_void, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1343#[repr(C)]
1344pub struct WS_DEFAULT_VALUE {
1345 pub value: *mut ::core::ffi::c_void,
1346 pub valueSize: u32,
1347}
1348impl ::core::marker::Copy for WS_DEFAULT_VALUE {}
1349impl ::core::clone::Clone for WS_DEFAULT_VALUE {
1350 fn clone(&self) -> Self {
1351 *self
1352 }
1353}
1354#[repr(C)]
1355pub struct WS_DEFAULT_WINDOWS_INTEGRATED_AUTH_CREDENTIAL {
1356 pub credential: WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
1357}
1358impl ::core::marker::Copy for WS_DEFAULT_WINDOWS_INTEGRATED_AUTH_CREDENTIAL {}
1359impl ::core::clone::Clone for WS_DEFAULT_WINDOWS_INTEGRATED_AUTH_CREDENTIAL {
1360 fn clone(&self) -> Self {
1361 *self
1362 }
1363}
1364#[repr(C)]
1365#[cfg(feature = "Win32_Foundation")]
1366pub struct WS_DISALLOWED_USER_AGENT_SUBSTRINGS {
1367 pub subStringCount: u32,
1368 pub subStrings: *mut *mut WS_STRING,
1369}
1370#[cfg(feature = "Win32_Foundation")]
1371impl ::core::marker::Copy for WS_DISALLOWED_USER_AGENT_SUBSTRINGS {}
1372#[cfg(feature = "Win32_Foundation")]
1373impl ::core::clone::Clone for WS_DISALLOWED_USER_AGENT_SUBSTRINGS {
1374 fn clone(&self) -> Self {
1375 *self
1376 }
1377}
1378#[repr(C)]
1379#[cfg(feature = "Win32_Foundation")]
1380pub struct WS_DNS_ENDPOINT_IDENTITY {
1381 pub identity: WS_ENDPOINT_IDENTITY,
1382 pub dns: WS_STRING,
1383}
1384#[cfg(feature = "Win32_Foundation")]
1385impl ::core::marker::Copy for WS_DNS_ENDPOINT_IDENTITY {}
1386#[cfg(feature = "Win32_Foundation")]
1387impl ::core::clone::Clone for WS_DNS_ENDPOINT_IDENTITY {
1388 fn clone(&self) -> Self {
1389 *self
1390 }
1391}
1392#[repr(C)]
1393pub struct WS_DOUBLE_DESCRIPTION {
1394 pub minValue: f64,
1395 pub maxValue: f64,
1396}
1397impl ::core::marker::Copy for WS_DOUBLE_DESCRIPTION {}
1398impl ::core::clone::Clone for WS_DOUBLE_DESCRIPTION {
1399 fn clone(&self) -> Self {
1400 *self
1401 }
1402}
1403#[repr(C)]
1404#[cfg(feature = "Win32_Foundation")]
1405pub struct WS_DURATION {
1406 pub negative: super::super::Foundation::BOOL,
1407 pub years: u32,
1408 pub months: u32,
1409 pub days: u32,
1410 pub hours: u32,
1411 pub minutes: u32,
1412 pub seconds: u32,
1413 pub milliseconds: u32,
1414 pub ticks: u32,
1415}
1416#[cfg(feature = "Win32_Foundation")]
1417impl ::core::marker::Copy for WS_DURATION {}
1418#[cfg(feature = "Win32_Foundation")]
1419impl ::core::clone::Clone for WS_DURATION {
1420 fn clone(&self) -> Self {
1421 *self
1422 }
1423}
1424#[cfg(feature = "Win32_Foundation")]
1425pub type WS_DURATION_COMPARISON_CALLBACK = unsafe extern "system" fn(duration1: *const WS_DURATION, duration2: *const WS_DURATION, result: *mut i32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1426#[repr(C)]
1427#[cfg(feature = "Win32_Foundation")]
1428pub struct WS_DURATION_DESCRIPTION {
1429 pub minValue: WS_DURATION,
1430 pub maxValue: WS_DURATION,
1431 pub comparer: WS_DURATION_COMPARISON_CALLBACK,
1432}
1433#[cfg(feature = "Win32_Foundation")]
1434impl ::core::marker::Copy for WS_DURATION_DESCRIPTION {}
1435#[cfg(feature = "Win32_Foundation")]
1436impl ::core::clone::Clone for WS_DURATION_DESCRIPTION {
1437 fn clone(&self) -> Self {
1438 *self
1439 }
1440}
1441#[cfg(feature = "Win32_Foundation")]
1442pub type WS_DYNAMIC_STRING_CALLBACK = unsafe extern "system" fn(callbackstate: *const ::core::ffi::c_void, string: *const WS_XML_STRING, found: *mut super::super::Foundation::BOOL, id: *mut u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1443#[repr(C)]
1444#[cfg(feature = "Win32_Foundation")]
1445pub struct WS_ELEMENT_DESCRIPTION {
1446 pub elementLocalName: *mut WS_XML_STRING,
1447 pub elementNs: *mut WS_XML_STRING,
1448 pub r#type: WS_TYPE,
1449 pub typeDescription: *mut ::core::ffi::c_void,
1450}
1451#[cfg(feature = "Win32_Foundation")]
1452impl ::core::marker::Copy for WS_ELEMENT_DESCRIPTION {}
1453#[cfg(feature = "Win32_Foundation")]
1454impl ::core::clone::Clone for WS_ELEMENT_DESCRIPTION {
1455 fn clone(&self) -> Self {
1456 *self
1457 }
1458}
1459pub type WS_ENCODER_ENCODE_CALLBACK = unsafe extern "system" fn(encodercontext: *const ::core::ffi::c_void, buffers: *const WS_BYTES, count: u32, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1460pub type WS_ENCODER_END_CALLBACK = unsafe extern "system" fn(encodercontext: *const ::core::ffi::c_void, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1461#[cfg(feature = "Win32_Foundation")]
1462pub type WS_ENCODER_GET_CONTENT_TYPE_CALLBACK = unsafe extern "system" fn(encodercontext: *const ::core::ffi::c_void, contenttype: *const WS_STRING, newcontenttype: *mut WS_STRING, contentencoding: *mut WS_STRING, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1463pub type WS_ENCODER_START_CALLBACK = unsafe extern "system" fn(encodercontext: *const ::core::ffi::c_void, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1464pub type WS_ENCODING = i32;
1465pub const WS_ENCODING_XML_BINARY_1: WS_ENCODING = 0i32;
1466pub const WS_ENCODING_XML_BINARY_SESSION_1: WS_ENCODING = 1i32;
1467pub const WS_ENCODING_XML_MTOM_UTF8: WS_ENCODING = 2i32;
1468pub const WS_ENCODING_XML_MTOM_UTF16BE: WS_ENCODING = 3i32;
1469pub const WS_ENCODING_XML_MTOM_UTF16LE: WS_ENCODING = 4i32;
1470pub const WS_ENCODING_XML_UTF8: WS_ENCODING = 5i32;
1471pub const WS_ENCODING_XML_UTF16BE: WS_ENCODING = 6i32;
1472pub const WS_ENCODING_XML_UTF16LE: WS_ENCODING = 7i32;
1473pub const WS_ENCODING_RAW: WS_ENCODING = 8i32;
1474#[repr(C)]
1475#[cfg(feature = "Win32_Foundation")]
1476pub struct WS_ENDPOINT_ADDRESS {
1477 pub url: WS_STRING,
1478 pub headers: *mut WS_XML_BUFFER,
1479 pub extensions: *mut WS_XML_BUFFER,
1480 pub identity: *mut WS_ENDPOINT_IDENTITY,
1481}
1482#[cfg(feature = "Win32_Foundation")]
1483impl ::core::marker::Copy for WS_ENDPOINT_ADDRESS {}
1484#[cfg(feature = "Win32_Foundation")]
1485impl ::core::clone::Clone for WS_ENDPOINT_ADDRESS {
1486 fn clone(&self) -> Self {
1487 *self
1488 }
1489}
1490#[repr(C)]
1491pub struct WS_ENDPOINT_ADDRESS_DESCRIPTION {
1492 pub addressingVersion: WS_ADDRESSING_VERSION,
1493}
1494impl ::core::marker::Copy for WS_ENDPOINT_ADDRESS_DESCRIPTION {}
1495impl ::core::clone::Clone for WS_ENDPOINT_ADDRESS_DESCRIPTION {
1496 fn clone(&self) -> Self {
1497 *self
1498 }
1499}
1500pub type WS_ENDPOINT_ADDRESS_EXTENSION_TYPE = i32;
1501pub const WS_ENDPOINT_ADDRESS_EXTENSION_METADATA_ADDRESS: WS_ENDPOINT_ADDRESS_EXTENSION_TYPE = 1i32;
1502#[repr(C)]
1503pub struct WS_ENDPOINT_IDENTITY {
1504 pub identityType: WS_ENDPOINT_IDENTITY_TYPE,
1505}
1506impl ::core::marker::Copy for WS_ENDPOINT_IDENTITY {}
1507impl ::core::clone::Clone for WS_ENDPOINT_IDENTITY {
1508 fn clone(&self) -> Self {
1509 *self
1510 }
1511}
1512pub type WS_ENDPOINT_IDENTITY_TYPE = i32;
1513pub const WS_DNS_ENDPOINT_IDENTITY_TYPE: WS_ENDPOINT_IDENTITY_TYPE = 1i32;
1514pub const WS_UPN_ENDPOINT_IDENTITY_TYPE: WS_ENDPOINT_IDENTITY_TYPE = 2i32;
1515pub const WS_SPN_ENDPOINT_IDENTITY_TYPE: WS_ENDPOINT_IDENTITY_TYPE = 3i32;
1516pub const WS_RSA_ENDPOINT_IDENTITY_TYPE: WS_ENDPOINT_IDENTITY_TYPE = 4i32;
1517pub const WS_CERT_ENDPOINT_IDENTITY_TYPE: WS_ENDPOINT_IDENTITY_TYPE = 5i32;
1518pub const WS_UNKNOWN_ENDPOINT_IDENTITY_TYPE: WS_ENDPOINT_IDENTITY_TYPE = 6i32;
1519#[repr(C)]
1520#[cfg(feature = "Win32_Foundation")]
1521pub struct WS_ENDPOINT_POLICY_EXTENSION {
1522 pub policyExtension: WS_POLICY_EXTENSION,
1523 pub assertionName: *mut WS_XML_STRING,
1524 pub assertionNs: *mut WS_XML_STRING,
1525 pub out: WS_ENDPOINT_POLICY_EXTENSION_0,
1526}
1527#[cfg(feature = "Win32_Foundation")]
1528impl ::core::marker::Copy for WS_ENDPOINT_POLICY_EXTENSION {}
1529#[cfg(feature = "Win32_Foundation")]
1530impl ::core::clone::Clone for WS_ENDPOINT_POLICY_EXTENSION {
1531 fn clone(&self) -> Self {
1532 *self
1533 }
1534}
1535#[repr(C)]
1536#[cfg(feature = "Win32_Foundation")]
1537pub struct WS_ENDPOINT_POLICY_EXTENSION_0 {
1538 pub assertionValue: *mut WS_XML_BUFFER,
1539}
1540#[cfg(feature = "Win32_Foundation")]
1541impl ::core::marker::Copy for WS_ENDPOINT_POLICY_EXTENSION_0 {}
1542#[cfg(feature = "Win32_Foundation")]
1543impl ::core::clone::Clone for WS_ENDPOINT_POLICY_EXTENSION_0 {
1544 fn clone(&self) -> Self {
1545 *self
1546 }
1547}
1548#[repr(C)]
1549#[cfg(feature = "Win32_Foundation")]
1550pub struct WS_ENUM_DESCRIPTION {
1551 pub values: *mut WS_ENUM_VALUE,
1552 pub valueCount: u32,
1553 pub maxByteCount: u32,
1554 pub nameIndices: *mut u32,
1555}
1556#[cfg(feature = "Win32_Foundation")]
1557impl ::core::marker::Copy for WS_ENUM_DESCRIPTION {}
1558#[cfg(feature = "Win32_Foundation")]
1559impl ::core::clone::Clone for WS_ENUM_DESCRIPTION {
1560 fn clone(&self) -> Self {
1561 *self
1562 }
1563}
1564#[repr(C)]
1565#[cfg(feature = "Win32_Foundation")]
1566pub struct WS_ENUM_VALUE {
1567 pub value: i32,
1568 pub name: *mut WS_XML_STRING,
1569}
1570#[cfg(feature = "Win32_Foundation")]
1571impl ::core::marker::Copy for WS_ENUM_VALUE {}
1572#[cfg(feature = "Win32_Foundation")]
1573impl ::core::clone::Clone for WS_ENUM_VALUE {
1574 fn clone(&self) -> Self {
1575 *self
1576 }
1577}
1578pub type WS_ENVELOPE_VERSION = i32;
1579pub const WS_ENVELOPE_VERSION_SOAP_1_1: WS_ENVELOPE_VERSION = 1i32;
1580pub const WS_ENVELOPE_VERSION_SOAP_1_2: WS_ENVELOPE_VERSION = 2i32;
1581pub const WS_ENVELOPE_VERSION_NONE: WS_ENVELOPE_VERSION = 3i32;
1582#[repr(C)]
1583pub struct WS_ERROR(pub u8);
1584#[repr(C)]
1585pub struct WS_ERROR_PROPERTY {
1586 pub id: WS_ERROR_PROPERTY_ID,
1587 pub value: *mut ::core::ffi::c_void,
1588 pub valueSize: u32,
1589}
1590impl ::core::marker::Copy for WS_ERROR_PROPERTY {}
1591impl ::core::clone::Clone for WS_ERROR_PROPERTY {
1592 fn clone(&self) -> Self {
1593 *self
1594 }
1595}
1596pub type WS_ERROR_PROPERTY_ID = i32;
1597pub const WS_ERROR_PROPERTY_STRING_COUNT: WS_ERROR_PROPERTY_ID = 0i32;
1598pub const WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE: WS_ERROR_PROPERTY_ID = 1i32;
1599pub const WS_ERROR_PROPERTY_LANGID: WS_ERROR_PROPERTY_ID = 2i32;
1600pub type WS_EXCEPTION_CODE = i32;
1601pub const WS_EXCEPTION_CODE_USAGE_FAILURE: WS_EXCEPTION_CODE = -1069744128i32;
1602pub const WS_EXCEPTION_CODE_INTERNAL_FAILURE: WS_EXCEPTION_CODE = -1069744127i32;
1603pub type WS_EXTENDED_PROTECTION_POLICY = i32;
1604pub const WS_EXTENDED_PROTECTION_POLICY_NEVER: WS_EXTENDED_PROTECTION_POLICY = 1i32;
1605pub const WS_EXTENDED_PROTECTION_POLICY_WHEN_SUPPORTED: WS_EXTENDED_PROTECTION_POLICY = 2i32;
1606pub const WS_EXTENDED_PROTECTION_POLICY_ALWAYS: WS_EXTENDED_PROTECTION_POLICY = 3i32;
1607pub type WS_EXTENDED_PROTECTION_SCENARIO = i32;
1608pub const WS_EXTENDED_PROTECTION_SCENARIO_BOUND_SERVER: WS_EXTENDED_PROTECTION_SCENARIO = 1i32;
1609pub const WS_EXTENDED_PROTECTION_SCENARIO_TERMINATED_SSL: WS_EXTENDED_PROTECTION_SCENARIO = 2i32;
1610#[repr(C)]
1611#[cfg(feature = "Win32_Foundation")]
1612pub struct WS_FAULT {
1613 pub code: *mut WS_FAULT_CODE,
1614 pub reasons: *mut WS_FAULT_REASON,
1615 pub reasonCount: u32,
1616 pub actor: WS_STRING,
1617 pub node: WS_STRING,
1618 pub detail: *mut WS_XML_BUFFER,
1619}
1620#[cfg(feature = "Win32_Foundation")]
1621impl ::core::marker::Copy for WS_FAULT {}
1622#[cfg(feature = "Win32_Foundation")]
1623impl ::core::clone::Clone for WS_FAULT {
1624 fn clone(&self) -> Self {
1625 *self
1626 }
1627}
1628#[repr(C)]
1629#[cfg(feature = "Win32_Foundation")]
1630pub struct WS_FAULT_CODE {
1631 pub value: WS_XML_QNAME,
1632 pub subCode: *mut WS_FAULT_CODE,
1633}
1634#[cfg(feature = "Win32_Foundation")]
1635impl ::core::marker::Copy for WS_FAULT_CODE {}
1636#[cfg(feature = "Win32_Foundation")]
1637impl ::core::clone::Clone for WS_FAULT_CODE {
1638 fn clone(&self) -> Self {
1639 *self
1640 }
1641}
1642#[repr(C)]
1643pub struct WS_FAULT_DESCRIPTION {
1644 pub envelopeVersion: WS_ENVELOPE_VERSION,
1645}
1646impl ::core::marker::Copy for WS_FAULT_DESCRIPTION {}
1647impl ::core::clone::Clone for WS_FAULT_DESCRIPTION {
1648 fn clone(&self) -> Self {
1649 *self
1650 }
1651}
1652#[repr(C)]
1653#[cfg(feature = "Win32_Foundation")]
1654pub struct WS_FAULT_DETAIL_DESCRIPTION {
1655 pub action: *mut WS_XML_STRING,
1656 pub detailElementDescription: *mut WS_ELEMENT_DESCRIPTION,
1657}
1658#[cfg(feature = "Win32_Foundation")]
1659impl ::core::marker::Copy for WS_FAULT_DETAIL_DESCRIPTION {}
1660#[cfg(feature = "Win32_Foundation")]
1661impl ::core::clone::Clone for WS_FAULT_DETAIL_DESCRIPTION {
1662 fn clone(&self) -> Self {
1663 *self
1664 }
1665}
1666pub type WS_FAULT_DISCLOSURE = i32;
1667pub const WS_MINIMAL_FAULT_DISCLOSURE: WS_FAULT_DISCLOSURE = 0i32;
1668pub const WS_FULL_FAULT_DISCLOSURE: WS_FAULT_DISCLOSURE = 1i32;
1669pub type WS_FAULT_ERROR_PROPERTY_ID = i32;
1670pub const WS_FAULT_ERROR_PROPERTY_FAULT: WS_FAULT_ERROR_PROPERTY_ID = 0i32;
1671pub const WS_FAULT_ERROR_PROPERTY_ACTION: WS_FAULT_ERROR_PROPERTY_ID = 1i32;
1672pub const WS_FAULT_ERROR_PROPERTY_HEADER: WS_FAULT_ERROR_PROPERTY_ID = 2i32;
1673#[repr(C)]
1674#[cfg(feature = "Win32_Foundation")]
1675pub struct WS_FAULT_REASON {
1676 pub text: WS_STRING,
1677 pub lang: WS_STRING,
1678}
1679#[cfg(feature = "Win32_Foundation")]
1680impl ::core::marker::Copy for WS_FAULT_REASON {}
1681#[cfg(feature = "Win32_Foundation")]
1682impl ::core::clone::Clone for WS_FAULT_REASON {
1683 fn clone(&self) -> Self {
1684 *self
1685 }
1686}
1687#[repr(C)]
1688#[cfg(feature = "Win32_Foundation")]
1689pub struct WS_FIELD_DESCRIPTION {
1690 pub mapping: WS_FIELD_MAPPING,
1691 pub localName: *mut WS_XML_STRING,
1692 pub ns: *mut WS_XML_STRING,
1693 pub r#type: WS_TYPE,
1694 pub typeDescription: *mut ::core::ffi::c_void,
1695 pub offset: u32,
1696 pub options: u32,
1697 pub defaultValue: *mut WS_DEFAULT_VALUE,
1698 pub countOffset: u32,
1699 pub itemLocalName: *mut WS_XML_STRING,
1700 pub itemNs: *mut WS_XML_STRING,
1701 pub itemRange: *mut WS_ITEM_RANGE,
1702}
1703#[cfg(feature = "Win32_Foundation")]
1704impl ::core::marker::Copy for WS_FIELD_DESCRIPTION {}
1705#[cfg(feature = "Win32_Foundation")]
1706impl ::core::clone::Clone for WS_FIELD_DESCRIPTION {
1707 fn clone(&self) -> Self {
1708 *self
1709 }
1710}
1711pub type WS_FIELD_MAPPING = i32;
1712pub const WS_TYPE_ATTRIBUTE_FIELD_MAPPING: WS_FIELD_MAPPING = 0i32;
1713pub const WS_ATTRIBUTE_FIELD_MAPPING: WS_FIELD_MAPPING = 1i32;
1714pub const WS_ELEMENT_FIELD_MAPPING: WS_FIELD_MAPPING = 2i32;
1715pub const WS_REPEATING_ELEMENT_FIELD_MAPPING: WS_FIELD_MAPPING = 3i32;
1716pub const WS_TEXT_FIELD_MAPPING: WS_FIELD_MAPPING = 4i32;
1717pub const WS_NO_FIELD_MAPPING: WS_FIELD_MAPPING = 5i32;
1718pub const WS_XML_ATTRIBUTE_FIELD_MAPPING: WS_FIELD_MAPPING = 6i32;
1719pub const WS_ELEMENT_CHOICE_FIELD_MAPPING: WS_FIELD_MAPPING = 7i32;
1720pub const WS_REPEATING_ELEMENT_CHOICE_FIELD_MAPPING: WS_FIELD_MAPPING = 8i32;
1721pub const WS_ANY_ELEMENT_FIELD_MAPPING: WS_FIELD_MAPPING = 9i32;
1722pub const WS_REPEATING_ANY_ELEMENT_FIELD_MAPPING: WS_FIELD_MAPPING = 10i32;
1723pub const WS_ANY_CONTENT_FIELD_MAPPING: WS_FIELD_MAPPING = 11i32;
1724pub const WS_ANY_ATTRIBUTES_FIELD_MAPPING: WS_FIELD_MAPPING = 12i32;
1725pub const WS_FIELD_NILLABLE: i32 = 4i32;
1726pub const WS_FIELD_NILLABLE_ITEM: i32 = 8i32;
1727pub const WS_FIELD_OPTIONAL: i32 = 2i32;
1728pub const WS_FIELD_OTHER_NAMESPACE: i32 = 16i32;
1729pub const WS_FIELD_POINTER: i32 = 1i32;
1730#[repr(C)]
1731pub struct WS_FLOAT_DESCRIPTION {
1732 pub minValue: f32,
1733 pub maxValue: f32,
1734}
1735impl ::core::marker::Copy for WS_FLOAT_DESCRIPTION {}
1736impl ::core::clone::Clone for WS_FLOAT_DESCRIPTION {
1737 fn clone(&self) -> Self {
1738 *self
1739 }
1740}
1741pub type WS_FREE_CHANNEL_CALLBACK = unsafe extern "system" fn(channelinstance: *const ::core::ffi::c_void);
1742pub type WS_FREE_DECODER_CALLBACK = unsafe extern "system" fn(decodercontext: *const ::core::ffi::c_void);
1743pub type WS_FREE_ENCODER_CALLBACK = unsafe extern "system" fn(encodercontext: *const ::core::ffi::c_void);
1744pub type WS_FREE_LISTENER_CALLBACK = unsafe extern "system" fn(listenerinstance: *const ::core::ffi::c_void);
1745#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1746pub type WS_GET_CERT_CALLBACK = unsafe extern "system" fn(getcertcallbackstate: *const ::core::ffi::c_void, targetaddress: *const WS_ENDPOINT_ADDRESS, viauri: *const WS_STRING, cert: *mut *mut super::super::Security::Cryptography::CERT_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1747pub type WS_GET_CHANNEL_PROPERTY_CALLBACK = unsafe extern "system" fn(channelinstance: *const ::core::ffi::c_void, id: WS_CHANNEL_PROPERTY_ID, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1748pub type WS_GET_LISTENER_PROPERTY_CALLBACK = unsafe extern "system" fn(listenerinstance: *const ::core::ffi::c_void, id: WS_LISTENER_PROPERTY_ID, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
1749#[repr(C)]
1750pub struct WS_GUID_DESCRIPTION {
1751 pub value: ::windows_sys::core::GUID,
1752}
1753impl ::core::marker::Copy for WS_GUID_DESCRIPTION {}
1754impl ::core::clone::Clone for WS_GUID_DESCRIPTION {
1755 fn clone(&self) -> Self {
1756 *self
1757 }
1758}
1759pub type WS_HEADER_TYPE = i32;
1760pub const WS_ACTION_HEADER: WS_HEADER_TYPE = 1i32;
1761pub const WS_TO_HEADER: WS_HEADER_TYPE = 2i32;
1762pub const WS_MESSAGE_ID_HEADER: WS_HEADER_TYPE = 3i32;
1763pub const WS_RELATES_TO_HEADER: WS_HEADER_TYPE = 4i32;
1764pub const WS_FROM_HEADER: WS_HEADER_TYPE = 5i32;
1765pub const WS_REPLY_TO_HEADER: WS_HEADER_TYPE = 6i32;
1766pub const WS_FAULT_TO_HEADER: WS_HEADER_TYPE = 7i32;
1767#[repr(C)]
1768pub struct WS_HEAP(pub u8);
1769#[repr(C)]
1770pub struct WS_HEAP_PROPERTIES {
1771 pub properties: *mut WS_HEAP_PROPERTY,
1772 pub propertyCount: u32,
1773}
1774impl ::core::marker::Copy for WS_HEAP_PROPERTIES {}
1775impl ::core::clone::Clone for WS_HEAP_PROPERTIES {
1776 fn clone(&self) -> Self {
1777 *self
1778 }
1779}
1780#[repr(C)]
1781pub struct WS_HEAP_PROPERTY {
1782 pub id: WS_HEAP_PROPERTY_ID,
1783 pub value: *mut ::core::ffi::c_void,
1784 pub valueSize: u32,
1785}
1786impl ::core::marker::Copy for WS_HEAP_PROPERTY {}
1787impl ::core::clone::Clone for WS_HEAP_PROPERTY {
1788 fn clone(&self) -> Self {
1789 *self
1790 }
1791}
1792pub type WS_HEAP_PROPERTY_ID = i32;
1793pub const WS_HEAP_PROPERTY_MAX_SIZE: WS_HEAP_PROPERTY_ID = 0i32;
1794pub const WS_HEAP_PROPERTY_TRIM_SIZE: WS_HEAP_PROPERTY_ID = 1i32;
1795pub const WS_HEAP_PROPERTY_REQUESTED_SIZE: WS_HEAP_PROPERTY_ID = 2i32;
1796pub const WS_HEAP_PROPERTY_ACTUAL_SIZE: WS_HEAP_PROPERTY_ID = 3i32;
1797#[repr(C)]
1798#[cfg(feature = "Win32_Foundation")]
1799pub struct WS_HOST_NAMES {
1800 pub hostNames: *mut WS_STRING,
1801 pub hostNameCount: u32,
1802}
1803#[cfg(feature = "Win32_Foundation")]
1804impl ::core::marker::Copy for WS_HOST_NAMES {}
1805#[cfg(feature = "Win32_Foundation")]
1806impl ::core::clone::Clone for WS_HOST_NAMES {
1807 fn clone(&self) -> Self {
1808 *self
1809 }
1810}
1811#[repr(C)]
1812#[cfg(feature = "Win32_Foundation")]
1813pub struct WS_HTTPS_URL {
1814 pub url: WS_URL,
1815 pub host: WS_STRING,
1816 pub port: u16,
1817 pub portAsString: WS_STRING,
1818 pub path: WS_STRING,
1819 pub query: WS_STRING,
1820 pub fragment: WS_STRING,
1821}
1822#[cfg(feature = "Win32_Foundation")]
1823impl ::core::marker::Copy for WS_HTTPS_URL {}
1824#[cfg(feature = "Win32_Foundation")]
1825impl ::core::clone::Clone for WS_HTTPS_URL {
1826 fn clone(&self) -> Self {
1827 *self
1828 }
1829}
1830#[repr(C)]
1831pub struct WS_HTTP_BINDING_TEMPLATE {
1832 pub channelProperties: WS_CHANNEL_PROPERTIES,
1833}
1834impl ::core::marker::Copy for WS_HTTP_BINDING_TEMPLATE {}
1835impl ::core::clone::Clone for WS_HTTP_BINDING_TEMPLATE {
1836 fn clone(&self) -> Self {
1837 *self
1838 }
1839}
1840#[repr(C)]
1841pub struct WS_HTTP_HEADER_AUTH_BINDING_TEMPLATE {
1842 pub channelProperties: WS_CHANNEL_PROPERTIES,
1843 pub securityProperties: WS_SECURITY_PROPERTIES,
1844 pub httpHeaderAuthSecurityBinding: WS_HTTP_HEADER_AUTH_SECURITY_BINDING_TEMPLATE,
1845}
1846impl ::core::marker::Copy for WS_HTTP_HEADER_AUTH_BINDING_TEMPLATE {}
1847impl ::core::clone::Clone for WS_HTTP_HEADER_AUTH_BINDING_TEMPLATE {
1848 fn clone(&self) -> Self {
1849 *self
1850 }
1851}
1852#[repr(C)]
1853pub struct WS_HTTP_HEADER_AUTH_POLICY_DESCRIPTION {
1854 pub channelProperties: WS_CHANNEL_PROPERTIES,
1855 pub securityProperties: WS_SECURITY_PROPERTIES,
1856 pub httpHeaderAuthSecurityBinding: WS_HTTP_HEADER_AUTH_SECURITY_BINDING_POLICY_DESCRIPTION,
1857}
1858impl ::core::marker::Copy for WS_HTTP_HEADER_AUTH_POLICY_DESCRIPTION {}
1859impl ::core::clone::Clone for WS_HTTP_HEADER_AUTH_POLICY_DESCRIPTION {
1860 fn clone(&self) -> Self {
1861 *self
1862 }
1863}
1864pub const WS_HTTP_HEADER_AUTH_SCHEME_BASIC: i32 = 2i32;
1865pub const WS_HTTP_HEADER_AUTH_SCHEME_DIGEST: i32 = 4i32;
1866pub const WS_HTTP_HEADER_AUTH_SCHEME_NEGOTIATE: i32 = 16i32;
1867pub const WS_HTTP_HEADER_AUTH_SCHEME_NONE: i32 = 1i32;
1868pub const WS_HTTP_HEADER_AUTH_SCHEME_NTLM: i32 = 8i32;
1869pub const WS_HTTP_HEADER_AUTH_SCHEME_PASSPORT: i32 = 32i32;
1870#[repr(C)]
1871pub struct WS_HTTP_HEADER_AUTH_SECURITY_BINDING {
1872 pub binding: WS_SECURITY_BINDING,
1873 pub clientCredential: *mut WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
1874}
1875impl ::core::marker::Copy for WS_HTTP_HEADER_AUTH_SECURITY_BINDING {}
1876impl ::core::clone::Clone for WS_HTTP_HEADER_AUTH_SECURITY_BINDING {
1877 fn clone(&self) -> Self {
1878 *self
1879 }
1880}
1881#[repr(C)]
1882pub struct WS_HTTP_HEADER_AUTH_SECURITY_BINDING_CONSTRAINT {
1883 pub bindingConstraint: WS_SECURITY_BINDING_CONSTRAINT,
1884}
1885impl ::core::marker::Copy for WS_HTTP_HEADER_AUTH_SECURITY_BINDING_CONSTRAINT {}
1886impl ::core::clone::Clone for WS_HTTP_HEADER_AUTH_SECURITY_BINDING_CONSTRAINT {
1887 fn clone(&self) -> Self {
1888 *self
1889 }
1890}
1891#[repr(C)]
1892pub struct WS_HTTP_HEADER_AUTH_SECURITY_BINDING_POLICY_DESCRIPTION {
1893 pub securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
1894}
1895impl ::core::marker::Copy for WS_HTTP_HEADER_AUTH_SECURITY_BINDING_POLICY_DESCRIPTION {}
1896impl ::core::clone::Clone for WS_HTTP_HEADER_AUTH_SECURITY_BINDING_POLICY_DESCRIPTION {
1897 fn clone(&self) -> Self {
1898 *self
1899 }
1900}
1901#[repr(C)]
1902pub struct WS_HTTP_HEADER_AUTH_SECURITY_BINDING_TEMPLATE {
1903 pub securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
1904 pub clientCredential: *mut WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
1905}
1906impl ::core::marker::Copy for WS_HTTP_HEADER_AUTH_SECURITY_BINDING_TEMPLATE {}
1907impl ::core::clone::Clone for WS_HTTP_HEADER_AUTH_SECURITY_BINDING_TEMPLATE {
1908 fn clone(&self) -> Self {
1909 *self
1910 }
1911}
1912pub type WS_HTTP_HEADER_AUTH_TARGET = i32;
1913pub const WS_HTTP_HEADER_AUTH_TARGET_SERVICE: WS_HTTP_HEADER_AUTH_TARGET = 1i32;
1914pub const WS_HTTP_HEADER_AUTH_TARGET_PROXY: WS_HTTP_HEADER_AUTH_TARGET = 2i32;
1915#[repr(C)]
1916#[cfg(feature = "Win32_Foundation")]
1917pub struct WS_HTTP_HEADER_MAPPING {
1918 pub headerName: WS_XML_STRING,
1919 pub headerMappingOptions: u32,
1920}
1921#[cfg(feature = "Win32_Foundation")]
1922impl ::core::marker::Copy for WS_HTTP_HEADER_MAPPING {}
1923#[cfg(feature = "Win32_Foundation")]
1924impl ::core::clone::Clone for WS_HTTP_HEADER_MAPPING {
1925 fn clone(&self) -> Self {
1926 *self
1927 }
1928}
1929pub const WS_HTTP_HEADER_MAPPING_COMMA_SEPARATOR: i32 = 1i32;
1930pub const WS_HTTP_HEADER_MAPPING_QUOTED_VALUE: i32 = 4i32;
1931pub const WS_HTTP_HEADER_MAPPING_SEMICOLON_SEPARATOR: i32 = 2i32;
1932#[repr(C)]
1933#[cfg(feature = "Win32_Foundation")]
1934pub struct WS_HTTP_MESSAGE_MAPPING {
1935 pub requestMappingOptions: u32,
1936 pub responseMappingOptions: u32,
1937 pub requestHeaderMappings: *mut *mut WS_HTTP_HEADER_MAPPING,
1938 pub requestHeaderMappingCount: u32,
1939 pub responseHeaderMappings: *mut *mut WS_HTTP_HEADER_MAPPING,
1940 pub responseHeaderMappingCount: u32,
1941}
1942#[cfg(feature = "Win32_Foundation")]
1943impl ::core::marker::Copy for WS_HTTP_MESSAGE_MAPPING {}
1944#[cfg(feature = "Win32_Foundation")]
1945impl ::core::clone::Clone for WS_HTTP_MESSAGE_MAPPING {
1946 fn clone(&self) -> Self {
1947 *self
1948 }
1949}
1950#[repr(C)]
1951pub struct WS_HTTP_POLICY_DESCRIPTION {
1952 pub channelProperties: WS_CHANNEL_PROPERTIES,
1953}
1954impl ::core::marker::Copy for WS_HTTP_POLICY_DESCRIPTION {}
1955impl ::core::clone::Clone for WS_HTTP_POLICY_DESCRIPTION {
1956 fn clone(&self) -> Self {
1957 *self
1958 }
1959}
1960pub type WS_HTTP_PROXY_SETTING_MODE = i32;
1961pub const WS_HTTP_PROXY_SETTING_MODE_AUTO: WS_HTTP_PROXY_SETTING_MODE = 1i32;
1962pub const WS_HTTP_PROXY_SETTING_MODE_NONE: WS_HTTP_PROXY_SETTING_MODE = 2i32;
1963pub const WS_HTTP_PROXY_SETTING_MODE_CUSTOM: WS_HTTP_PROXY_SETTING_MODE = 3i32;
1964#[cfg(feature = "Win32_Foundation")]
1965pub type WS_HTTP_REDIRECT_CALLBACK = unsafe extern "system" fn(state: *const ::core::ffi::c_void, originalurl: *const WS_STRING, newurl: *const WS_STRING) -> ::windows_sys::core::HRESULT;
1966#[repr(C)]
1967#[cfg(feature = "Win32_Foundation")]
1968pub struct WS_HTTP_REDIRECT_CALLBACK_CONTEXT {
1969 pub callback: WS_HTTP_REDIRECT_CALLBACK,
1970 pub state: *mut ::core::ffi::c_void,
1971}
1972#[cfg(feature = "Win32_Foundation")]
1973impl ::core::marker::Copy for WS_HTTP_REDIRECT_CALLBACK_CONTEXT {}
1974#[cfg(feature = "Win32_Foundation")]
1975impl ::core::clone::Clone for WS_HTTP_REDIRECT_CALLBACK_CONTEXT {
1976 fn clone(&self) -> Self {
1977 *self
1978 }
1979}
1980pub const WS_HTTP_REQUEST_MAPPING_VERB: i32 = 2i32;
1981pub const WS_HTTP_RESPONSE_MAPPING_STATUS_CODE: i32 = 1i32;
1982pub const WS_HTTP_RESPONSE_MAPPING_STATUS_TEXT: i32 = 2i32;
1983#[repr(C)]
1984pub struct WS_HTTP_SSL_BINDING_TEMPLATE {
1985 pub channelProperties: WS_CHANNEL_PROPERTIES,
1986 pub securityProperties: WS_SECURITY_PROPERTIES,
1987 pub sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE,
1988}
1989impl ::core::marker::Copy for WS_HTTP_SSL_BINDING_TEMPLATE {}
1990impl ::core::clone::Clone for WS_HTTP_SSL_BINDING_TEMPLATE {
1991 fn clone(&self) -> Self {
1992 *self
1993 }
1994}
1995#[repr(C)]
1996pub struct WS_HTTP_SSL_HEADER_AUTH_BINDING_TEMPLATE {
1997 pub channelProperties: WS_CHANNEL_PROPERTIES,
1998 pub securityProperties: WS_SECURITY_PROPERTIES,
1999 pub sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE,
2000 pub httpHeaderAuthSecurityBinding: WS_HTTP_HEADER_AUTH_SECURITY_BINDING_TEMPLATE,
2001}
2002impl ::core::marker::Copy for WS_HTTP_SSL_HEADER_AUTH_BINDING_TEMPLATE {}
2003impl ::core::clone::Clone for WS_HTTP_SSL_HEADER_AUTH_BINDING_TEMPLATE {
2004 fn clone(&self) -> Self {
2005 *self
2006 }
2007}
2008#[repr(C)]
2009pub struct WS_HTTP_SSL_HEADER_AUTH_POLICY_DESCRIPTION {
2010 pub channelProperties: WS_CHANNEL_PROPERTIES,
2011 pub securityProperties: WS_SECURITY_PROPERTIES,
2012 pub sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
2013 pub httpHeaderAuthSecurityBinding: WS_HTTP_HEADER_AUTH_SECURITY_BINDING_POLICY_DESCRIPTION,
2014}
2015impl ::core::marker::Copy for WS_HTTP_SSL_HEADER_AUTH_POLICY_DESCRIPTION {}
2016impl ::core::clone::Clone for WS_HTTP_SSL_HEADER_AUTH_POLICY_DESCRIPTION {
2017 fn clone(&self) -> Self {
2018 *self
2019 }
2020}
2021#[repr(C)]
2022pub struct WS_HTTP_SSL_KERBEROS_APREQ_BINDING_TEMPLATE {
2023 pub channelProperties: WS_CHANNEL_PROPERTIES,
2024 pub securityProperties: WS_SECURITY_PROPERTIES,
2025 pub sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE,
2026 pub kerberosApreqMessageSecurityBinding: WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TEMPLATE,
2027}
2028impl ::core::marker::Copy for WS_HTTP_SSL_KERBEROS_APREQ_BINDING_TEMPLATE {}
2029impl ::core::clone::Clone for WS_HTTP_SSL_KERBEROS_APREQ_BINDING_TEMPLATE {
2030 fn clone(&self) -> Self {
2031 *self
2032 }
2033}
2034#[repr(C)]
2035pub struct WS_HTTP_SSL_KERBEROS_APREQ_POLICY_DESCRIPTION {
2036 pub channelProperties: WS_CHANNEL_PROPERTIES,
2037 pub securityProperties: WS_SECURITY_PROPERTIES,
2038 pub sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
2039 pub kerberosApreqMessageSecurityBinding: WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION,
2040}
2041impl ::core::marker::Copy for WS_HTTP_SSL_KERBEROS_APREQ_POLICY_DESCRIPTION {}
2042impl ::core::clone::Clone for WS_HTTP_SSL_KERBEROS_APREQ_POLICY_DESCRIPTION {
2043 fn clone(&self) -> Self {
2044 *self
2045 }
2046}
2047#[repr(C)]
2048pub struct WS_HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE {
2049 pub channelProperties: WS_CHANNEL_PROPERTIES,
2050 pub securityProperties: WS_SECURITY_PROPERTIES,
2051 pub sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE,
2052 pub kerberosApreqMessageSecurityBinding: WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TEMPLATE,
2053 pub securityContextSecurityBinding: WS_SECURITY_CONTEXT_SECURITY_BINDING_TEMPLATE,
2054}
2055impl ::core::marker::Copy for WS_HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE {}
2056impl ::core::clone::Clone for WS_HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE {
2057 fn clone(&self) -> Self {
2058 *self
2059 }
2060}
2061#[repr(C)]
2062pub struct WS_HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_POLICY_DESCRIPTION {
2063 pub channelProperties: WS_CHANNEL_PROPERTIES,
2064 pub securityProperties: WS_SECURITY_PROPERTIES,
2065 pub sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
2066 pub kerberosApreqMessageSecurityBinding: WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION,
2067 pub securityContextSecurityBinding: WS_SECURITY_CONTEXT_SECURITY_BINDING_POLICY_DESCRIPTION,
2068}
2069impl ::core::marker::Copy for WS_HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_POLICY_DESCRIPTION {}
2070impl ::core::clone::Clone for WS_HTTP_SSL_KERBEROS_APREQ_SECURITY_CONTEXT_POLICY_DESCRIPTION {
2071 fn clone(&self) -> Self {
2072 *self
2073 }
2074}
2075#[repr(C)]
2076pub struct WS_HTTP_SSL_POLICY_DESCRIPTION {
2077 pub channelProperties: WS_CHANNEL_PROPERTIES,
2078 pub securityProperties: WS_SECURITY_PROPERTIES,
2079 pub sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
2080}
2081impl ::core::marker::Copy for WS_HTTP_SSL_POLICY_DESCRIPTION {}
2082impl ::core::clone::Clone for WS_HTTP_SSL_POLICY_DESCRIPTION {
2083 fn clone(&self) -> Self {
2084 *self
2085 }
2086}
2087#[repr(C)]
2088#[cfg(feature = "Win32_Foundation")]
2089pub struct WS_HTTP_SSL_USERNAME_BINDING_TEMPLATE {
2090 pub channelProperties: WS_CHANNEL_PROPERTIES,
2091 pub securityProperties: WS_SECURITY_PROPERTIES,
2092 pub sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE,
2093 pub usernameMessageSecurityBinding: WS_USERNAME_MESSAGE_SECURITY_BINDING_TEMPLATE,
2094}
2095#[cfg(feature = "Win32_Foundation")]
2096impl ::core::marker::Copy for WS_HTTP_SSL_USERNAME_BINDING_TEMPLATE {}
2097#[cfg(feature = "Win32_Foundation")]
2098impl ::core::clone::Clone for WS_HTTP_SSL_USERNAME_BINDING_TEMPLATE {
2099 fn clone(&self) -> Self {
2100 *self
2101 }
2102}
2103#[repr(C)]
2104pub struct WS_HTTP_SSL_USERNAME_POLICY_DESCRIPTION {
2105 pub channelProperties: WS_CHANNEL_PROPERTIES,
2106 pub securityProperties: WS_SECURITY_PROPERTIES,
2107 pub sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
2108 pub usernameMessageSecurityBinding: WS_USERNAME_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION,
2109}
2110impl ::core::marker::Copy for WS_HTTP_SSL_USERNAME_POLICY_DESCRIPTION {}
2111impl ::core::clone::Clone for WS_HTTP_SSL_USERNAME_POLICY_DESCRIPTION {
2112 fn clone(&self) -> Self {
2113 *self
2114 }
2115}
2116#[repr(C)]
2117#[cfg(feature = "Win32_Foundation")]
2118pub struct WS_HTTP_SSL_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE {
2119 pub channelProperties: WS_CHANNEL_PROPERTIES,
2120 pub securityProperties: WS_SECURITY_PROPERTIES,
2121 pub sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE,
2122 pub usernameMessageSecurityBinding: WS_USERNAME_MESSAGE_SECURITY_BINDING_TEMPLATE,
2123 pub securityContextSecurityBinding: WS_SECURITY_CONTEXT_SECURITY_BINDING_TEMPLATE,
2124}
2125#[cfg(feature = "Win32_Foundation")]
2126impl ::core::marker::Copy for WS_HTTP_SSL_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE {}
2127#[cfg(feature = "Win32_Foundation")]
2128impl ::core::clone::Clone for WS_HTTP_SSL_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE {
2129 fn clone(&self) -> Self {
2130 *self
2131 }
2132}
2133#[repr(C)]
2134pub struct WS_HTTP_SSL_USERNAME_SECURITY_CONTEXT_POLICY_DESCRIPTION {
2135 pub channelProperties: WS_CHANNEL_PROPERTIES,
2136 pub securityProperties: WS_SECURITY_PROPERTIES,
2137 pub sslTransportSecurityBinding: WS_SSL_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
2138 pub usernameMessageSecurityBinding: WS_USERNAME_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION,
2139 pub securityContextSecurityBinding: WS_SECURITY_CONTEXT_SECURITY_BINDING_POLICY_DESCRIPTION,
2140}
2141impl ::core::marker::Copy for WS_HTTP_SSL_USERNAME_SECURITY_CONTEXT_POLICY_DESCRIPTION {}
2142impl ::core::clone::Clone for WS_HTTP_SSL_USERNAME_SECURITY_CONTEXT_POLICY_DESCRIPTION {
2143 fn clone(&self) -> Self {
2144 *self
2145 }
2146}
2147#[repr(C)]
2148#[cfg(feature = "Win32_Foundation")]
2149pub struct WS_HTTP_URL {
2150 pub url: WS_URL,
2151 pub host: WS_STRING,
2152 pub port: u16,
2153 pub portAsString: WS_STRING,
2154 pub path: WS_STRING,
2155 pub query: WS_STRING,
2156 pub fragment: WS_STRING,
2157}
2158#[cfg(feature = "Win32_Foundation")]
2159impl ::core::marker::Copy for WS_HTTP_URL {}
2160#[cfg(feature = "Win32_Foundation")]
2161impl ::core::clone::Clone for WS_HTTP_URL {
2162 fn clone(&self) -> Self {
2163 *self
2164 }
2165}
2166#[repr(C)]
2167pub struct WS_INT16_DESCRIPTION {
2168 pub minValue: i16,
2169 pub maxValue: i16,
2170}
2171impl ::core::marker::Copy for WS_INT16_DESCRIPTION {}
2172impl ::core::clone::Clone for WS_INT16_DESCRIPTION {
2173 fn clone(&self) -> Self {
2174 *self
2175 }
2176}
2177#[repr(C)]
2178pub struct WS_INT32_DESCRIPTION {
2179 pub minValue: i32,
2180 pub maxValue: i32,
2181}
2182impl ::core::marker::Copy for WS_INT32_DESCRIPTION {}
2183impl ::core::clone::Clone for WS_INT32_DESCRIPTION {
2184 fn clone(&self) -> Self {
2185 *self
2186 }
2187}
2188#[repr(C)]
2189pub struct WS_INT64_DESCRIPTION {
2190 pub minValue: i64,
2191 pub maxValue: i64,
2192}
2193impl ::core::marker::Copy for WS_INT64_DESCRIPTION {}
2194impl ::core::clone::Clone for WS_INT64_DESCRIPTION {
2195 fn clone(&self) -> Self {
2196 *self
2197 }
2198}
2199#[repr(C)]
2200#[cfg(feature = "Win32_Foundation")]
2201pub struct WS_INT8_DESCRIPTION {
2202 pub minValue: super::super::Foundation::CHAR,
2203 pub maxValue: super::super::Foundation::CHAR,
2204}
2205#[cfg(feature = "Win32_Foundation")]
2206impl ::core::marker::Copy for WS_INT8_DESCRIPTION {}
2207#[cfg(feature = "Win32_Foundation")]
2208impl ::core::clone::Clone for WS_INT8_DESCRIPTION {
2209 fn clone(&self) -> Self {
2210 *self
2211 }
2212}
2213pub type WS_IP_VERSION = i32;
2214pub const WS_IP_VERSION_4: WS_IP_VERSION = 1i32;
2215pub const WS_IP_VERSION_6: WS_IP_VERSION = 2i32;
2216pub const WS_IP_VERSION_AUTO: WS_IP_VERSION = 3i32;
2217#[repr(C)]
2218#[cfg(feature = "Win32_Foundation")]
2219pub struct WS_ISSUED_TOKEN_MESSAGE_SECURITY_BINDING_CONSTRAINT {
2220 pub bindingConstraint: WS_SECURITY_BINDING_CONSTRAINT,
2221 pub bindingUsage: WS_MESSAGE_SECURITY_USAGE,
2222 pub claimConstraints: *mut WS_XML_STRING,
2223 pub claimConstraintCount: u32,
2224 pub requestSecurityTokenPropertyConstraints: *mut WS_REQUEST_SECURITY_TOKEN_PROPERTY_CONSTRAINT,
2225 pub requestSecurityTokenPropertyConstraintCount: u32,
2226 pub out: WS_ISSUED_TOKEN_MESSAGE_SECURITY_BINDING_CONSTRAINT_0,
2227}
2228#[cfg(feature = "Win32_Foundation")]
2229impl ::core::marker::Copy for WS_ISSUED_TOKEN_MESSAGE_SECURITY_BINDING_CONSTRAINT {}
2230#[cfg(feature = "Win32_Foundation")]
2231impl ::core::clone::Clone for WS_ISSUED_TOKEN_MESSAGE_SECURITY_BINDING_CONSTRAINT {
2232 fn clone(&self) -> Self {
2233 *self
2234 }
2235}
2236#[repr(C)]
2237#[cfg(feature = "Win32_Foundation")]
2238pub struct WS_ISSUED_TOKEN_MESSAGE_SECURITY_BINDING_CONSTRAINT_0 {
2239 pub issuerAddress: *mut WS_ENDPOINT_ADDRESS,
2240 pub requestSecurityTokenTemplate: *mut WS_XML_BUFFER,
2241}
2242#[cfg(feature = "Win32_Foundation")]
2243impl ::core::marker::Copy for WS_ISSUED_TOKEN_MESSAGE_SECURITY_BINDING_CONSTRAINT_0 {}
2244#[cfg(feature = "Win32_Foundation")]
2245impl ::core::clone::Clone for WS_ISSUED_TOKEN_MESSAGE_SECURITY_BINDING_CONSTRAINT_0 {
2246 fn clone(&self) -> Self {
2247 *self
2248 }
2249}
2250#[cfg(feature = "Win32_Foundation")]
2251pub type WS_IS_DEFAULT_VALUE_CALLBACK = unsafe extern "system" fn(descriptiondata: *const ::core::ffi::c_void, value: *const ::core::ffi::c_void, defaultvalue: *const ::core::ffi::c_void, valuesize: u32, isdefault: *mut super::super::Foundation::BOOL, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
2252#[repr(C)]
2253pub struct WS_ITEM_RANGE {
2254 pub minItemCount: u32,
2255 pub maxItemCount: u32,
2256}
2257impl ::core::marker::Copy for WS_ITEM_RANGE {}
2258impl ::core::clone::Clone for WS_ITEM_RANGE {
2259 fn clone(&self) -> Self {
2260 *self
2261 }
2262}
2263#[repr(C)]
2264pub struct WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING {
2265 pub binding: WS_SECURITY_BINDING,
2266 pub bindingUsage: WS_MESSAGE_SECURITY_USAGE,
2267 pub clientCredential: *mut WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
2268}
2269impl ::core::marker::Copy for WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING {}
2270impl ::core::clone::Clone for WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING {
2271 fn clone(&self) -> Self {
2272 *self
2273 }
2274}
2275#[repr(C)]
2276pub struct WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_CONSTRAINT {
2277 pub bindingConstraint: WS_SECURITY_BINDING_CONSTRAINT,
2278 pub bindingUsage: WS_MESSAGE_SECURITY_USAGE,
2279}
2280impl ::core::marker::Copy for WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_CONSTRAINT {}
2281impl ::core::clone::Clone for WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_CONSTRAINT {
2282 fn clone(&self) -> Self {
2283 *self
2284 }
2285}
2286#[repr(C)]
2287pub struct WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION {
2288 pub securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
2289 pub bindingUsage: WS_MESSAGE_SECURITY_USAGE,
2290}
2291impl ::core::marker::Copy for WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION {}
2292impl ::core::clone::Clone for WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION {
2293 fn clone(&self) -> Self {
2294 *self
2295 }
2296}
2297#[repr(C)]
2298pub struct WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TEMPLATE {
2299 pub securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
2300 pub clientCredential: *mut WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
2301}
2302impl ::core::marker::Copy for WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TEMPLATE {}
2303impl ::core::clone::Clone for WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TEMPLATE {
2304 fn clone(&self) -> Self {
2305 *self
2306 }
2307}
2308#[repr(C)]
2309pub struct WS_LISTENER(pub u8);
2310#[repr(C)]
2311pub struct WS_LISTENER_PROPERTIES {
2312 pub properties: *mut WS_LISTENER_PROPERTY,
2313 pub propertyCount: u32,
2314}
2315impl ::core::marker::Copy for WS_LISTENER_PROPERTIES {}
2316impl ::core::clone::Clone for WS_LISTENER_PROPERTIES {
2317 fn clone(&self) -> Self {
2318 *self
2319 }
2320}
2321#[repr(C)]
2322pub struct WS_LISTENER_PROPERTY {
2323 pub id: WS_LISTENER_PROPERTY_ID,
2324 pub value: *mut ::core::ffi::c_void,
2325 pub valueSize: u32,
2326}
2327impl ::core::marker::Copy for WS_LISTENER_PROPERTY {}
2328impl ::core::clone::Clone for WS_LISTENER_PROPERTY {
2329 fn clone(&self) -> Self {
2330 *self
2331 }
2332}
2333pub type WS_LISTENER_PROPERTY_ID = i32;
2334pub const WS_LISTENER_PROPERTY_LISTEN_BACKLOG: WS_LISTENER_PROPERTY_ID = 0i32;
2335pub const WS_LISTENER_PROPERTY_IP_VERSION: WS_LISTENER_PROPERTY_ID = 1i32;
2336pub const WS_LISTENER_PROPERTY_STATE: WS_LISTENER_PROPERTY_ID = 2i32;
2337pub const WS_LISTENER_PROPERTY_ASYNC_CALLBACK_MODEL: WS_LISTENER_PROPERTY_ID = 3i32;
2338pub const WS_LISTENER_PROPERTY_CHANNEL_TYPE: WS_LISTENER_PROPERTY_ID = 4i32;
2339pub const WS_LISTENER_PROPERTY_CHANNEL_BINDING: WS_LISTENER_PROPERTY_ID = 5i32;
2340pub const WS_LISTENER_PROPERTY_CONNECT_TIMEOUT: WS_LISTENER_PROPERTY_ID = 6i32;
2341pub const WS_LISTENER_PROPERTY_IS_MULTICAST: WS_LISTENER_PROPERTY_ID = 7i32;
2342pub const WS_LISTENER_PROPERTY_MULTICAST_INTERFACES: WS_LISTENER_PROPERTY_ID = 8i32;
2343pub const WS_LISTENER_PROPERTY_MULTICAST_LOOPBACK: WS_LISTENER_PROPERTY_ID = 9i32;
2344pub const WS_LISTENER_PROPERTY_CLOSE_TIMEOUT: WS_LISTENER_PROPERTY_ID = 10i32;
2345pub const WS_LISTENER_PROPERTY_TO_HEADER_MATCHING_OPTIONS: WS_LISTENER_PROPERTY_ID = 11i32;
2346pub const WS_LISTENER_PROPERTY_TRANSPORT_URL_MATCHING_OPTIONS: WS_LISTENER_PROPERTY_ID = 12i32;
2347pub const WS_LISTENER_PROPERTY_CUSTOM_LISTENER_CALLBACKS: WS_LISTENER_PROPERTY_ID = 13i32;
2348pub const WS_LISTENER_PROPERTY_CUSTOM_LISTENER_PARAMETERS: WS_LISTENER_PROPERTY_ID = 14i32;
2349pub const WS_LISTENER_PROPERTY_CUSTOM_LISTENER_INSTANCE: WS_LISTENER_PROPERTY_ID = 15i32;
2350pub const WS_LISTENER_PROPERTY_DISALLOWED_USER_AGENT: WS_LISTENER_PROPERTY_ID = 16i32;
2351pub type WS_LISTENER_STATE = i32;
2352pub const WS_LISTENER_STATE_CREATED: WS_LISTENER_STATE = 0i32;
2353pub const WS_LISTENER_STATE_OPENING: WS_LISTENER_STATE = 1i32;
2354pub const WS_LISTENER_STATE_OPEN: WS_LISTENER_STATE = 2i32;
2355pub const WS_LISTENER_STATE_FAULTED: WS_LISTENER_STATE = 3i32;
2356pub const WS_LISTENER_STATE_CLOSING: WS_LISTENER_STATE = 4i32;
2357pub const WS_LISTENER_STATE_CLOSED: WS_LISTENER_STATE = 5i32;
2358pub const WS_MATCH_URL_DNS_FULLY_QUALIFIED_HOST: i32 = 2i32;
2359pub const WS_MATCH_URL_DNS_HOST: i32 = 1i32;
2360pub const WS_MATCH_URL_EXACT_PATH: i32 = 64i32;
2361pub const WS_MATCH_URL_HOST_ADDRESSES: i32 = 16i32;
2362pub const WS_MATCH_URL_LOCAL_HOST: i32 = 8i32;
2363pub const WS_MATCH_URL_NETBIOS_HOST: i32 = 4i32;
2364pub const WS_MATCH_URL_NO_QUERY: i32 = 256i32;
2365pub const WS_MATCH_URL_PORT: i32 = 32i32;
2366pub const WS_MATCH_URL_PREFIX_PATH: i32 = 128i32;
2367pub const WS_MATCH_URL_THIS_HOST: i32 = 31i32;
2368#[repr(C)]
2369pub struct WS_MESSAGE(pub u8);
2370#[repr(C)]
2371#[cfg(feature = "Win32_Foundation")]
2372pub struct WS_MESSAGE_DESCRIPTION {
2373 pub action: *mut WS_XML_STRING,
2374 pub bodyElementDescription: *mut WS_ELEMENT_DESCRIPTION,
2375}
2376#[cfg(feature = "Win32_Foundation")]
2377impl ::core::marker::Copy for WS_MESSAGE_DESCRIPTION {}
2378#[cfg(feature = "Win32_Foundation")]
2379impl ::core::clone::Clone for WS_MESSAGE_DESCRIPTION {
2380 fn clone(&self) -> Self {
2381 *self
2382 }
2383}
2384pub type WS_MESSAGE_DONE_CALLBACK = unsafe extern "system" fn(donecallbackstate: *const ::core::ffi::c_void);
2385pub type WS_MESSAGE_INITIALIZATION = i32;
2386pub const WS_BLANK_MESSAGE: WS_MESSAGE_INITIALIZATION = 0i32;
2387pub const WS_DUPLICATE_MESSAGE: WS_MESSAGE_INITIALIZATION = 1i32;
2388pub const WS_REQUEST_MESSAGE: WS_MESSAGE_INITIALIZATION = 2i32;
2389pub const WS_REPLY_MESSAGE: WS_MESSAGE_INITIALIZATION = 3i32;
2390pub const WS_FAULT_MESSAGE: WS_MESSAGE_INITIALIZATION = 4i32;
2391#[repr(C)]
2392pub struct WS_MESSAGE_PROPERTIES {
2393 pub properties: *mut WS_MESSAGE_PROPERTY,
2394 pub propertyCount: u32,
2395}
2396impl ::core::marker::Copy for WS_MESSAGE_PROPERTIES {}
2397impl ::core::clone::Clone for WS_MESSAGE_PROPERTIES {
2398 fn clone(&self) -> Self {
2399 *self
2400 }
2401}
2402#[repr(C)]
2403pub struct WS_MESSAGE_PROPERTY {
2404 pub id: WS_MESSAGE_PROPERTY_ID,
2405 pub value: *mut ::core::ffi::c_void,
2406 pub valueSize: u32,
2407}
2408impl ::core::marker::Copy for WS_MESSAGE_PROPERTY {}
2409impl ::core::clone::Clone for WS_MESSAGE_PROPERTY {
2410 fn clone(&self) -> Self {
2411 *self
2412 }
2413}
2414pub type WS_MESSAGE_PROPERTY_ID = i32;
2415pub const WS_MESSAGE_PROPERTY_STATE: WS_MESSAGE_PROPERTY_ID = 0i32;
2416pub const WS_MESSAGE_PROPERTY_HEAP: WS_MESSAGE_PROPERTY_ID = 1i32;
2417pub const WS_MESSAGE_PROPERTY_ENVELOPE_VERSION: WS_MESSAGE_PROPERTY_ID = 2i32;
2418pub const WS_MESSAGE_PROPERTY_ADDRESSING_VERSION: WS_MESSAGE_PROPERTY_ID = 3i32;
2419pub const WS_MESSAGE_PROPERTY_HEADER_BUFFER: WS_MESSAGE_PROPERTY_ID = 4i32;
2420pub const WS_MESSAGE_PROPERTY_HEADER_POSITION: WS_MESSAGE_PROPERTY_ID = 5i32;
2421pub const WS_MESSAGE_PROPERTY_BODY_READER: WS_MESSAGE_PROPERTY_ID = 6i32;
2422pub const WS_MESSAGE_PROPERTY_BODY_WRITER: WS_MESSAGE_PROPERTY_ID = 7i32;
2423pub const WS_MESSAGE_PROPERTY_IS_ADDRESSED: WS_MESSAGE_PROPERTY_ID = 8i32;
2424pub const WS_MESSAGE_PROPERTY_HEAP_PROPERTIES: WS_MESSAGE_PROPERTY_ID = 9i32;
2425pub const WS_MESSAGE_PROPERTY_XML_READER_PROPERTIES: WS_MESSAGE_PROPERTY_ID = 10i32;
2426pub const WS_MESSAGE_PROPERTY_XML_WRITER_PROPERTIES: WS_MESSAGE_PROPERTY_ID = 11i32;
2427pub const WS_MESSAGE_PROPERTY_IS_FAULT: WS_MESSAGE_PROPERTY_ID = 12i32;
2428pub const WS_MESSAGE_PROPERTY_MAX_PROCESSED_HEADERS: WS_MESSAGE_PROPERTY_ID = 13i32;
2429pub const WS_MESSAGE_PROPERTY_USERNAME: WS_MESSAGE_PROPERTY_ID = 14i32;
2430pub const WS_MESSAGE_PROPERTY_ENCODED_CERT: WS_MESSAGE_PROPERTY_ID = 15i32;
2431pub const WS_MESSAGE_PROPERTY_TRANSPORT_SECURITY_WINDOWS_TOKEN: WS_MESSAGE_PROPERTY_ID = 16i32;
2432pub const WS_MESSAGE_PROPERTY_HTTP_HEADER_AUTH_WINDOWS_TOKEN: WS_MESSAGE_PROPERTY_ID = 17i32;
2433pub const WS_MESSAGE_PROPERTY_MESSAGE_SECURITY_WINDOWS_TOKEN: WS_MESSAGE_PROPERTY_ID = 18i32;
2434pub const WS_MESSAGE_PROPERTY_SAML_ASSERTION: WS_MESSAGE_PROPERTY_ID = 19i32;
2435pub const WS_MESSAGE_PROPERTY_SECURITY_CONTEXT: WS_MESSAGE_PROPERTY_ID = 20i32;
2436pub const WS_MESSAGE_PROPERTY_PROTECTION_LEVEL: WS_MESSAGE_PROPERTY_ID = 21i32;
2437pub type WS_MESSAGE_SECURITY_USAGE = i32;
2438pub const WS_SUPPORTING_MESSAGE_SECURITY_USAGE: WS_MESSAGE_SECURITY_USAGE = 1i32;
2439pub type WS_MESSAGE_STATE = i32;
2440pub const WS_MESSAGE_STATE_EMPTY: WS_MESSAGE_STATE = 1i32;
2441pub const WS_MESSAGE_STATE_INITIALIZED: WS_MESSAGE_STATE = 2i32;
2442pub const WS_MESSAGE_STATE_READING: WS_MESSAGE_STATE = 3i32;
2443pub const WS_MESSAGE_STATE_WRITING: WS_MESSAGE_STATE = 4i32;
2444pub const WS_MESSAGE_STATE_DONE: WS_MESSAGE_STATE = 5i32;
2445#[repr(C)]
2446pub struct WS_METADATA(pub u8);
2447#[repr(C)]
2448#[cfg(feature = "Win32_Foundation")]
2449pub struct WS_METADATA_ENDPOINT {
2450 pub endpointAddress: WS_ENDPOINT_ADDRESS,
2451 pub endpointPolicy: *mut WS_POLICY,
2452 pub portName: *mut WS_XML_STRING,
2453 pub serviceName: *mut WS_XML_STRING,
2454 pub serviceNs: *mut WS_XML_STRING,
2455 pub bindingName: *mut WS_XML_STRING,
2456 pub bindingNs: *mut WS_XML_STRING,
2457 pub portTypeName: *mut WS_XML_STRING,
2458 pub portTypeNs: *mut WS_XML_STRING,
2459}
2460#[cfg(feature = "Win32_Foundation")]
2461impl ::core::marker::Copy for WS_METADATA_ENDPOINT {}
2462#[cfg(feature = "Win32_Foundation")]
2463impl ::core::clone::Clone for WS_METADATA_ENDPOINT {
2464 fn clone(&self) -> Self {
2465 *self
2466 }
2467}
2468#[repr(C)]
2469#[cfg(feature = "Win32_Foundation")]
2470pub struct WS_METADATA_ENDPOINTS {
2471 pub endpoints: *mut WS_METADATA_ENDPOINT,
2472 pub endpointCount: u32,
2473}
2474#[cfg(feature = "Win32_Foundation")]
2475impl ::core::marker::Copy for WS_METADATA_ENDPOINTS {}
2476#[cfg(feature = "Win32_Foundation")]
2477impl ::core::clone::Clone for WS_METADATA_ENDPOINTS {
2478 fn clone(&self) -> Self {
2479 *self
2480 }
2481}
2482pub type WS_METADATA_EXCHANGE_TYPE = i32;
2483pub const WS_METADATA_EXCHANGE_TYPE_NONE: WS_METADATA_EXCHANGE_TYPE = 0i32;
2484pub const WS_METADATA_EXCHANGE_TYPE_MEX: WS_METADATA_EXCHANGE_TYPE = 1i32;
2485pub const WS_METADATA_EXCHANGE_TYPE_HTTP_GET: WS_METADATA_EXCHANGE_TYPE = 2i32;
2486#[repr(C)]
2487pub struct WS_METADATA_PROPERTY {
2488 pub id: WS_METADATA_PROPERTY_ID,
2489 pub value: *mut ::core::ffi::c_void,
2490 pub valueSize: u32,
2491}
2492impl ::core::marker::Copy for WS_METADATA_PROPERTY {}
2493impl ::core::clone::Clone for WS_METADATA_PROPERTY {
2494 fn clone(&self) -> Self {
2495 *self
2496 }
2497}
2498pub type WS_METADATA_PROPERTY_ID = i32;
2499pub const WS_METADATA_PROPERTY_STATE: WS_METADATA_PROPERTY_ID = 1i32;
2500pub const WS_METADATA_PROPERTY_HEAP_PROPERTIES: WS_METADATA_PROPERTY_ID = 2i32;
2501pub const WS_METADATA_PROPERTY_POLICY_PROPERTIES: WS_METADATA_PROPERTY_ID = 3i32;
2502pub const WS_METADATA_PROPERTY_HEAP_REQUESTED_SIZE: WS_METADATA_PROPERTY_ID = 4i32;
2503pub const WS_METADATA_PROPERTY_MAX_DOCUMENTS: WS_METADATA_PROPERTY_ID = 5i32;
2504pub const WS_METADATA_PROPERTY_HOST_NAMES: WS_METADATA_PROPERTY_ID = 6i32;
2505pub const WS_METADATA_PROPERTY_VERIFY_HOST_NAMES: WS_METADATA_PROPERTY_ID = 7i32;
2506pub type WS_METADATA_STATE = i32;
2507pub const WS_METADATA_STATE_CREATED: WS_METADATA_STATE = 1i32;
2508pub const WS_METADATA_STATE_RESOLVED: WS_METADATA_STATE = 2i32;
2509pub const WS_METADATA_STATE_FAULTED: WS_METADATA_STATE = 3i32;
2510pub type WS_MOVE_TO = i32;
2511pub const WS_MOVE_TO_ROOT_ELEMENT: WS_MOVE_TO = 0i32;
2512pub const WS_MOVE_TO_NEXT_ELEMENT: WS_MOVE_TO = 1i32;
2513pub const WS_MOVE_TO_PREVIOUS_ELEMENT: WS_MOVE_TO = 2i32;
2514pub const WS_MOVE_TO_CHILD_ELEMENT: WS_MOVE_TO = 3i32;
2515pub const WS_MOVE_TO_END_ELEMENT: WS_MOVE_TO = 4i32;
2516pub const WS_MOVE_TO_PARENT_ELEMENT: WS_MOVE_TO = 5i32;
2517pub const WS_MOVE_TO_NEXT_NODE: WS_MOVE_TO = 6i32;
2518pub const WS_MOVE_TO_PREVIOUS_NODE: WS_MOVE_TO = 7i32;
2519pub const WS_MOVE_TO_FIRST_NODE: WS_MOVE_TO = 8i32;
2520pub const WS_MOVE_TO_BOF: WS_MOVE_TO = 9i32;
2521pub const WS_MOVE_TO_EOF: WS_MOVE_TO = 10i32;
2522pub const WS_MOVE_TO_CHILD_NODE: WS_MOVE_TO = 11i32;
2523pub const WS_MUST_UNDERSTAND_HEADER_ATTRIBUTE: i32 = 1i32;
2524#[repr(C)]
2525pub struct WS_NAMEDPIPE_SSPI_TRANSPORT_SECURITY_BINDING {
2526 pub binding: WS_SECURITY_BINDING,
2527 pub clientCredential: *mut WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
2528}
2529impl ::core::marker::Copy for WS_NAMEDPIPE_SSPI_TRANSPORT_SECURITY_BINDING {}
2530impl ::core::clone::Clone for WS_NAMEDPIPE_SSPI_TRANSPORT_SECURITY_BINDING {
2531 fn clone(&self) -> Self {
2532 *self
2533 }
2534}
2535#[repr(C)]
2536pub struct WS_NCRYPT_ASYMMETRIC_SECURITY_KEY_HANDLE {
2537 pub keyHandle: WS_SECURITY_KEY_HANDLE,
2538 pub asymmetricKey: usize,
2539}
2540impl ::core::marker::Copy for WS_NCRYPT_ASYMMETRIC_SECURITY_KEY_HANDLE {}
2541impl ::core::clone::Clone for WS_NCRYPT_ASYMMETRIC_SECURITY_KEY_HANDLE {
2542 fn clone(&self) -> Self {
2543 *self
2544 }
2545}
2546#[repr(C)]
2547#[cfg(feature = "Win32_Foundation")]
2548pub struct WS_NETPIPE_URL {
2549 pub url: WS_URL,
2550 pub host: WS_STRING,
2551 pub port: u16,
2552 pub portAsString: WS_STRING,
2553 pub path: WS_STRING,
2554 pub query: WS_STRING,
2555 pub fragment: WS_STRING,
2556}
2557#[cfg(feature = "Win32_Foundation")]
2558impl ::core::marker::Copy for WS_NETPIPE_URL {}
2559#[cfg(feature = "Win32_Foundation")]
2560impl ::core::clone::Clone for WS_NETPIPE_URL {
2561 fn clone(&self) -> Self {
2562 *self
2563 }
2564}
2565#[repr(C)]
2566#[cfg(feature = "Win32_Foundation")]
2567pub struct WS_NETTCP_URL {
2568 pub url: WS_URL,
2569 pub host: WS_STRING,
2570 pub port: u16,
2571 pub portAsString: WS_STRING,
2572 pub path: WS_STRING,
2573 pub query: WS_STRING,
2574 pub fragment: WS_STRING,
2575}
2576#[cfg(feature = "Win32_Foundation")]
2577impl ::core::marker::Copy for WS_NETTCP_URL {}
2578#[cfg(feature = "Win32_Foundation")]
2579impl ::core::clone::Clone for WS_NETTCP_URL {
2580 fn clone(&self) -> Self {
2581 *self
2582 }
2583}
2584#[repr(C)]
2585pub struct WS_OPAQUE_WINDOWS_INTEGRATED_AUTH_CREDENTIAL {
2586 pub credential: WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
2587 pub opaqueAuthIdentity: *mut ::core::ffi::c_void,
2588}
2589impl ::core::marker::Copy for WS_OPAQUE_WINDOWS_INTEGRATED_AUTH_CREDENTIAL {}
2590impl ::core::clone::Clone for WS_OPAQUE_WINDOWS_INTEGRATED_AUTH_CREDENTIAL {
2591 fn clone(&self) -> Self {
2592 *self
2593 }
2594}
2595#[cfg(feature = "Win32_Foundation")]
2596pub type WS_OPEN_CHANNEL_CALLBACK = unsafe extern "system" fn(channelinstance: *const ::core::ffi::c_void, endpointaddress: *const WS_ENDPOINT_ADDRESS, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
2597#[cfg(feature = "Win32_Foundation")]
2598pub type WS_OPEN_LISTENER_CALLBACK = unsafe extern "system" fn(listenerinstance: *const ::core::ffi::c_void, url: *const WS_STRING, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
2599pub type WS_OPERATION_CANCEL_CALLBACK = unsafe extern "system" fn(reason: WS_SERVICE_CANCEL_REASON, state: *const ::core::ffi::c_void);
2600#[repr(C)]
2601pub struct WS_OPERATION_CONTEXT(pub u8);
2602pub type WS_OPERATION_CONTEXT_PROPERTY_ID = i32;
2603pub const WS_OPERATION_CONTEXT_PROPERTY_CHANNEL: WS_OPERATION_CONTEXT_PROPERTY_ID = 0i32;
2604pub const WS_OPERATION_CONTEXT_PROPERTY_CONTRACT_DESCRIPTION: WS_OPERATION_CONTEXT_PROPERTY_ID = 1i32;
2605pub const WS_OPERATION_CONTEXT_PROPERTY_HOST_USER_STATE: WS_OPERATION_CONTEXT_PROPERTY_ID = 2i32;
2606pub const WS_OPERATION_CONTEXT_PROPERTY_CHANNEL_USER_STATE: WS_OPERATION_CONTEXT_PROPERTY_ID = 3i32;
2607pub const WS_OPERATION_CONTEXT_PROPERTY_INPUT_MESSAGE: WS_OPERATION_CONTEXT_PROPERTY_ID = 4i32;
2608pub const WS_OPERATION_CONTEXT_PROPERTY_OUTPUT_MESSAGE: WS_OPERATION_CONTEXT_PROPERTY_ID = 5i32;
2609pub const WS_OPERATION_CONTEXT_PROPERTY_HEAP: WS_OPERATION_CONTEXT_PROPERTY_ID = 6i32;
2610pub const WS_OPERATION_CONTEXT_PROPERTY_LISTENER: WS_OPERATION_CONTEXT_PROPERTY_ID = 7i32;
2611pub const WS_OPERATION_CONTEXT_PROPERTY_ENDPOINT_ADDRESS: WS_OPERATION_CONTEXT_PROPERTY_ID = 8i32;
2612#[repr(C)]
2613#[cfg(feature = "Win32_Foundation")]
2614pub struct WS_OPERATION_DESCRIPTION {
2615 pub versionInfo: u32,
2616 pub inputMessageDescription: *mut WS_MESSAGE_DESCRIPTION,
2617 pub outputMessageDescription: *mut WS_MESSAGE_DESCRIPTION,
2618 pub inputMessageOptions: u32,
2619 pub outputMessageOptions: u32,
2620 pub parameterCount: u16,
2621 pub parameterDescription: *mut WS_PARAMETER_DESCRIPTION,
2622 pub stubCallback: WS_SERVICE_STUB_CALLBACK,
2623 pub style: WS_OPERATION_STYLE,
2624}
2625#[cfg(feature = "Win32_Foundation")]
2626impl ::core::marker::Copy for WS_OPERATION_DESCRIPTION {}
2627#[cfg(feature = "Win32_Foundation")]
2628impl ::core::clone::Clone for WS_OPERATION_DESCRIPTION {
2629 fn clone(&self) -> Self {
2630 *self
2631 }
2632}
2633pub type WS_OPERATION_FREE_STATE_CALLBACK = unsafe extern "system" fn(state: *const ::core::ffi::c_void);
2634pub type WS_OPERATION_STYLE = i32;
2635pub const WS_NON_RPC_LITERAL_OPERATION: WS_OPERATION_STYLE = 0i32;
2636pub const WS_RPC_LITERAL_OPERATION: WS_OPERATION_STYLE = 1i32;
2637#[repr(C)]
2638pub struct WS_PARAMETER_DESCRIPTION {
2639 pub parameterType: WS_PARAMETER_TYPE,
2640 pub inputMessageIndex: u16,
2641 pub outputMessageIndex: u16,
2642}
2643impl ::core::marker::Copy for WS_PARAMETER_DESCRIPTION {}
2644impl ::core::clone::Clone for WS_PARAMETER_DESCRIPTION {
2645 fn clone(&self) -> Self {
2646 *self
2647 }
2648}
2649pub type WS_PARAMETER_TYPE = i32;
2650pub const WS_PARAMETER_TYPE_NORMAL: WS_PARAMETER_TYPE = 0i32;
2651pub const WS_PARAMETER_TYPE_ARRAY: WS_PARAMETER_TYPE = 1i32;
2652pub const WS_PARAMETER_TYPE_ARRAY_COUNT: WS_PARAMETER_TYPE = 2i32;
2653pub const WS_PARAMETER_TYPE_MESSAGES: WS_PARAMETER_TYPE = 3i32;
2654#[repr(C)]
2655pub struct WS_POLICY(pub u8);
2656#[repr(C)]
2657pub struct WS_POLICY_CONSTRAINTS {
2658 pub channelBinding: WS_CHANNEL_BINDING,
2659 pub channelPropertyConstraints: *mut WS_CHANNEL_PROPERTY_CONSTRAINT,
2660 pub channelPropertyConstraintCount: u32,
2661 pub securityConstraints: *mut WS_SECURITY_CONSTRAINTS,
2662 pub policyExtensions: *mut *mut WS_POLICY_EXTENSION,
2663 pub policyExtensionCount: u32,
2664}
2665impl ::core::marker::Copy for WS_POLICY_CONSTRAINTS {}
2666impl ::core::clone::Clone for WS_POLICY_CONSTRAINTS {
2667 fn clone(&self) -> Self {
2668 *self
2669 }
2670}
2671#[repr(C)]
2672pub struct WS_POLICY_EXTENSION {
2673 pub r#type: WS_POLICY_EXTENSION_TYPE,
2674}
2675impl ::core::marker::Copy for WS_POLICY_EXTENSION {}
2676impl ::core::clone::Clone for WS_POLICY_EXTENSION {
2677 fn clone(&self) -> Self {
2678 *self
2679 }
2680}
2681pub type WS_POLICY_EXTENSION_TYPE = i32;
2682pub const WS_ENDPOINT_POLICY_EXTENSION_TYPE: WS_POLICY_EXTENSION_TYPE = 1i32;
2683#[repr(C)]
2684pub struct WS_POLICY_PROPERTIES {
2685 pub properties: *mut WS_POLICY_PROPERTY,
2686 pub propertyCount: u32,
2687}
2688impl ::core::marker::Copy for WS_POLICY_PROPERTIES {}
2689impl ::core::clone::Clone for WS_POLICY_PROPERTIES {
2690 fn clone(&self) -> Self {
2691 *self
2692 }
2693}
2694#[repr(C)]
2695pub struct WS_POLICY_PROPERTY {
2696 pub id: WS_POLICY_PROPERTY_ID,
2697 pub value: *mut ::core::ffi::c_void,
2698 pub valueSize: u32,
2699}
2700impl ::core::marker::Copy for WS_POLICY_PROPERTY {}
2701impl ::core::clone::Clone for WS_POLICY_PROPERTY {
2702 fn clone(&self) -> Self {
2703 *self
2704 }
2705}
2706pub type WS_POLICY_PROPERTY_ID = i32;
2707pub const WS_POLICY_PROPERTY_STATE: WS_POLICY_PROPERTY_ID = 1i32;
2708pub const WS_POLICY_PROPERTY_MAX_ALTERNATIVES: WS_POLICY_PROPERTY_ID = 2i32;
2709pub const WS_POLICY_PROPERTY_MAX_DEPTH: WS_POLICY_PROPERTY_ID = 3i32;
2710pub const WS_POLICY_PROPERTY_MAX_EXTENSIONS: WS_POLICY_PROPERTY_ID = 4i32;
2711pub type WS_POLICY_STATE = i32;
2712pub const WS_POLICY_STATE_CREATED: WS_POLICY_STATE = 1i32;
2713pub const WS_POLICY_STATE_FAULTED: WS_POLICY_STATE = 2i32;
2714pub type WS_PROTECTION_LEVEL = i32;
2715pub const WS_PROTECTION_LEVEL_NONE: WS_PROTECTION_LEVEL = 1i32;
2716pub const WS_PROTECTION_LEVEL_SIGN: WS_PROTECTION_LEVEL = 2i32;
2717pub const WS_PROTECTION_LEVEL_SIGN_AND_ENCRYPT: WS_PROTECTION_LEVEL = 3i32;
2718pub type WS_PROXY_MESSAGE_CALLBACK = unsafe extern "system" fn(message: *const WS_MESSAGE, heap: *const WS_HEAP, state: *const ::core::ffi::c_void, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
2719#[repr(C)]
2720pub struct WS_PROXY_MESSAGE_CALLBACK_CONTEXT {
2721 pub callback: WS_PROXY_MESSAGE_CALLBACK,
2722 pub state: *mut ::core::ffi::c_void,
2723}
2724impl ::core::marker::Copy for WS_PROXY_MESSAGE_CALLBACK_CONTEXT {}
2725impl ::core::clone::Clone for WS_PROXY_MESSAGE_CALLBACK_CONTEXT {
2726 fn clone(&self) -> Self {
2727 *self
2728 }
2729}
2730#[repr(C)]
2731pub struct WS_PROXY_PROPERTY {
2732 pub id: WS_PROXY_PROPERTY_ID,
2733 pub value: *mut ::core::ffi::c_void,
2734 pub valueSize: u32,
2735}
2736impl ::core::marker::Copy for WS_PROXY_PROPERTY {}
2737impl ::core::clone::Clone for WS_PROXY_PROPERTY {
2738 fn clone(&self) -> Self {
2739 *self
2740 }
2741}
2742pub type WS_PROXY_PROPERTY_ID = i32;
2743pub const WS_PROXY_PROPERTY_CALL_TIMEOUT: WS_PROXY_PROPERTY_ID = 0i32;
2744pub const WS_PROXY_PROPERTY_MESSAGE_PROPERTIES: WS_PROXY_PROPERTY_ID = 1i32;
2745pub const WS_PROXY_PROPERTY_MAX_CALL_POOL_SIZE: WS_PROXY_PROPERTY_ID = 2i32;
2746pub const WS_PROXY_PROPERTY_STATE: WS_PROXY_PROPERTY_ID = 3i32;
2747pub const WS_PROXY_PROPERTY_MAX_PENDING_CALLS: WS_PROXY_PROPERTY_ID = 4i32;
2748pub const WS_PROXY_PROPERTY_MAX_CLOSE_TIMEOUT: WS_PROXY_PROPERTY_ID = 5i32;
2749pub const WS_PROXY_FAULT_LANG_ID: WS_PROXY_PROPERTY_ID = 6i32;
2750pub type WS_PULL_BYTES_CALLBACK = unsafe extern "system" fn(callbackstate: *const ::core::ffi::c_void, bytes: *mut ::core::ffi::c_void, maxsize: u32, actualsize: *mut u32, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
2751pub type WS_PUSH_BYTES_CALLBACK = unsafe extern "system" fn(callbackstate: *const ::core::ffi::c_void, writecallback: ::core::option::Option<WS_WRITE_CALLBACK>, writecallbackstate: *const ::core::ffi::c_void, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
2752#[repr(C)]
2753pub struct WS_RAW_SYMMETRIC_SECURITY_KEY_HANDLE {
2754 pub keyHandle: WS_SECURITY_KEY_HANDLE,
2755 pub rawKeyBytes: WS_BYTES,
2756}
2757impl ::core::marker::Copy for WS_RAW_SYMMETRIC_SECURITY_KEY_HANDLE {}
2758impl ::core::clone::Clone for WS_RAW_SYMMETRIC_SECURITY_KEY_HANDLE {
2759 fn clone(&self) -> Self {
2760 *self
2761 }
2762}
2763pub type WS_READ_CALLBACK = unsafe extern "system" fn(callbackstate: *const ::core::ffi::c_void, bytes: *mut ::core::ffi::c_void, maxsize: u32, actualsize: *mut u32, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
2764pub type WS_READ_MESSAGE_END_CALLBACK = unsafe extern "system" fn(channelinstance: *const ::core::ffi::c_void, message: *const WS_MESSAGE, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
2765pub type WS_READ_MESSAGE_START_CALLBACK = unsafe extern "system" fn(channelinstance: *const ::core::ffi::c_void, message: *const WS_MESSAGE, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
2766pub type WS_READ_OPTION = i32;
2767pub const WS_READ_REQUIRED_VALUE: WS_READ_OPTION = 1i32;
2768pub const WS_READ_REQUIRED_POINTER: WS_READ_OPTION = 2i32;
2769pub const WS_READ_OPTIONAL_POINTER: WS_READ_OPTION = 3i32;
2770pub const WS_READ_NILLABLE_POINTER: WS_READ_OPTION = 4i32;
2771pub const WS_READ_NILLABLE_VALUE: WS_READ_OPTION = 5i32;
2772pub type WS_READ_TYPE_CALLBACK = unsafe extern "system" fn(reader: *const WS_XML_READER, typemapping: WS_TYPE_MAPPING, descriptiondata: *const ::core::ffi::c_void, heap: *const WS_HEAP, value: *mut ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
2773pub type WS_RECEIVE_OPTION = i32;
2774pub const WS_RECEIVE_REQUIRED_MESSAGE: WS_RECEIVE_OPTION = 1i32;
2775pub const WS_RECEIVE_OPTIONAL_MESSAGE: WS_RECEIVE_OPTION = 2i32;
2776pub const WS_RELAY_HEADER_ATTRIBUTE: i32 = 2i32;
2777pub type WS_REPEATING_HEADER_OPTION = i32;
2778pub const WS_REPEATING_HEADER: WS_REPEATING_HEADER_OPTION = 1i32;
2779pub const WS_SINGLETON_HEADER: WS_REPEATING_HEADER_OPTION = 2i32;
2780pub type WS_REQUEST_SECURITY_TOKEN_ACTION = i32;
2781pub const WS_REQUEST_SECURITY_TOKEN_ACTION_ISSUE: WS_REQUEST_SECURITY_TOKEN_ACTION = 1i32;
2782pub const WS_REQUEST_SECURITY_TOKEN_ACTION_NEW_CONTEXT: WS_REQUEST_SECURITY_TOKEN_ACTION = 2i32;
2783pub const WS_REQUEST_SECURITY_TOKEN_ACTION_RENEW_CONTEXT: WS_REQUEST_SECURITY_TOKEN_ACTION = 3i32;
2784#[repr(C)]
2785pub struct WS_REQUEST_SECURITY_TOKEN_PROPERTY {
2786 pub id: WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID,
2787 pub value: *mut ::core::ffi::c_void,
2788 pub valueSize: u32,
2789}
2790impl ::core::marker::Copy for WS_REQUEST_SECURITY_TOKEN_PROPERTY {}
2791impl ::core::clone::Clone for WS_REQUEST_SECURITY_TOKEN_PROPERTY {
2792 fn clone(&self) -> Self {
2793 *self
2794 }
2795}
2796#[repr(C)]
2797pub struct WS_REQUEST_SECURITY_TOKEN_PROPERTY_CONSTRAINT {
2798 pub id: WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID,
2799 pub allowedValues: *mut ::core::ffi::c_void,
2800 pub allowedValuesSize: u32,
2801 pub out: WS_REQUEST_SECURITY_TOKEN_PROPERTY_CONSTRAINT_0,
2802}
2803impl ::core::marker::Copy for WS_REQUEST_SECURITY_TOKEN_PROPERTY_CONSTRAINT {}
2804impl ::core::clone::Clone for WS_REQUEST_SECURITY_TOKEN_PROPERTY_CONSTRAINT {
2805 fn clone(&self) -> Self {
2806 *self
2807 }
2808}
2809#[repr(C)]
2810pub struct WS_REQUEST_SECURITY_TOKEN_PROPERTY_CONSTRAINT_0 {
2811 pub requestSecurityTokenProperty: WS_REQUEST_SECURITY_TOKEN_PROPERTY,
2812}
2813impl ::core::marker::Copy for WS_REQUEST_SECURITY_TOKEN_PROPERTY_CONSTRAINT_0 {}
2814impl ::core::clone::Clone for WS_REQUEST_SECURITY_TOKEN_PROPERTY_CONSTRAINT_0 {
2815 fn clone(&self) -> Self {
2816 *self
2817 }
2818}
2819pub type WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID = i32;
2820pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_APPLIES_TO: WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID = 1i32;
2821pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_TRUST_VERSION: WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID = 2i32;
2822pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_SECURE_CONVERSATION_VERSION: WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID = 3i32;
2823pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_ISSUED_TOKEN_TYPE: WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID = 4i32;
2824pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_REQUEST_ACTION: WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID = 5i32;
2825pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_EXISTING_TOKEN: WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID = 6i32;
2826pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_ISSUED_TOKEN_KEY_TYPE: WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID = 7i32;
2827pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_ISSUED_TOKEN_KEY_SIZE: WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID = 8i32;
2828pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_ISSUED_TOKEN_KEY_ENTROPY: WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID = 9i32;
2829pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_LOCAL_REQUEST_PARAMETERS: WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID = 10i32;
2830pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_SERVICE_REQUEST_PARAMETERS: WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID = 11i32;
2831pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_MESSAGE_PROPERTIES: WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID = 12i32;
2832pub const WS_REQUEST_SECURITY_TOKEN_PROPERTY_BEARER_KEY_TYPE_VERSION: WS_REQUEST_SECURITY_TOKEN_PROPERTY_ID = 13i32;
2833pub type WS_RESET_CHANNEL_CALLBACK = unsafe extern "system" fn(channelinstance: *const ::core::ffi::c_void, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
2834pub type WS_RESET_LISTENER_CALLBACK = unsafe extern "system" fn(listenerinstance: *const ::core::ffi::c_void, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
2835#[repr(C)]
2836pub struct WS_RSA_ENDPOINT_IDENTITY {
2837 pub identity: WS_ENDPOINT_IDENTITY,
2838 pub modulus: WS_BYTES,
2839 pub exponent: WS_BYTES,
2840}
2841impl ::core::marker::Copy for WS_RSA_ENDPOINT_IDENTITY {}
2842impl ::core::clone::Clone for WS_RSA_ENDPOINT_IDENTITY {
2843 fn clone(&self) -> Self {
2844 *self
2845 }
2846}
2847#[repr(C)]
2848pub struct WS_SAML_AUTHENTICATOR {
2849 pub authenticatorType: WS_SAML_AUTHENTICATOR_TYPE,
2850}
2851impl ::core::marker::Copy for WS_SAML_AUTHENTICATOR {}
2852impl ::core::clone::Clone for WS_SAML_AUTHENTICATOR {
2853 fn clone(&self) -> Self {
2854 *self
2855 }
2856}
2857pub type WS_SAML_AUTHENTICATOR_TYPE = i32;
2858pub const WS_CERT_SIGNED_SAML_AUTHENTICATOR_TYPE: WS_SAML_AUTHENTICATOR_TYPE = 1i32;
2859#[repr(C)]
2860pub struct WS_SAML_MESSAGE_SECURITY_BINDING {
2861 pub binding: WS_SECURITY_BINDING,
2862 pub bindingUsage: WS_MESSAGE_SECURITY_USAGE,
2863 pub authenticator: *mut WS_SAML_AUTHENTICATOR,
2864}
2865impl ::core::marker::Copy for WS_SAML_MESSAGE_SECURITY_BINDING {}
2866impl ::core::clone::Clone for WS_SAML_MESSAGE_SECURITY_BINDING {
2867 fn clone(&self) -> Self {
2868 *self
2869 }
2870}
2871pub type WS_SECURE_CONVERSATION_VERSION = i32;
2872pub const WS_SECURE_CONVERSATION_VERSION_FEBRUARY_2005: WS_SECURE_CONVERSATION_VERSION = 1i32;
2873pub const WS_SECURE_CONVERSATION_VERSION_1_3: WS_SECURE_CONVERSATION_VERSION = 2i32;
2874pub type WS_SECURE_PROTOCOL = i32;
2875pub const WS_SECURE_PROTOCOL_SSL2: WS_SECURE_PROTOCOL = 1i32;
2876pub const WS_SECURE_PROTOCOL_SSL3: WS_SECURE_PROTOCOL = 2i32;
2877pub const WS_SECURE_PROTOCOL_TLS1_0: WS_SECURE_PROTOCOL = 4i32;
2878pub const WS_SECURE_PROTOCOL_TLS1_1: WS_SECURE_PROTOCOL = 8i32;
2879pub const WS_SECURE_PROTOCOL_TLS1_2: WS_SECURE_PROTOCOL = 16i32;
2880pub type WS_SECURITY_ALGORITHM_ID = i32;
2881pub const WS_SECURITY_ALGORITHM_DEFAULT: WS_SECURITY_ALGORITHM_ID = 0i32;
2882pub const WS_SECURITY_ALGORITHM_CANONICALIZATION_EXCLUSIVE: WS_SECURITY_ALGORITHM_ID = 1i32;
2883pub const WS_SECURITY_ALGORITHM_CANONICALIZATION_EXCLUSIVE_WITH_COMMENTS: WS_SECURITY_ALGORITHM_ID = 2i32;
2884pub const WS_SECURITY_ALGORITHM_DIGEST_SHA1: WS_SECURITY_ALGORITHM_ID = 3i32;
2885pub const WS_SECURITY_ALGORITHM_DIGEST_SHA_256: WS_SECURITY_ALGORITHM_ID = 4i32;
2886pub const WS_SECURITY_ALGORITHM_DIGEST_SHA_384: WS_SECURITY_ALGORITHM_ID = 5i32;
2887pub const WS_SECURITY_ALGORITHM_DIGEST_SHA_512: WS_SECURITY_ALGORITHM_ID = 6i32;
2888pub const WS_SECURITY_ALGORITHM_SYMMETRIC_SIGNATURE_HMAC_SHA1: WS_SECURITY_ALGORITHM_ID = 7i32;
2889pub const WS_SECURITY_ALGORITHM_SYMMETRIC_SIGNATURE_HMAC_SHA_256: WS_SECURITY_ALGORITHM_ID = 8i32;
2890pub const WS_SECURITY_ALGORITHM_SYMMETRIC_SIGNATURE_HMAC_SHA_384: WS_SECURITY_ALGORITHM_ID = 9i32;
2891pub const WS_SECURITY_ALGORITHM_SYMMETRIC_SIGNATURE_HMAC_SHA_512: WS_SECURITY_ALGORITHM_ID = 10i32;
2892pub const WS_SECURITY_ALGORITHM_ASYMMETRIC_SIGNATURE_RSA_SHA1: WS_SECURITY_ALGORITHM_ID = 11i32;
2893pub const WS_SECURITY_ALGORITHM_ASYMMETRIC_SIGNATURE_DSA_SHA1: WS_SECURITY_ALGORITHM_ID = 12i32;
2894pub const WS_SECURITY_ALGORITHM_ASYMMETRIC_SIGNATURE_RSA_SHA_256: WS_SECURITY_ALGORITHM_ID = 13i32;
2895pub const WS_SECURITY_ALGORITHM_ASYMMETRIC_SIGNATURE_RSA_SHA_384: WS_SECURITY_ALGORITHM_ID = 14i32;
2896pub const WS_SECURITY_ALGORITHM_ASYMMETRIC_SIGNATURE_RSA_SHA_512: WS_SECURITY_ALGORITHM_ID = 15i32;
2897pub const WS_SECURITY_ALGORITHM_ASYMMETRIC_KEYWRAP_RSA_1_5: WS_SECURITY_ALGORITHM_ID = 16i32;
2898pub const WS_SECURITY_ALGORITHM_ASYMMETRIC_KEYWRAP_RSA_OAEP: WS_SECURITY_ALGORITHM_ID = 17i32;
2899pub const WS_SECURITY_ALGORITHM_KEY_DERIVATION_P_SHA1: WS_SECURITY_ALGORITHM_ID = 18i32;
2900#[repr(C)]
2901pub struct WS_SECURITY_ALGORITHM_PROPERTY {
2902 pub id: WS_SECURITY_ALGORITHM_PROPERTY_ID,
2903 pub value: *mut ::core::ffi::c_void,
2904 pub valueSize: u32,
2905}
2906impl ::core::marker::Copy for WS_SECURITY_ALGORITHM_PROPERTY {}
2907impl ::core::clone::Clone for WS_SECURITY_ALGORITHM_PROPERTY {
2908 fn clone(&self) -> Self {
2909 *self
2910 }
2911}
2912pub type WS_SECURITY_ALGORITHM_PROPERTY_ID = i32;
2913#[repr(C)]
2914pub struct WS_SECURITY_ALGORITHM_SUITE {
2915 pub canonicalizationAlgorithm: WS_SECURITY_ALGORITHM_ID,
2916 pub digestAlgorithm: WS_SECURITY_ALGORITHM_ID,
2917 pub symmetricSignatureAlgorithm: WS_SECURITY_ALGORITHM_ID,
2918 pub asymmetricSignatureAlgorithm: WS_SECURITY_ALGORITHM_ID,
2919 pub encryptionAlgorithm: WS_SECURITY_ALGORITHM_ID,
2920 pub keyDerivationAlgorithm: WS_SECURITY_ALGORITHM_ID,
2921 pub symmetricKeyWrapAlgorithm: WS_SECURITY_ALGORITHM_ID,
2922 pub asymmetricKeyWrapAlgorithm: WS_SECURITY_ALGORITHM_ID,
2923 pub minSymmetricKeyLength: u32,
2924 pub maxSymmetricKeyLength: u32,
2925 pub minAsymmetricKeyLength: u32,
2926 pub maxAsymmetricKeyLength: u32,
2927 pub properties: *mut WS_SECURITY_ALGORITHM_PROPERTY,
2928 pub propertyCount: u32,
2929}
2930impl ::core::marker::Copy for WS_SECURITY_ALGORITHM_SUITE {}
2931impl ::core::clone::Clone for WS_SECURITY_ALGORITHM_SUITE {
2932 fn clone(&self) -> Self {
2933 *self
2934 }
2935}
2936pub type WS_SECURITY_ALGORITHM_SUITE_NAME = i32;
2937pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC256: WS_SECURITY_ALGORITHM_SUITE_NAME = 1i32;
2938pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC192: WS_SECURITY_ALGORITHM_SUITE_NAME = 2i32;
2939pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC128: WS_SECURITY_ALGORITHM_SUITE_NAME = 3i32;
2940pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC256_RSA15: WS_SECURITY_ALGORITHM_SUITE_NAME = 4i32;
2941pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC192_RSA15: WS_SECURITY_ALGORITHM_SUITE_NAME = 5i32;
2942pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC128_RSA15: WS_SECURITY_ALGORITHM_SUITE_NAME = 6i32;
2943pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC256_SHA256: WS_SECURITY_ALGORITHM_SUITE_NAME = 7i32;
2944pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC192_SHA256: WS_SECURITY_ALGORITHM_SUITE_NAME = 8i32;
2945pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC128_SHA256: WS_SECURITY_ALGORITHM_SUITE_NAME = 9i32;
2946pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC256_SHA256_RSA15: WS_SECURITY_ALGORITHM_SUITE_NAME = 10i32;
2947pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC192_SHA256_RSA15: WS_SECURITY_ALGORITHM_SUITE_NAME = 11i32;
2948pub const WS_SECURITY_ALGORITHM_SUITE_NAME_BASIC128_SHA256_RSA15: WS_SECURITY_ALGORITHM_SUITE_NAME = 12i32;
2949pub type WS_SECURITY_BEARER_KEY_TYPE_VERSION = i32;
2950pub const WS_SECURITY_BEARER_KEY_TYPE_VERSION_1_3_ORIGINAL_SPECIFICATION: WS_SECURITY_BEARER_KEY_TYPE_VERSION = 1i32;
2951pub const WS_SECURITY_BEARER_KEY_TYPE_VERSION_1_3_ORIGINAL_SCHEMA: WS_SECURITY_BEARER_KEY_TYPE_VERSION = 2i32;
2952pub const WS_SECURITY_BEARER_KEY_TYPE_VERSION_1_3_ERRATA_01: WS_SECURITY_BEARER_KEY_TYPE_VERSION = 3i32;
2953#[repr(C)]
2954pub struct WS_SECURITY_BINDING {
2955 pub bindingType: WS_SECURITY_BINDING_TYPE,
2956 pub properties: *mut WS_SECURITY_BINDING_PROPERTY,
2957 pub propertyCount: u32,
2958}
2959impl ::core::marker::Copy for WS_SECURITY_BINDING {}
2960impl ::core::clone::Clone for WS_SECURITY_BINDING {
2961 fn clone(&self) -> Self {
2962 *self
2963 }
2964}
2965#[repr(C)]
2966pub struct WS_SECURITY_BINDING_CONSTRAINT {
2967 pub r#type: WS_SECURITY_BINDING_CONSTRAINT_TYPE,
2968 pub propertyConstraints: *mut WS_SECURITY_BINDING_PROPERTY_CONSTRAINT,
2969 pub propertyConstraintCount: u32,
2970}
2971impl ::core::marker::Copy for WS_SECURITY_BINDING_CONSTRAINT {}
2972impl ::core::clone::Clone for WS_SECURITY_BINDING_CONSTRAINT {
2973 fn clone(&self) -> Self {
2974 *self
2975 }
2976}
2977pub type WS_SECURITY_BINDING_CONSTRAINT_TYPE = i32;
2978pub const WS_SSL_TRANSPORT_SECURITY_BINDING_CONSTRAINT_TYPE: WS_SECURITY_BINDING_CONSTRAINT_TYPE = 1i32;
2979pub const WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_CONSTRAINT_TYPE: WS_SECURITY_BINDING_CONSTRAINT_TYPE = 2i32;
2980pub const WS_HTTP_HEADER_AUTH_SECURITY_BINDING_CONSTRAINT_TYPE: WS_SECURITY_BINDING_CONSTRAINT_TYPE = 3i32;
2981pub const WS_USERNAME_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE: WS_SECURITY_BINDING_CONSTRAINT_TYPE = 4i32;
2982pub const WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE: WS_SECURITY_BINDING_CONSTRAINT_TYPE = 5i32;
2983pub const WS_ISSUED_TOKEN_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE: WS_SECURITY_BINDING_CONSTRAINT_TYPE = 6i32;
2984pub const WS_CERT_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE: WS_SECURITY_BINDING_CONSTRAINT_TYPE = 7i32;
2985pub const WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_CONSTRAINT_TYPE: WS_SECURITY_BINDING_CONSTRAINT_TYPE = 8i32;
2986#[repr(C)]
2987pub struct WS_SECURITY_BINDING_PROPERTIES {
2988 pub properties: *mut WS_SECURITY_BINDING_PROPERTY,
2989 pub propertyCount: u32,
2990}
2991impl ::core::marker::Copy for WS_SECURITY_BINDING_PROPERTIES {}
2992impl ::core::clone::Clone for WS_SECURITY_BINDING_PROPERTIES {
2993 fn clone(&self) -> Self {
2994 *self
2995 }
2996}
2997#[repr(C)]
2998pub struct WS_SECURITY_BINDING_PROPERTY {
2999 pub id: WS_SECURITY_BINDING_PROPERTY_ID,
3000 pub value: *mut ::core::ffi::c_void,
3001 pub valueSize: u32,
3002}
3003impl ::core::marker::Copy for WS_SECURITY_BINDING_PROPERTY {}
3004impl ::core::clone::Clone for WS_SECURITY_BINDING_PROPERTY {
3005 fn clone(&self) -> Self {
3006 *self
3007 }
3008}
3009#[repr(C)]
3010pub struct WS_SECURITY_BINDING_PROPERTY_CONSTRAINT {
3011 pub id: WS_SECURITY_BINDING_PROPERTY_ID,
3012 pub allowedValues: *mut ::core::ffi::c_void,
3013 pub allowedValuesSize: u32,
3014 pub out: WS_SECURITY_BINDING_PROPERTY_CONSTRAINT_0,
3015}
3016impl ::core::marker::Copy for WS_SECURITY_BINDING_PROPERTY_CONSTRAINT {}
3017impl ::core::clone::Clone for WS_SECURITY_BINDING_PROPERTY_CONSTRAINT {
3018 fn clone(&self) -> Self {
3019 *self
3020 }
3021}
3022#[repr(C)]
3023pub struct WS_SECURITY_BINDING_PROPERTY_CONSTRAINT_0 {
3024 pub securityBindingProperty: WS_SECURITY_BINDING_PROPERTY,
3025}
3026impl ::core::marker::Copy for WS_SECURITY_BINDING_PROPERTY_CONSTRAINT_0 {}
3027impl ::core::clone::Clone for WS_SECURITY_BINDING_PROPERTY_CONSTRAINT_0 {
3028 fn clone(&self) -> Self {
3029 *self
3030 }
3031}
3032pub type WS_SECURITY_BINDING_PROPERTY_ID = i32;
3033pub const WS_SECURITY_BINDING_PROPERTY_REQUIRE_SSL_CLIENT_CERT: WS_SECURITY_BINDING_PROPERTY_ID = 1i32;
3034pub const WS_SECURITY_BINDING_PROPERTY_WINDOWS_INTEGRATED_AUTH_PACKAGE: WS_SECURITY_BINDING_PROPERTY_ID = 2i32;
3035pub const WS_SECURITY_BINDING_PROPERTY_REQUIRE_SERVER_AUTH: WS_SECURITY_BINDING_PROPERTY_ID = 3i32;
3036pub const WS_SECURITY_BINDING_PROPERTY_ALLOW_ANONYMOUS_CLIENTS: WS_SECURITY_BINDING_PROPERTY_ID = 4i32;
3037pub const WS_SECURITY_BINDING_PROPERTY_ALLOWED_IMPERSONATION_LEVEL: WS_SECURITY_BINDING_PROPERTY_ID = 5i32;
3038pub const WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_SCHEME: WS_SECURITY_BINDING_PROPERTY_ID = 6i32;
3039pub const WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_TARGET: WS_SECURITY_BINDING_PROPERTY_ID = 7i32;
3040pub const WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_BASIC_REALM: WS_SECURITY_BINDING_PROPERTY_ID = 8i32;
3041pub const WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_DIGEST_REALM: WS_SECURITY_BINDING_PROPERTY_ID = 9i32;
3042pub const WS_SECURITY_BINDING_PROPERTY_HTTP_HEADER_AUTH_DIGEST_DOMAIN: WS_SECURITY_BINDING_PROPERTY_ID = 10i32;
3043pub const WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_KEY_SIZE: WS_SECURITY_BINDING_PROPERTY_ID = 11i32;
3044pub const WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_KEY_ENTROPY_MODE: WS_SECURITY_BINDING_PROPERTY_ID = 12i32;
3045pub const WS_SECURITY_BINDING_PROPERTY_MESSAGE_PROPERTIES: WS_SECURITY_BINDING_PROPERTY_ID = 13i32;
3046pub const WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_MAX_PENDING_CONTEXTS: WS_SECURITY_BINDING_PROPERTY_ID = 14i32;
3047pub const WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_MAX_ACTIVE_CONTEXTS: WS_SECURITY_BINDING_PROPERTY_ID = 15i32;
3048pub const WS_SECURITY_BINDING_PROPERTY_SECURE_CONVERSATION_VERSION: WS_SECURITY_BINDING_PROPERTY_ID = 16i32;
3049pub const WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_SUPPORT_RENEW: WS_SECURITY_BINDING_PROPERTY_ID = 17i32;
3050pub const WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_RENEWAL_INTERVAL: WS_SECURITY_BINDING_PROPERTY_ID = 18i32;
3051pub const WS_SECURITY_BINDING_PROPERTY_SECURITY_CONTEXT_ROLLOVER_INTERVAL: WS_SECURITY_BINDING_PROPERTY_ID = 19i32;
3052pub const WS_SECURITY_BINDING_PROPERTY_CERT_FAILURES_TO_IGNORE: WS_SECURITY_BINDING_PROPERTY_ID = 20i32;
3053pub const WS_SECURITY_BINDING_PROPERTY_DISABLE_CERT_REVOCATION_CHECK: WS_SECURITY_BINDING_PROPERTY_ID = 21i32;
3054pub const WS_SECURITY_BINDING_PROPERTY_DISALLOWED_SECURE_PROTOCOLS: WS_SECURITY_BINDING_PROPERTY_ID = 22i32;
3055pub const WS_SECURITY_BINDING_PROPERTY_CERTIFICATE_VALIDATION_CALLBACK_CONTEXT: WS_SECURITY_BINDING_PROPERTY_ID = 23i32;
3056pub type WS_SECURITY_BINDING_TYPE = i32;
3057pub const WS_SSL_TRANSPORT_SECURITY_BINDING_TYPE: WS_SECURITY_BINDING_TYPE = 1i32;
3058pub const WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TYPE: WS_SECURITY_BINDING_TYPE = 2i32;
3059pub const WS_HTTP_HEADER_AUTH_SECURITY_BINDING_TYPE: WS_SECURITY_BINDING_TYPE = 3i32;
3060pub const WS_USERNAME_MESSAGE_SECURITY_BINDING_TYPE: WS_SECURITY_BINDING_TYPE = 4i32;
3061pub const WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TYPE: WS_SECURITY_BINDING_TYPE = 5i32;
3062pub const WS_XML_TOKEN_MESSAGE_SECURITY_BINDING_TYPE: WS_SECURITY_BINDING_TYPE = 6i32;
3063pub const WS_SAML_MESSAGE_SECURITY_BINDING_TYPE: WS_SECURITY_BINDING_TYPE = 7i32;
3064pub const WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_TYPE: WS_SECURITY_BINDING_TYPE = 8i32;
3065pub const WS_NAMEDPIPE_SSPI_TRANSPORT_SECURITY_BINDING_TYPE: WS_SECURITY_BINDING_TYPE = 9i32;
3066#[repr(C)]
3067pub struct WS_SECURITY_CONSTRAINTS {
3068 pub securityPropertyConstraints: *mut WS_SECURITY_PROPERTY_CONSTRAINT,
3069 pub securityPropertyConstraintCount: u32,
3070 pub securityBindingConstraints: *mut *mut WS_SECURITY_BINDING_CONSTRAINT,
3071 pub securityBindingConstraintCount: u32,
3072}
3073impl ::core::marker::Copy for WS_SECURITY_CONSTRAINTS {}
3074impl ::core::clone::Clone for WS_SECURITY_CONSTRAINTS {
3075 fn clone(&self) -> Self {
3076 *self
3077 }
3078}
3079#[repr(C)]
3080pub struct WS_SECURITY_CONTEXT(pub u8);
3081#[repr(C)]
3082pub struct WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING {
3083 pub binding: WS_SECURITY_BINDING,
3084 pub bindingUsage: WS_MESSAGE_SECURITY_USAGE,
3085 pub bootstrapSecurityDescription: *mut WS_SECURITY_DESCRIPTION,
3086}
3087impl ::core::marker::Copy for WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING {}
3088impl ::core::clone::Clone for WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING {
3089 fn clone(&self) -> Self {
3090 *self
3091 }
3092}
3093#[repr(C)]
3094pub struct WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_CONSTRAINT {
3095 pub bindingConstraint: WS_SECURITY_BINDING_CONSTRAINT,
3096 pub bindingUsage: WS_MESSAGE_SECURITY_USAGE,
3097 pub bootstrapSecurityConstraint: *mut WS_SECURITY_CONSTRAINTS,
3098}
3099impl ::core::marker::Copy for WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_CONSTRAINT {}
3100impl ::core::clone::Clone for WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_CONSTRAINT {
3101 fn clone(&self) -> Self {
3102 *self
3103 }
3104}
3105#[repr(C)]
3106pub struct WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION {
3107 pub securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
3108 pub bindingUsage: WS_MESSAGE_SECURITY_USAGE,
3109}
3110impl ::core::marker::Copy for WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION {}
3111impl ::core::clone::Clone for WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION {
3112 fn clone(&self) -> Self {
3113 *self
3114 }
3115}
3116#[repr(C)]
3117pub struct WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_TEMPLATE {
3118 pub securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
3119}
3120impl ::core::marker::Copy for WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_TEMPLATE {}
3121impl ::core::clone::Clone for WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_TEMPLATE {
3122 fn clone(&self) -> Self {
3123 *self
3124 }
3125}
3126#[repr(C)]
3127pub struct WS_SECURITY_CONTEXT_PROPERTY {
3128 pub id: WS_SECURITY_CONTEXT_PROPERTY_ID,
3129 pub value: *mut ::core::ffi::c_void,
3130 pub valueSize: u32,
3131}
3132impl ::core::marker::Copy for WS_SECURITY_CONTEXT_PROPERTY {}
3133impl ::core::clone::Clone for WS_SECURITY_CONTEXT_PROPERTY {
3134 fn clone(&self) -> Self {
3135 *self
3136 }
3137}
3138pub type WS_SECURITY_CONTEXT_PROPERTY_ID = i32;
3139pub const WS_SECURITY_CONTEXT_PROPERTY_IDENTIFIER: WS_SECURITY_CONTEXT_PROPERTY_ID = 1i32;
3140pub const WS_SECURITY_CONTEXT_PROPERTY_USERNAME: WS_SECURITY_CONTEXT_PROPERTY_ID = 2i32;
3141pub const WS_SECURITY_CONTEXT_PROPERTY_MESSAGE_SECURITY_WINDOWS_TOKEN: WS_SECURITY_CONTEXT_PROPERTY_ID = 3i32;
3142pub const WS_SECURITY_CONTEXT_PROPERTY_SAML_ASSERTION: WS_SECURITY_CONTEXT_PROPERTY_ID = 4i32;
3143#[repr(C)]
3144pub struct WS_SECURITY_CONTEXT_SECURITY_BINDING_POLICY_DESCRIPTION {
3145 pub securityContextMessageSecurityBinding: WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION,
3146 pub securityProperties: WS_SECURITY_PROPERTIES,
3147}
3148impl ::core::marker::Copy for WS_SECURITY_CONTEXT_SECURITY_BINDING_POLICY_DESCRIPTION {}
3149impl ::core::clone::Clone for WS_SECURITY_CONTEXT_SECURITY_BINDING_POLICY_DESCRIPTION {
3150 fn clone(&self) -> Self {
3151 *self
3152 }
3153}
3154#[repr(C)]
3155pub struct WS_SECURITY_CONTEXT_SECURITY_BINDING_TEMPLATE {
3156 pub securityContextMessageSecurityBinding: WS_SECURITY_CONTEXT_MESSAGE_SECURITY_BINDING_TEMPLATE,
3157 pub securityProperties: WS_SECURITY_PROPERTIES,
3158}
3159impl ::core::marker::Copy for WS_SECURITY_CONTEXT_SECURITY_BINDING_TEMPLATE {}
3160impl ::core::clone::Clone for WS_SECURITY_CONTEXT_SECURITY_BINDING_TEMPLATE {
3161 fn clone(&self) -> Self {
3162 *self
3163 }
3164}
3165#[repr(C)]
3166pub struct WS_SECURITY_DESCRIPTION {
3167 pub securityBindings: *mut *mut WS_SECURITY_BINDING,
3168 pub securityBindingCount: u32,
3169 pub properties: *mut WS_SECURITY_PROPERTY,
3170 pub propertyCount: u32,
3171}
3172impl ::core::marker::Copy for WS_SECURITY_DESCRIPTION {}
3173impl ::core::clone::Clone for WS_SECURITY_DESCRIPTION {
3174 fn clone(&self) -> Self {
3175 *self
3176 }
3177}
3178pub type WS_SECURITY_HEADER_LAYOUT = i32;
3179pub const WS_SECURITY_HEADER_LAYOUT_STRICT: WS_SECURITY_HEADER_LAYOUT = 1i32;
3180pub const WS_SECURITY_HEADER_LAYOUT_LAX: WS_SECURITY_HEADER_LAYOUT = 2i32;
3181pub const WS_SECURITY_HEADER_LAYOUT_LAX_WITH_TIMESTAMP_FIRST: WS_SECURITY_HEADER_LAYOUT = 3i32;
3182pub const WS_SECURITY_HEADER_LAYOUT_LAX_WITH_TIMESTAMP_LAST: WS_SECURITY_HEADER_LAYOUT = 4i32;
3183pub type WS_SECURITY_HEADER_VERSION = i32;
3184pub const WS_SECURITY_HEADER_VERSION_1_0: WS_SECURITY_HEADER_VERSION = 1i32;
3185pub const WS_SECURITY_HEADER_VERSION_1_1: WS_SECURITY_HEADER_VERSION = 2i32;
3186pub type WS_SECURITY_KEY_ENTROPY_MODE = i32;
3187pub const WS_SECURITY_KEY_ENTROPY_MODE_CLIENT_ONLY: WS_SECURITY_KEY_ENTROPY_MODE = 1i32;
3188pub const WS_SECURITY_KEY_ENTROPY_MODE_SERVER_ONLY: WS_SECURITY_KEY_ENTROPY_MODE = 2i32;
3189pub const WS_SECURITY_KEY_ENTROPY_MODE_COMBINED: WS_SECURITY_KEY_ENTROPY_MODE = 3i32;
3190#[repr(C)]
3191pub struct WS_SECURITY_KEY_HANDLE {
3192 pub keyHandleType: WS_SECURITY_KEY_HANDLE_TYPE,
3193}
3194impl ::core::marker::Copy for WS_SECURITY_KEY_HANDLE {}
3195impl ::core::clone::Clone for WS_SECURITY_KEY_HANDLE {
3196 fn clone(&self) -> Self {
3197 *self
3198 }
3199}
3200pub type WS_SECURITY_KEY_HANDLE_TYPE = i32;
3201pub const WS_RAW_SYMMETRIC_SECURITY_KEY_HANDLE_TYPE: WS_SECURITY_KEY_HANDLE_TYPE = 1i32;
3202pub const WS_NCRYPT_ASYMMETRIC_SECURITY_KEY_HANDLE_TYPE: WS_SECURITY_KEY_HANDLE_TYPE = 2i32;
3203pub const WS_CAPI_ASYMMETRIC_SECURITY_KEY_HANDLE_TYPE: WS_SECURITY_KEY_HANDLE_TYPE = 3i32;
3204pub type WS_SECURITY_KEY_TYPE = i32;
3205pub const WS_SECURITY_KEY_TYPE_NONE: WS_SECURITY_KEY_TYPE = 1i32;
3206pub const WS_SECURITY_KEY_TYPE_SYMMETRIC: WS_SECURITY_KEY_TYPE = 2i32;
3207pub const WS_SECURITY_KEY_TYPE_ASYMMETRIC: WS_SECURITY_KEY_TYPE = 3i32;
3208#[repr(C)]
3209pub struct WS_SECURITY_PROPERTIES {
3210 pub properties: *mut WS_SECURITY_PROPERTY,
3211 pub propertyCount: u32,
3212}
3213impl ::core::marker::Copy for WS_SECURITY_PROPERTIES {}
3214impl ::core::clone::Clone for WS_SECURITY_PROPERTIES {
3215 fn clone(&self) -> Self {
3216 *self
3217 }
3218}
3219#[repr(C)]
3220pub struct WS_SECURITY_PROPERTY {
3221 pub id: WS_SECURITY_PROPERTY_ID,
3222 pub value: *mut ::core::ffi::c_void,
3223 pub valueSize: u32,
3224}
3225impl ::core::marker::Copy for WS_SECURITY_PROPERTY {}
3226impl ::core::clone::Clone for WS_SECURITY_PROPERTY {
3227 fn clone(&self) -> Self {
3228 *self
3229 }
3230}
3231#[repr(C)]
3232pub struct WS_SECURITY_PROPERTY_CONSTRAINT {
3233 pub id: WS_SECURITY_PROPERTY_ID,
3234 pub allowedValues: *mut ::core::ffi::c_void,
3235 pub allowedValuesSize: u32,
3236 pub out: WS_SECURITY_PROPERTY_CONSTRAINT_0,
3237}
3238impl ::core::marker::Copy for WS_SECURITY_PROPERTY_CONSTRAINT {}
3239impl ::core::clone::Clone for WS_SECURITY_PROPERTY_CONSTRAINT {
3240 fn clone(&self) -> Self {
3241 *self
3242 }
3243}
3244#[repr(C)]
3245pub struct WS_SECURITY_PROPERTY_CONSTRAINT_0 {
3246 pub securityProperty: WS_SECURITY_PROPERTY,
3247}
3248impl ::core::marker::Copy for WS_SECURITY_PROPERTY_CONSTRAINT_0 {}
3249impl ::core::clone::Clone for WS_SECURITY_PROPERTY_CONSTRAINT_0 {
3250 fn clone(&self) -> Self {
3251 *self
3252 }
3253}
3254pub type WS_SECURITY_PROPERTY_ID = i32;
3255pub const WS_SECURITY_PROPERTY_TRANSPORT_PROTECTION_LEVEL: WS_SECURITY_PROPERTY_ID = 1i32;
3256pub const WS_SECURITY_PROPERTY_ALGORITHM_SUITE: WS_SECURITY_PROPERTY_ID = 2i32;
3257pub const WS_SECURITY_PROPERTY_ALGORITHM_SUITE_NAME: WS_SECURITY_PROPERTY_ID = 3i32;
3258pub const WS_SECURITY_PROPERTY_MAX_ALLOWED_LATENCY: WS_SECURITY_PROPERTY_ID = 4i32;
3259pub const WS_SECURITY_PROPERTY_TIMESTAMP_VALIDITY_DURATION: WS_SECURITY_PROPERTY_ID = 5i32;
3260pub const WS_SECURITY_PROPERTY_MAX_ALLOWED_CLOCK_SKEW: WS_SECURITY_PROPERTY_ID = 6i32;
3261pub const WS_SECURITY_PROPERTY_TIMESTAMP_USAGE: WS_SECURITY_PROPERTY_ID = 7i32;
3262pub const WS_SECURITY_PROPERTY_SECURITY_HEADER_LAYOUT: WS_SECURITY_PROPERTY_ID = 8i32;
3263pub const WS_SECURITY_PROPERTY_SECURITY_HEADER_VERSION: WS_SECURITY_PROPERTY_ID = 9i32;
3264pub const WS_SECURITY_PROPERTY_EXTENDED_PROTECTION_POLICY: WS_SECURITY_PROPERTY_ID = 10i32;
3265pub const WS_SECURITY_PROPERTY_EXTENDED_PROTECTION_SCENARIO: WS_SECURITY_PROPERTY_ID = 11i32;
3266pub const WS_SECURITY_PROPERTY_SERVICE_IDENTITIES: WS_SECURITY_PROPERTY_ID = 12i32;
3267pub type WS_SECURITY_TIMESTAMP_USAGE = i32;
3268pub const WS_SECURITY_TIMESTAMP_USAGE_ALWAYS: WS_SECURITY_TIMESTAMP_USAGE = 1i32;
3269pub const WS_SECURITY_TIMESTAMP_USAGE_NEVER: WS_SECURITY_TIMESTAMP_USAGE = 2i32;
3270pub const WS_SECURITY_TIMESTAMP_USAGE_REQUESTS_ONLY: WS_SECURITY_TIMESTAMP_USAGE = 3i32;
3271#[repr(C)]
3272pub struct WS_SECURITY_TOKEN(pub u8);
3273pub type WS_SECURITY_TOKEN_PROPERTY_ID = i32;
3274pub const WS_SECURITY_TOKEN_PROPERTY_KEY_TYPE: WS_SECURITY_TOKEN_PROPERTY_ID = 1i32;
3275pub const WS_SECURITY_TOKEN_PROPERTY_VALID_FROM_TIME: WS_SECURITY_TOKEN_PROPERTY_ID = 2i32;
3276pub const WS_SECURITY_TOKEN_PROPERTY_VALID_TILL_TIME: WS_SECURITY_TOKEN_PROPERTY_ID = 3i32;
3277pub const WS_SECURITY_TOKEN_PROPERTY_SERIALIZED_XML: WS_SECURITY_TOKEN_PROPERTY_ID = 4i32;
3278pub const WS_SECURITY_TOKEN_PROPERTY_ATTACHED_REFERENCE_XML: WS_SECURITY_TOKEN_PROPERTY_ID = 5i32;
3279pub const WS_SECURITY_TOKEN_PROPERTY_UNATTACHED_REFERENCE_XML: WS_SECURITY_TOKEN_PROPERTY_ID = 6i32;
3280pub const WS_SECURITY_TOKEN_PROPERTY_SYMMETRIC_KEY: WS_SECURITY_TOKEN_PROPERTY_ID = 7i32;
3281pub type WS_SECURITY_TOKEN_REFERENCE_MODE = i32;
3282pub const WS_SECURITY_TOKEN_REFERENCE_MODE_LOCAL_ID: WS_SECURITY_TOKEN_REFERENCE_MODE = 1i32;
3283pub const WS_SECURITY_TOKEN_REFERENCE_MODE_XML_BUFFER: WS_SECURITY_TOKEN_REFERENCE_MODE = 2i32;
3284pub const WS_SECURITY_TOKEN_REFERENCE_MODE_CERT_THUMBPRINT: WS_SECURITY_TOKEN_REFERENCE_MODE = 3i32;
3285pub const WS_SECURITY_TOKEN_REFERENCE_MODE_SECURITY_CONTEXT_ID: WS_SECURITY_TOKEN_REFERENCE_MODE = 4i32;
3286pub const WS_SECURITY_TOKEN_REFERENCE_MODE_SAML_ASSERTION_ID: WS_SECURITY_TOKEN_REFERENCE_MODE = 5i32;
3287pub type WS_SERVICE_ACCEPT_CHANNEL_CALLBACK = unsafe extern "system" fn(context: *const WS_OPERATION_CONTEXT, channelstate: *mut *mut ::core::ffi::c_void, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
3288pub type WS_SERVICE_CANCEL_REASON = i32;
3289pub const WS_SERVICE_HOST_ABORT: WS_SERVICE_CANCEL_REASON = 0i32;
3290pub const WS_SERVICE_CHANNEL_FAULTED: WS_SERVICE_CANCEL_REASON = 1i32;
3291pub type WS_SERVICE_CLOSE_CHANNEL_CALLBACK = unsafe extern "system" fn(context: *const WS_OPERATION_CONTEXT, asynccontext: *const WS_ASYNC_CONTEXT) -> ::windows_sys::core::HRESULT;
3292#[repr(C)]
3293#[cfg(feature = "Win32_Foundation")]
3294pub struct WS_SERVICE_CONTRACT {
3295 pub contractDescription: *mut WS_CONTRACT_DESCRIPTION,
3296 pub defaultMessageHandlerCallback: WS_SERVICE_MESSAGE_RECEIVE_CALLBACK,
3297 pub methodTable: *mut ::core::ffi::c_void,
3298}
3299#[cfg(feature = "Win32_Foundation")]
3300impl ::core::marker::Copy for WS_SERVICE_CONTRACT {}
3301#[cfg(feature = "Win32_Foundation")]
3302impl ::core::clone::Clone for WS_SERVICE_CONTRACT {
3303 fn clone(&self) -> Self {
3304 *self
3305 }
3306}
3307#[repr(C)]
3308#[cfg(feature = "Win32_Foundation")]
3309pub struct WS_SERVICE_ENDPOINT {
3310 pub address: WS_ENDPOINT_ADDRESS,
3311 pub channelBinding: WS_CHANNEL_BINDING,
3312 pub channelType: WS_CHANNEL_TYPE,
3313 pub securityDescription: *mut WS_SECURITY_DESCRIPTION,
3314 pub contract: *mut WS_SERVICE_CONTRACT,
3315 pub authorizationCallback: WS_SERVICE_SECURITY_CALLBACK,
3316 pub properties: *mut WS_SERVICE_ENDPOINT_PROPERTY,
3317 pub propertyCount: u32,
3318 pub channelProperties: WS_CHANNEL_PROPERTIES,
3319}
3320#[cfg(feature = "Win32_Foundation")]
3321impl ::core::marker::Copy for WS_SERVICE_ENDPOINT {}
3322#[cfg(feature = "Win32_Foundation")]
3323impl ::core::clone::Clone for WS_SERVICE_ENDPOINT {
3324 fn clone(&self) -> Self {
3325 *self
3326 }
3327}
3328#[repr(C)]
3329#[cfg(feature = "Win32_Foundation")]
3330pub struct WS_SERVICE_ENDPOINT_METADATA {
3331 pub portName: *mut WS_XML_STRING,
3332 pub bindingName: *mut WS_XML_STRING,
3333 pub bindingNs: *mut WS_XML_STRING,
3334}
3335#[cfg(feature = "Win32_Foundation")]
3336impl ::core::marker::Copy for WS_SERVICE_ENDPOINT_METADATA {}
3337#[cfg(feature = "Win32_Foundation")]
3338impl ::core::clone::Clone for WS_SERVICE_ENDPOINT_METADATA {
3339 fn clone(&self) -> Self {
3340 *self
3341 }
3342}
3343#[repr(C)]
3344pub struct WS_SERVICE_ENDPOINT_PROPERTY {
3345 pub id: WS_SERVICE_ENDPOINT_PROPERTY_ID,
3346 pub value: *mut ::core::ffi::c_void,
3347 pub valueSize: u32,
3348}
3349impl ::core::marker::Copy for WS_SERVICE_ENDPOINT_PROPERTY {}
3350impl ::core::clone::Clone for WS_SERVICE_ENDPOINT_PROPERTY {
3351 fn clone(&self) -> Self {
3352 *self
3353 }
3354}
3355pub type WS_SERVICE_ENDPOINT_PROPERTY_ID = i32;
3356pub const WS_SERVICE_ENDPOINT_PROPERTY_ACCEPT_CHANNEL_CALLBACK: WS_SERVICE_ENDPOINT_PROPERTY_ID = 0i32;
3357pub const WS_SERVICE_ENDPOINT_PROPERTY_CLOSE_CHANNEL_CALLBACK: WS_SERVICE_ENDPOINT_PROPERTY_ID = 1i32;
3358pub const WS_SERVICE_ENDPOINT_PROPERTY_MAX_ACCEPTING_CHANNELS: WS_SERVICE_ENDPOINT_PROPERTY_ID = 2i32;
3359pub const WS_SERVICE_ENDPOINT_PROPERTY_MAX_CONCURRENCY: WS_SERVICE_ENDPOINT_PROPERTY_ID = 3i32;
3360pub const WS_SERVICE_ENDPOINT_PROPERTY_BODY_HEAP_MAX_SIZE: WS_SERVICE_ENDPOINT_PROPERTY_ID = 4i32;
3361pub const WS_SERVICE_ENDPOINT_PROPERTY_BODY_HEAP_TRIM_SIZE: WS_SERVICE_ENDPOINT_PROPERTY_ID = 5i32;
3362pub const WS_SERVICE_ENDPOINT_PROPERTY_MESSAGE_PROPERTIES: WS_SERVICE_ENDPOINT_PROPERTY_ID = 6i32;
3363pub const WS_SERVICE_ENDPOINT_PROPERTY_MAX_CALL_POOL_SIZE: WS_SERVICE_ENDPOINT_PROPERTY_ID = 7i32;
3364pub const WS_SERVICE_ENDPOINT_PROPERTY_MAX_CHANNEL_POOL_SIZE: WS_SERVICE_ENDPOINT_PROPERTY_ID = 8i32;
3365pub const WS_SERVICE_ENDPOINT_PROPERTY_LISTENER_PROPERTIES: WS_SERVICE_ENDPOINT_PROPERTY_ID = 9i32;
3366pub const WS_SERVICE_ENDPOINT_PROPERTY_CHECK_MUST_UNDERSTAND: WS_SERVICE_ENDPOINT_PROPERTY_ID = 10i32;
3367pub const WS_SERVICE_ENDPOINT_PROPERTY_METADATA_EXCHANGE_TYPE: WS_SERVICE_ENDPOINT_PROPERTY_ID = 11i32;
3368pub const WS_SERVICE_ENDPOINT_PROPERTY_METADATA: WS_SERVICE_ENDPOINT_PROPERTY_ID = 12i32;
3369pub const WS_SERVICE_ENDPOINT_PROPERTY_METADATA_EXCHANGE_URL_SUFFIX: WS_SERVICE_ENDPOINT_PROPERTY_ID = 13i32;
3370pub const WS_SERVICE_ENDPOINT_PROPERTY_MAX_CHANNELS: WS_SERVICE_ENDPOINT_PROPERTY_ID = 14i32;
3371#[repr(C)]
3372pub struct WS_SERVICE_HOST(pub u8);
3373pub type WS_SERVICE_HOST_STATE = i32;
3374pub const WS_SERVICE_HOST_STATE_CREATED: WS_SERVICE_HOST_STATE = 0i32;
3375pub const WS_SERVICE_HOST_STATE_OPENING: WS_SERVICE_HOST_STATE = 1i32;
3376pub const WS_SERVICE_HOST_STATE_OPEN: WS_SERVICE_HOST_STATE = 2i32;
3377pub const WS_SERVICE_HOST_STATE_CLOSING: WS_SERVICE_HOST_STATE = 3i32;
3378pub const WS_SERVICE_HOST_STATE_CLOSED: WS_SERVICE_HOST_STATE = 4i32;
3379pub const WS_SERVICE_HOST_STATE_FAULTED: WS_SERVICE_HOST_STATE = 5i32;
3380pub type WS_SERVICE_MESSAGE_RECEIVE_CALLBACK = unsafe extern "system" fn(context: *const WS_OPERATION_CONTEXT, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
3381#[repr(C)]
3382#[cfg(feature = "Win32_Foundation")]
3383pub struct WS_SERVICE_METADATA {
3384 pub documentCount: u32,
3385 pub documents: *mut *mut WS_SERVICE_METADATA_DOCUMENT,
3386 pub serviceName: *mut WS_XML_STRING,
3387 pub serviceNs: *mut WS_XML_STRING,
3388}
3389#[cfg(feature = "Win32_Foundation")]
3390impl ::core::marker::Copy for WS_SERVICE_METADATA {}
3391#[cfg(feature = "Win32_Foundation")]
3392impl ::core::clone::Clone for WS_SERVICE_METADATA {
3393 fn clone(&self) -> Self {
3394 *self
3395 }
3396}
3397#[repr(C)]
3398#[cfg(feature = "Win32_Foundation")]
3399pub struct WS_SERVICE_METADATA_DOCUMENT {
3400 pub content: *mut WS_XML_STRING,
3401 pub name: *mut WS_STRING,
3402}
3403#[cfg(feature = "Win32_Foundation")]
3404impl ::core::marker::Copy for WS_SERVICE_METADATA_DOCUMENT {}
3405#[cfg(feature = "Win32_Foundation")]
3406impl ::core::clone::Clone for WS_SERVICE_METADATA_DOCUMENT {
3407 fn clone(&self) -> Self {
3408 *self
3409 }
3410}
3411pub const WS_SERVICE_OPERATION_MESSAGE_NILLABLE_ELEMENT: i32 = 1i32;
3412#[repr(C)]
3413pub struct WS_SERVICE_PROPERTY {
3414 pub id: WS_SERVICE_PROPERTY_ID,
3415 pub value: *mut ::core::ffi::c_void,
3416 pub valueSize: u32,
3417}
3418impl ::core::marker::Copy for WS_SERVICE_PROPERTY {}
3419impl ::core::clone::Clone for WS_SERVICE_PROPERTY {
3420 fn clone(&self) -> Self {
3421 *self
3422 }
3423}
3424#[repr(C)]
3425pub struct WS_SERVICE_PROPERTY_ACCEPT_CALLBACK {
3426 pub callback: WS_SERVICE_ACCEPT_CHANNEL_CALLBACK,
3427}
3428impl ::core::marker::Copy for WS_SERVICE_PROPERTY_ACCEPT_CALLBACK {}
3429impl ::core::clone::Clone for WS_SERVICE_PROPERTY_ACCEPT_CALLBACK {
3430 fn clone(&self) -> Self {
3431 *self
3432 }
3433}
3434#[repr(C)]
3435pub struct WS_SERVICE_PROPERTY_CLOSE_CALLBACK {
3436 pub callback: WS_SERVICE_CLOSE_CHANNEL_CALLBACK,
3437}
3438impl ::core::marker::Copy for WS_SERVICE_PROPERTY_CLOSE_CALLBACK {}
3439impl ::core::clone::Clone for WS_SERVICE_PROPERTY_CLOSE_CALLBACK {
3440 fn clone(&self) -> Self {
3441 *self
3442 }
3443}
3444pub type WS_SERVICE_PROPERTY_ID = i32;
3445pub const WS_SERVICE_PROPERTY_HOST_USER_STATE: WS_SERVICE_PROPERTY_ID = 0i32;
3446pub const WS_SERVICE_PROPERTY_FAULT_DISCLOSURE: WS_SERVICE_PROPERTY_ID = 1i32;
3447pub const WS_SERVICE_PROPERTY_FAULT_LANGID: WS_SERVICE_PROPERTY_ID = 2i32;
3448pub const WS_SERVICE_PROPERTY_HOST_STATE: WS_SERVICE_PROPERTY_ID = 3i32;
3449pub const WS_SERVICE_PROPERTY_METADATA: WS_SERVICE_PROPERTY_ID = 4i32;
3450pub const WS_SERVICE_PROPERTY_CLOSE_TIMEOUT: WS_SERVICE_PROPERTY_ID = 5i32;
3451#[repr(C)]
3452pub struct WS_SERVICE_PROXY(pub u8);
3453pub type WS_SERVICE_PROXY_STATE = i32;
3454pub const WS_SERVICE_PROXY_STATE_CREATED: WS_SERVICE_PROXY_STATE = 0i32;
3455pub const WS_SERVICE_PROXY_STATE_OPENING: WS_SERVICE_PROXY_STATE = 1i32;
3456pub const WS_SERVICE_PROXY_STATE_OPEN: WS_SERVICE_PROXY_STATE = 2i32;
3457pub const WS_SERVICE_PROXY_STATE_CLOSING: WS_SERVICE_PROXY_STATE = 3i32;
3458pub const WS_SERVICE_PROXY_STATE_CLOSED: WS_SERVICE_PROXY_STATE = 4i32;
3459pub const WS_SERVICE_PROXY_STATE_FAULTED: WS_SERVICE_PROXY_STATE = 5i32;
3460#[cfg(feature = "Win32_Foundation")]
3461pub type WS_SERVICE_SECURITY_CALLBACK = unsafe extern "system" fn(context: *const WS_OPERATION_CONTEXT, authorized: *mut super::super::Foundation::BOOL, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
3462#[repr(C)]
3463#[cfg(feature = "Win32_Foundation")]
3464pub struct WS_SERVICE_SECURITY_IDENTITIES {
3465 pub serviceIdentities: *mut WS_STRING,
3466 pub serviceIdentityCount: u32,
3467}
3468#[cfg(feature = "Win32_Foundation")]
3469impl ::core::marker::Copy for WS_SERVICE_SECURITY_IDENTITIES {}
3470#[cfg(feature = "Win32_Foundation")]
3471impl ::core::clone::Clone for WS_SERVICE_SECURITY_IDENTITIES {
3472 fn clone(&self) -> Self {
3473 *self
3474 }
3475}
3476pub type WS_SERVICE_STUB_CALLBACK = unsafe extern "system" fn(context: *const WS_OPERATION_CONTEXT, frame: *const ::core::ffi::c_void, callback: *const ::core::ffi::c_void, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
3477pub type WS_SET_CHANNEL_PROPERTY_CALLBACK = unsafe extern "system" fn(channelinstance: *const ::core::ffi::c_void, id: WS_CHANNEL_PROPERTY_ID, value: *const ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
3478pub type WS_SET_LISTENER_PROPERTY_CALLBACK = unsafe extern "system" fn(listenerinstance: *const ::core::ffi::c_void, id: WS_LISTENER_PROPERTY_ID, value: *const ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
3479pub type WS_SHUTDOWN_SESSION_CHANNEL_CALLBACK = unsafe extern "system" fn(channelinstance: *const ::core::ffi::c_void, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
3480#[repr(C)]
3481#[cfg(feature = "Win32_Foundation")]
3482pub struct WS_SOAPUDP_URL {
3483 pub url: WS_URL,
3484 pub host: WS_STRING,
3485 pub port: u16,
3486 pub portAsString: WS_STRING,
3487 pub path: WS_STRING,
3488 pub query: WS_STRING,
3489 pub fragment: WS_STRING,
3490}
3491#[cfg(feature = "Win32_Foundation")]
3492impl ::core::marker::Copy for WS_SOAPUDP_URL {}
3493#[cfg(feature = "Win32_Foundation")]
3494impl ::core::clone::Clone for WS_SOAPUDP_URL {
3495 fn clone(&self) -> Self {
3496 *self
3497 }
3498}
3499#[repr(C)]
3500#[cfg(feature = "Win32_Foundation")]
3501pub struct WS_SPN_ENDPOINT_IDENTITY {
3502 pub identity: WS_ENDPOINT_IDENTITY,
3503 pub spn: WS_STRING,
3504}
3505#[cfg(feature = "Win32_Foundation")]
3506impl ::core::marker::Copy for WS_SPN_ENDPOINT_IDENTITY {}
3507#[cfg(feature = "Win32_Foundation")]
3508impl ::core::clone::Clone for WS_SPN_ENDPOINT_IDENTITY {
3509 fn clone(&self) -> Self {
3510 *self
3511 }
3512}
3513#[repr(C)]
3514pub struct WS_SSL_TRANSPORT_SECURITY_BINDING {
3515 pub binding: WS_SECURITY_BINDING,
3516 pub localCertCredential: *mut WS_CERT_CREDENTIAL,
3517}
3518impl ::core::marker::Copy for WS_SSL_TRANSPORT_SECURITY_BINDING {}
3519impl ::core::clone::Clone for WS_SSL_TRANSPORT_SECURITY_BINDING {
3520 fn clone(&self) -> Self {
3521 *self
3522 }
3523}
3524#[repr(C)]
3525#[cfg(feature = "Win32_Foundation")]
3526pub struct WS_SSL_TRANSPORT_SECURITY_BINDING_CONSTRAINT {
3527 pub bindingConstraint: WS_SECURITY_BINDING_CONSTRAINT,
3528 pub out: WS_SSL_TRANSPORT_SECURITY_BINDING_CONSTRAINT_0,
3529}
3530#[cfg(feature = "Win32_Foundation")]
3531impl ::core::marker::Copy for WS_SSL_TRANSPORT_SECURITY_BINDING_CONSTRAINT {}
3532#[cfg(feature = "Win32_Foundation")]
3533impl ::core::clone::Clone for WS_SSL_TRANSPORT_SECURITY_BINDING_CONSTRAINT {
3534 fn clone(&self) -> Self {
3535 *self
3536 }
3537}
3538#[repr(C)]
3539#[cfg(feature = "Win32_Foundation")]
3540pub struct WS_SSL_TRANSPORT_SECURITY_BINDING_CONSTRAINT_0 {
3541 pub clientCertCredentialRequired: super::super::Foundation::BOOL,
3542}
3543#[cfg(feature = "Win32_Foundation")]
3544impl ::core::marker::Copy for WS_SSL_TRANSPORT_SECURITY_BINDING_CONSTRAINT_0 {}
3545#[cfg(feature = "Win32_Foundation")]
3546impl ::core::clone::Clone for WS_SSL_TRANSPORT_SECURITY_BINDING_CONSTRAINT_0 {
3547 fn clone(&self) -> Self {
3548 *self
3549 }
3550}
3551#[repr(C)]
3552pub struct WS_SSL_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION {
3553 pub securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
3554}
3555impl ::core::marker::Copy for WS_SSL_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION {}
3556impl ::core::clone::Clone for WS_SSL_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION {
3557 fn clone(&self) -> Self {
3558 *self
3559 }
3560}
3561#[repr(C)]
3562pub struct WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE {
3563 pub securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
3564 pub localCertCredential: *mut WS_CERT_CREDENTIAL,
3565}
3566impl ::core::marker::Copy for WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE {}
3567impl ::core::clone::Clone for WS_SSL_TRANSPORT_SECURITY_BINDING_TEMPLATE {
3568 fn clone(&self) -> Self {
3569 *self
3570 }
3571}
3572#[repr(C)]
3573pub struct WS_SSPI_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION {
3574 pub securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
3575}
3576impl ::core::marker::Copy for WS_SSPI_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION {}
3577impl ::core::clone::Clone for WS_SSPI_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION {
3578 fn clone(&self) -> Self {
3579 *self
3580 }
3581}
3582#[repr(C)]
3583#[cfg(feature = "Win32_Foundation")]
3584pub struct WS_STRING {
3585 pub length: u32,
3586 pub chars: super::super::Foundation::PWSTR,
3587}
3588#[cfg(feature = "Win32_Foundation")]
3589impl ::core::marker::Copy for WS_STRING {}
3590#[cfg(feature = "Win32_Foundation")]
3591impl ::core::clone::Clone for WS_STRING {
3592 fn clone(&self) -> Self {
3593 *self
3594 }
3595}
3596#[repr(C)]
3597pub struct WS_STRING_DESCRIPTION {
3598 pub minCharCount: u32,
3599 pub maxCharCount: u32,
3600}
3601impl ::core::marker::Copy for WS_STRING_DESCRIPTION {}
3602impl ::core::clone::Clone for WS_STRING_DESCRIPTION {
3603 fn clone(&self) -> Self {
3604 *self
3605 }
3606}
3607#[repr(C)]
3608#[cfg(feature = "Win32_Foundation")]
3609pub struct WS_STRING_USERNAME_CREDENTIAL {
3610 pub credential: WS_USERNAME_CREDENTIAL,
3611 pub username: WS_STRING,
3612 pub password: WS_STRING,
3613}
3614#[cfg(feature = "Win32_Foundation")]
3615impl ::core::marker::Copy for WS_STRING_USERNAME_CREDENTIAL {}
3616#[cfg(feature = "Win32_Foundation")]
3617impl ::core::clone::Clone for WS_STRING_USERNAME_CREDENTIAL {
3618 fn clone(&self) -> Self {
3619 *self
3620 }
3621}
3622#[repr(C)]
3623#[cfg(feature = "Win32_Foundation")]
3624pub struct WS_STRING_WINDOWS_INTEGRATED_AUTH_CREDENTIAL {
3625 pub credential: WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
3626 pub username: WS_STRING,
3627 pub password: WS_STRING,
3628 pub domain: WS_STRING,
3629}
3630#[cfg(feature = "Win32_Foundation")]
3631impl ::core::marker::Copy for WS_STRING_WINDOWS_INTEGRATED_AUTH_CREDENTIAL {}
3632#[cfg(feature = "Win32_Foundation")]
3633impl ::core::clone::Clone for WS_STRING_WINDOWS_INTEGRATED_AUTH_CREDENTIAL {
3634 fn clone(&self) -> Self {
3635 *self
3636 }
3637}
3638pub const WS_STRUCT_ABSTRACT: i32 = 1i32;
3639#[repr(C)]
3640#[cfg(feature = "Win32_Foundation")]
3641pub struct WS_STRUCT_DESCRIPTION {
3642 pub size: u32,
3643 pub alignment: u32,
3644 pub fields: *mut *mut WS_FIELD_DESCRIPTION,
3645 pub fieldCount: u32,
3646 pub typeLocalName: *mut WS_XML_STRING,
3647 pub typeNs: *mut WS_XML_STRING,
3648 pub parentType: *mut WS_STRUCT_DESCRIPTION,
3649 pub subTypes: *mut *mut WS_STRUCT_DESCRIPTION,
3650 pub subTypeCount: u32,
3651 pub structOptions: u32,
3652}
3653#[cfg(feature = "Win32_Foundation")]
3654impl ::core::marker::Copy for WS_STRUCT_DESCRIPTION {}
3655#[cfg(feature = "Win32_Foundation")]
3656impl ::core::clone::Clone for WS_STRUCT_DESCRIPTION {
3657 fn clone(&self) -> Self {
3658 *self
3659 }
3660}
3661pub const WS_STRUCT_IGNORE_TRAILING_ELEMENT_CONTENT: i32 = 2i32;
3662pub const WS_STRUCT_IGNORE_UNHANDLED_ATTRIBUTES: i32 = 4i32;
3663#[repr(C)]
3664#[cfg(feature = "Win32_Foundation")]
3665pub struct WS_SUBJECT_NAME_CERT_CREDENTIAL {
3666 pub credential: WS_CERT_CREDENTIAL,
3667 pub storeLocation: u32,
3668 pub storeName: WS_STRING,
3669 pub subjectName: WS_STRING,
3670}
3671#[cfg(feature = "Win32_Foundation")]
3672impl ::core::marker::Copy for WS_SUBJECT_NAME_CERT_CREDENTIAL {}
3673#[cfg(feature = "Win32_Foundation")]
3674impl ::core::clone::Clone for WS_SUBJECT_NAME_CERT_CREDENTIAL {
3675 fn clone(&self) -> Self {
3676 *self
3677 }
3678}
3679#[repr(C)]
3680pub struct WS_TCP_BINDING_TEMPLATE {
3681 pub channelProperties: WS_CHANNEL_PROPERTIES,
3682}
3683impl ::core::marker::Copy for WS_TCP_BINDING_TEMPLATE {}
3684impl ::core::clone::Clone for WS_TCP_BINDING_TEMPLATE {
3685 fn clone(&self) -> Self {
3686 *self
3687 }
3688}
3689#[repr(C)]
3690pub struct WS_TCP_POLICY_DESCRIPTION {
3691 pub channelProperties: WS_CHANNEL_PROPERTIES,
3692}
3693impl ::core::marker::Copy for WS_TCP_POLICY_DESCRIPTION {}
3694impl ::core::clone::Clone for WS_TCP_POLICY_DESCRIPTION {
3695 fn clone(&self) -> Self {
3696 *self
3697 }
3698}
3699#[repr(C)]
3700pub struct WS_TCP_SSPI_BINDING_TEMPLATE {
3701 pub channelProperties: WS_CHANNEL_PROPERTIES,
3702 pub securityProperties: WS_SECURITY_PROPERTIES,
3703 pub sspiTransportSecurityBinding: WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TEMPLATE,
3704}
3705impl ::core::marker::Copy for WS_TCP_SSPI_BINDING_TEMPLATE {}
3706impl ::core::clone::Clone for WS_TCP_SSPI_BINDING_TEMPLATE {
3707 fn clone(&self) -> Self {
3708 *self
3709 }
3710}
3711#[repr(C)]
3712pub struct WS_TCP_SSPI_KERBEROS_APREQ_BINDING_TEMPLATE {
3713 pub channelProperties: WS_CHANNEL_PROPERTIES,
3714 pub securityProperties: WS_SECURITY_PROPERTIES,
3715 pub sspiTransportSecurityBinding: WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TEMPLATE,
3716 pub kerberosApreqMessageSecurityBinding: WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TEMPLATE,
3717}
3718impl ::core::marker::Copy for WS_TCP_SSPI_KERBEROS_APREQ_BINDING_TEMPLATE {}
3719impl ::core::clone::Clone for WS_TCP_SSPI_KERBEROS_APREQ_BINDING_TEMPLATE {
3720 fn clone(&self) -> Self {
3721 *self
3722 }
3723}
3724#[repr(C)]
3725pub struct WS_TCP_SSPI_KERBEROS_APREQ_POLICY_DESCRIPTION {
3726 pub channelProperties: WS_CHANNEL_PROPERTIES,
3727 pub securityProperties: WS_SECURITY_PROPERTIES,
3728 pub sspiTransportSecurityBinding: WS_SSPI_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
3729 pub kerberosApreqMessageSecurityBinding: WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION,
3730}
3731impl ::core::marker::Copy for WS_TCP_SSPI_KERBEROS_APREQ_POLICY_DESCRIPTION {}
3732impl ::core::clone::Clone for WS_TCP_SSPI_KERBEROS_APREQ_POLICY_DESCRIPTION {
3733 fn clone(&self) -> Self {
3734 *self
3735 }
3736}
3737#[repr(C)]
3738pub struct WS_TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE {
3739 pub channelProperties: WS_CHANNEL_PROPERTIES,
3740 pub securityProperties: WS_SECURITY_PROPERTIES,
3741 pub sspiTransportSecurityBinding: WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TEMPLATE,
3742 pub kerberosApreqMessageSecurityBinding: WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_TEMPLATE,
3743 pub securityContextSecurityBinding: WS_SECURITY_CONTEXT_SECURITY_BINDING_TEMPLATE,
3744}
3745impl ::core::marker::Copy for WS_TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE {}
3746impl ::core::clone::Clone for WS_TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_BINDING_TEMPLATE {
3747 fn clone(&self) -> Self {
3748 *self
3749 }
3750}
3751#[repr(C)]
3752pub struct WS_TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_POLICY_DESCRIPTION {
3753 pub channelProperties: WS_CHANNEL_PROPERTIES,
3754 pub securityProperties: WS_SECURITY_PROPERTIES,
3755 pub sspiTransportSecurityBinding: WS_SSPI_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
3756 pub kerberosApreqMessageSecurityBinding: WS_KERBEROS_APREQ_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION,
3757 pub securityContextSecurityBinding: WS_SECURITY_CONTEXT_SECURITY_BINDING_POLICY_DESCRIPTION,
3758}
3759impl ::core::marker::Copy for WS_TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_POLICY_DESCRIPTION {}
3760impl ::core::clone::Clone for WS_TCP_SSPI_KERBEROS_APREQ_SECURITY_CONTEXT_POLICY_DESCRIPTION {
3761 fn clone(&self) -> Self {
3762 *self
3763 }
3764}
3765#[repr(C)]
3766pub struct WS_TCP_SSPI_POLICY_DESCRIPTION {
3767 pub channelProperties: WS_CHANNEL_PROPERTIES,
3768 pub securityProperties: WS_SECURITY_PROPERTIES,
3769 pub sspiTransportSecurityBinding: WS_SSPI_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
3770}
3771impl ::core::marker::Copy for WS_TCP_SSPI_POLICY_DESCRIPTION {}
3772impl ::core::clone::Clone for WS_TCP_SSPI_POLICY_DESCRIPTION {
3773 fn clone(&self) -> Self {
3774 *self
3775 }
3776}
3777#[repr(C)]
3778pub struct WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING {
3779 pub binding: WS_SECURITY_BINDING,
3780 pub clientCredential: *mut WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
3781}
3782impl ::core::marker::Copy for WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING {}
3783impl ::core::clone::Clone for WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING {
3784 fn clone(&self) -> Self {
3785 *self
3786 }
3787}
3788#[repr(C)]
3789pub struct WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_CONSTRAINT {
3790 pub bindingConstraint: WS_SECURITY_BINDING_CONSTRAINT,
3791}
3792impl ::core::marker::Copy for WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_CONSTRAINT {}
3793impl ::core::clone::Clone for WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_CONSTRAINT {
3794 fn clone(&self) -> Self {
3795 *self
3796 }
3797}
3798#[repr(C)]
3799pub struct WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TEMPLATE {
3800 pub securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
3801 pub clientCredential: *mut WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL,
3802}
3803impl ::core::marker::Copy for WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TEMPLATE {}
3804impl ::core::clone::Clone for WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TEMPLATE {
3805 fn clone(&self) -> Self {
3806 *self
3807 }
3808}
3809#[repr(C)]
3810#[cfg(feature = "Win32_Foundation")]
3811pub struct WS_TCP_SSPI_USERNAME_BINDING_TEMPLATE {
3812 pub channelProperties: WS_CHANNEL_PROPERTIES,
3813 pub securityProperties: WS_SECURITY_PROPERTIES,
3814 pub sspiTransportSecurityBinding: WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TEMPLATE,
3815 pub usernameMessageSecurityBinding: WS_USERNAME_MESSAGE_SECURITY_BINDING_TEMPLATE,
3816}
3817#[cfg(feature = "Win32_Foundation")]
3818impl ::core::marker::Copy for WS_TCP_SSPI_USERNAME_BINDING_TEMPLATE {}
3819#[cfg(feature = "Win32_Foundation")]
3820impl ::core::clone::Clone for WS_TCP_SSPI_USERNAME_BINDING_TEMPLATE {
3821 fn clone(&self) -> Self {
3822 *self
3823 }
3824}
3825#[repr(C)]
3826pub struct WS_TCP_SSPI_USERNAME_POLICY_DESCRIPTION {
3827 pub channelProperties: WS_CHANNEL_PROPERTIES,
3828 pub securityProperties: WS_SECURITY_PROPERTIES,
3829 pub sspiTransportSecurityBinding: WS_SSPI_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
3830 pub usernameMessageSecurityBinding: WS_USERNAME_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION,
3831}
3832impl ::core::marker::Copy for WS_TCP_SSPI_USERNAME_POLICY_DESCRIPTION {}
3833impl ::core::clone::Clone for WS_TCP_SSPI_USERNAME_POLICY_DESCRIPTION {
3834 fn clone(&self) -> Self {
3835 *self
3836 }
3837}
3838#[repr(C)]
3839#[cfg(feature = "Win32_Foundation")]
3840pub struct WS_TCP_SSPI_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE {
3841 pub channelProperties: WS_CHANNEL_PROPERTIES,
3842 pub securityProperties: WS_SECURITY_PROPERTIES,
3843 pub sspiTransportSecurityBinding: WS_TCP_SSPI_TRANSPORT_SECURITY_BINDING_TEMPLATE,
3844 pub usernameMessageSecurityBinding: WS_USERNAME_MESSAGE_SECURITY_BINDING_TEMPLATE,
3845 pub securityContextSecurityBinding: WS_SECURITY_CONTEXT_SECURITY_BINDING_TEMPLATE,
3846}
3847#[cfg(feature = "Win32_Foundation")]
3848impl ::core::marker::Copy for WS_TCP_SSPI_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE {}
3849#[cfg(feature = "Win32_Foundation")]
3850impl ::core::clone::Clone for WS_TCP_SSPI_USERNAME_SECURITY_CONTEXT_BINDING_TEMPLATE {
3851 fn clone(&self) -> Self {
3852 *self
3853 }
3854}
3855#[repr(C)]
3856pub struct WS_TCP_SSPI_USERNAME_SECURITY_CONTEXT_POLICY_DESCRIPTION {
3857 pub channelProperties: WS_CHANNEL_PROPERTIES,
3858 pub securityProperties: WS_SECURITY_PROPERTIES,
3859 pub sspiTransportSecurityBinding: WS_SSPI_TRANSPORT_SECURITY_BINDING_POLICY_DESCRIPTION,
3860 pub usernameMessageSecurityBinding: WS_USERNAME_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION,
3861 pub securityContextSecurityBinding: WS_SECURITY_CONTEXT_SECURITY_BINDING_POLICY_DESCRIPTION,
3862}
3863impl ::core::marker::Copy for WS_TCP_SSPI_USERNAME_SECURITY_CONTEXT_POLICY_DESCRIPTION {}
3864impl ::core::clone::Clone for WS_TCP_SSPI_USERNAME_SECURITY_CONTEXT_POLICY_DESCRIPTION {
3865 fn clone(&self) -> Self {
3866 *self
3867 }
3868}
3869#[repr(C)]
3870#[cfg(feature = "Win32_Foundation")]
3871pub struct WS_THUMBPRINT_CERT_CREDENTIAL {
3872 pub credential: WS_CERT_CREDENTIAL,
3873 pub storeLocation: u32,
3874 pub storeName: WS_STRING,
3875 pub thumbprint: WS_STRING,
3876}
3877#[cfg(feature = "Win32_Foundation")]
3878impl ::core::marker::Copy for WS_THUMBPRINT_CERT_CREDENTIAL {}
3879#[cfg(feature = "Win32_Foundation")]
3880impl ::core::clone::Clone for WS_THUMBPRINT_CERT_CREDENTIAL {
3881 fn clone(&self) -> Self {
3882 *self
3883 }
3884}
3885#[repr(C)]
3886pub struct WS_TIMESPAN {
3887 pub ticks: i64,
3888}
3889impl ::core::marker::Copy for WS_TIMESPAN {}
3890impl ::core::clone::Clone for WS_TIMESPAN {
3891 fn clone(&self) -> Self {
3892 *self
3893 }
3894}
3895#[repr(C)]
3896pub struct WS_TIMESPAN_DESCRIPTION {
3897 pub minValue: WS_TIMESPAN,
3898 pub maxValue: WS_TIMESPAN,
3899}
3900impl ::core::marker::Copy for WS_TIMESPAN_DESCRIPTION {}
3901impl ::core::clone::Clone for WS_TIMESPAN_DESCRIPTION {
3902 fn clone(&self) -> Self {
3903 *self
3904 }
3905}
3906pub type WS_TRACE_API = i32;
3907pub const WS_TRACE_API_NONE: WS_TRACE_API = -1i32;
3908pub const WS_TRACE_API_START_READER_CANONICALIZATION: WS_TRACE_API = 0i32;
3909pub const WS_TRACE_API_END_READER_CANONICALIZATION: WS_TRACE_API = 1i32;
3910pub const WS_TRACE_API_START_WRITER_CANONICALIZATION: WS_TRACE_API = 2i32;
3911pub const WS_TRACE_API_END_WRITER_CANONICALIZATION: WS_TRACE_API = 3i32;
3912pub const WS_TRACE_API_CREATE_XML_BUFFER: WS_TRACE_API = 4i32;
3913pub const WS_TRACE_API_REMOVE_NODE: WS_TRACE_API = 5i32;
3914pub const WS_TRACE_API_CREATE_READER: WS_TRACE_API = 6i32;
3915pub const WS_TRACE_API_SET_INPUT: WS_TRACE_API = 7i32;
3916pub const WS_TRACE_API_SET_INPUT_TO_BUFFER: WS_TRACE_API = 8i32;
3917pub const WS_TRACE_API_FREE_XML_READER: WS_TRACE_API = 9i32;
3918pub const WS_TRACE_API_GET_READER_PROPERTY: WS_TRACE_API = 10i32;
3919pub const WS_TRACE_API_GET_READER_NODE: WS_TRACE_API = 11i32;
3920pub const WS_TRACE_API_FILL_READER: WS_TRACE_API = 12i32;
3921pub const WS_TRACE_API_READ_START_ELEMENT: WS_TRACE_API = 13i32;
3922pub const WS_TRACE_API_READ_TO_START_ELEMENT: WS_TRACE_API = 14i32;
3923pub const WS_TRACE_API_READ_START_ATTRIBUTE: WS_TRACE_API = 15i32;
3924pub const WS_TRACE_API_READ_END_ATTRIBUTE: WS_TRACE_API = 16i32;
3925pub const WS_TRACE_API_READ_NODE: WS_TRACE_API = 17i32;
3926pub const WS_TRACE_API_SKIP_NODE: WS_TRACE_API = 18i32;
3927pub const WS_TRACE_API_READ_END_ELEMENT: WS_TRACE_API = 19i32;
3928pub const WS_TRACE_API_FIND_ATTRIBUTE: WS_TRACE_API = 20i32;
3929pub const WS_TRACE_API_READ_ELEMENT_VALUE: WS_TRACE_API = 21i32;
3930pub const WS_TRACE_API_READ_CHARS: WS_TRACE_API = 22i32;
3931pub const WS_TRACE_API_READ_CHARS_UTF8: WS_TRACE_API = 23i32;
3932pub const WS_TRACE_API_READ_BYTES: WS_TRACE_API = 24i32;
3933pub const WS_TRACE_API_READ_ARRAY: WS_TRACE_API = 25i32;
3934pub const WS_TRACE_API_GET_READER_POSITION: WS_TRACE_API = 26i32;
3935pub const WS_TRACE_API_SET_READER_POSITION: WS_TRACE_API = 27i32;
3936pub const WS_TRACE_API_MOVE_READER: WS_TRACE_API = 28i32;
3937pub const WS_TRACE_API_CREATE_WRITER: WS_TRACE_API = 29i32;
3938pub const WS_TRACE_API_FREE_XML_WRITER: WS_TRACE_API = 30i32;
3939pub const WS_TRACE_API_SET_OUTPUT: WS_TRACE_API = 31i32;
3940pub const WS_TRACE_API_SET_OUTPUT_TO_BUFFER: WS_TRACE_API = 32i32;
3941pub const WS_TRACE_API_GET_WRITER_PROPERTY: WS_TRACE_API = 33i32;
3942pub const WS_TRACE_API_FLUSH_WRITER: WS_TRACE_API = 34i32;
3943pub const WS_TRACE_API_WRITE_START_ELEMENT: WS_TRACE_API = 35i32;
3944pub const WS_TRACE_API_WRITE_END_START_ELEMENT: WS_TRACE_API = 36i32;
3945pub const WS_TRACE_API_WRITE_XMLNS_ATTRIBUTE: WS_TRACE_API = 37i32;
3946pub const WS_TRACE_API_WRITE_START_ATTRIBUTE: WS_TRACE_API = 38i32;
3947pub const WS_TRACE_API_WRITE_END_ATTRIBUTE: WS_TRACE_API = 39i32;
3948pub const WS_TRACE_API_WRITE_VALUE: WS_TRACE_API = 40i32;
3949pub const WS_TRACE_API_WRITE_XML_BUFFER: WS_TRACE_API = 41i32;
3950pub const WS_TRACE_API_READ_XML_BUFFER: WS_TRACE_API = 42i32;
3951pub const WS_TRACE_API_WRITE_XML_BUFFER_TO_BYTES: WS_TRACE_API = 43i32;
3952pub const WS_TRACE_API_READ_XML_BUFFER_FROM_BYTES: WS_TRACE_API = 44i32;
3953pub const WS_TRACE_API_WRITE_ARRAY: WS_TRACE_API = 45i32;
3954pub const WS_TRACE_API_WRITE_QUALIFIED_NAME: WS_TRACE_API = 46i32;
3955pub const WS_TRACE_API_WRITE_CHARS: WS_TRACE_API = 47i32;
3956pub const WS_TRACE_API_WRITE_CHARS_UTF8: WS_TRACE_API = 48i32;
3957pub const WS_TRACE_API_WRITE_BYTES: WS_TRACE_API = 49i32;
3958pub const WS_TRACE_API_PUSH_BYTES: WS_TRACE_API = 50i32;
3959pub const WS_TRACE_API_PULL_BYTES: WS_TRACE_API = 51i32;
3960pub const WS_TRACE_API_WRITE_END_ELEMENT: WS_TRACE_API = 52i32;
3961pub const WS_TRACE_API_WRITE_TEXT: WS_TRACE_API = 53i32;
3962pub const WS_TRACE_API_WRITE_START_CDATA: WS_TRACE_API = 54i32;
3963pub const WS_TRACE_API_WRITE_END_CDATA: WS_TRACE_API = 55i32;
3964pub const WS_TRACE_API_WRITE_NODE: WS_TRACE_API = 56i32;
3965pub const WS_TRACE_API_PREFIX_FROM_NAMESPACE: WS_TRACE_API = 57i32;
3966pub const WS_TRACE_API_GET_WRITER_POSITION: WS_TRACE_API = 58i32;
3967pub const WS_TRACE_API_SET_WRITER_POSITION: WS_TRACE_API = 59i32;
3968pub const WS_TRACE_API_MOVE_WRITER: WS_TRACE_API = 60i32;
3969pub const WS_TRACE_API_TRIM_XML_WHITESPACE: WS_TRACE_API = 61i32;
3970pub const WS_TRACE_API_VERIFY_XML_NCNAME: WS_TRACE_API = 62i32;
3971pub const WS_TRACE_API_XML_STRING_EQUALS: WS_TRACE_API = 63i32;
3972pub const WS_TRACE_API_NAMESPACE_FROM_PREFIX: WS_TRACE_API = 64i32;
3973pub const WS_TRACE_API_READ_QUALIFIED_NAME: WS_TRACE_API = 65i32;
3974pub const WS_TRACE_API_GET_XML_ATTRIBUTE: WS_TRACE_API = 66i32;
3975pub const WS_TRACE_API_COPY_NODE: WS_TRACE_API = 67i32;
3976pub const WS_TRACE_API_ASYNC_EXECUTE: WS_TRACE_API = 68i32;
3977pub const WS_TRACE_API_CREATE_CHANNEL: WS_TRACE_API = 69i32;
3978pub const WS_TRACE_API_OPEN_CHANNEL: WS_TRACE_API = 70i32;
3979pub const WS_TRACE_API_SEND_MESSAGE: WS_TRACE_API = 71i32;
3980pub const WS_TRACE_API_RECEIVE_MESSAGE: WS_TRACE_API = 72i32;
3981pub const WS_TRACE_API_REQUEST_REPLY: WS_TRACE_API = 73i32;
3982pub const WS_TRACE_API_SEND_REPLY_MESSAGE: WS_TRACE_API = 74i32;
3983pub const WS_TRACE_API_SEND_FAULT_MESSAGE_FOR_ERROR: WS_TRACE_API = 75i32;
3984pub const WS_TRACE_API_GET_CHANNEL_PROPERTY: WS_TRACE_API = 76i32;
3985pub const WS_TRACE_API_SET_CHANNEL_PROPERTY: WS_TRACE_API = 77i32;
3986pub const WS_TRACE_API_WRITE_MESSAGE_START: WS_TRACE_API = 78i32;
3987pub const WS_TRACE_API_WRITE_MESSAGE_END: WS_TRACE_API = 79i32;
3988pub const WS_TRACE_API_READ_MESSAGE_START: WS_TRACE_API = 80i32;
3989pub const WS_TRACE_API_READ_MESSAGE_END: WS_TRACE_API = 81i32;
3990pub const WS_TRACE_API_CLOSE_CHANNEL: WS_TRACE_API = 82i32;
3991pub const WS_TRACE_API_ABORT_CHANNEL: WS_TRACE_API = 83i32;
3992pub const WS_TRACE_API_FREE_CHANNEL: WS_TRACE_API = 84i32;
3993pub const WS_TRACE_API_RESET_CHANNEL: WS_TRACE_API = 85i32;
3994pub const WS_TRACE_API_ABANDON_MESSAGE: WS_TRACE_API = 86i32;
3995pub const WS_TRACE_API_SHUTDOWN_SESSION_CHANNEL: WS_TRACE_API = 87i32;
3996pub const WS_TRACE_API_GET_CONTEXT_PROPERTY: WS_TRACE_API = 88i32;
3997pub const WS_TRACE_API_GET_DICTIONARY: WS_TRACE_API = 89i32;
3998pub const WS_TRACE_API_READ_ENDPOINT_ADDRESS_EXTENSION: WS_TRACE_API = 90i32;
3999pub const WS_TRACE_API_CREATE_ERROR: WS_TRACE_API = 91i32;
4000pub const WS_TRACE_API_ADD_ERROR_STRING: WS_TRACE_API = 92i32;
4001pub const WS_TRACE_API_GET_ERROR_STRING: WS_TRACE_API = 93i32;
4002pub const WS_TRACE_API_COPY_ERROR: WS_TRACE_API = 94i32;
4003pub const WS_TRACE_API_GET_ERROR_PROPERTY: WS_TRACE_API = 95i32;
4004pub const WS_TRACE_API_SET_ERROR_PROPERTY: WS_TRACE_API = 96i32;
4005pub const WS_TRACE_API_RESET_ERROR: WS_TRACE_API = 97i32;
4006pub const WS_TRACE_API_FREE_ERROR: WS_TRACE_API = 98i32;
4007pub const WS_TRACE_API_GET_FAULT_ERROR_PROPERTY: WS_TRACE_API = 99i32;
4008pub const WS_TRACE_API_SET_FAULT_ERROR_PROPERTY: WS_TRACE_API = 100i32;
4009pub const WS_TRACE_API_CREATE_FAULT_FROM_ERROR: WS_TRACE_API = 101i32;
4010pub const WS_TRACE_API_SET_FAULT_ERROR_DETAIL: WS_TRACE_API = 102i32;
4011pub const WS_TRACE_API_GET_FAULT_ERROR_DETAIL: WS_TRACE_API = 103i32;
4012pub const WS_TRACE_API_CREATE_HEAP: WS_TRACE_API = 104i32;
4013pub const WS_TRACE_API_ALLOC: WS_TRACE_API = 105i32;
4014pub const WS_TRACE_API_GET_HEAP_PROPERTY: WS_TRACE_API = 106i32;
4015pub const WS_TRACE_API_RESET_HEAP: WS_TRACE_API = 107i32;
4016pub const WS_TRACE_API_FREE_HEAP: WS_TRACE_API = 108i32;
4017pub const WS_TRACE_API_CREATE_LISTENER: WS_TRACE_API = 109i32;
4018pub const WS_TRACE_API_OPEN_LISTENER: WS_TRACE_API = 110i32;
4019pub const WS_TRACE_API_ACCEPT_CHANNEL: WS_TRACE_API = 111i32;
4020pub const WS_TRACE_API_CLOSE_LISTENER: WS_TRACE_API = 112i32;
4021pub const WS_TRACE_API_ABORT_LISTENER: WS_TRACE_API = 113i32;
4022pub const WS_TRACE_API_RESET_LISTENER: WS_TRACE_API = 114i32;
4023pub const WS_TRACE_API_FREE_LISTENER: WS_TRACE_API = 115i32;
4024pub const WS_TRACE_API_GET_LISTENER_PROPERTY: WS_TRACE_API = 116i32;
4025pub const WS_TRACE_API_SET_LISTENER_PROPERTY: WS_TRACE_API = 117i32;
4026pub const WS_TRACE_API_CREATE_CHANNEL_FOR_LISTENER: WS_TRACE_API = 118i32;
4027pub const WS_TRACE_API_CREATE_MESSAGE: WS_TRACE_API = 119i32;
4028pub const WS_TRACE_API_CREATE_MESSAGE_FOR_CHANNEL: WS_TRACE_API = 120i32;
4029pub const WS_TRACE_API_INITIALIZE_MESSAGE: WS_TRACE_API = 121i32;
4030pub const WS_TRACE_API_RESET_MESSAGE: WS_TRACE_API = 122i32;
4031pub const WS_TRACE_API_FREE_MESSAGE: WS_TRACE_API = 123i32;
4032pub const WS_TRACE_API_GET_HEADER_ATTRIBUTES: WS_TRACE_API = 124i32;
4033pub const WS_TRACE_API_GET_HEADER: WS_TRACE_API = 125i32;
4034pub const WS_TRACE_API_GET_CUSTOM_HEADER: WS_TRACE_API = 126i32;
4035pub const WS_TRACE_API_REMOVE_HEADER: WS_TRACE_API = 127i32;
4036pub const WS_TRACE_API_SET_HEADER: WS_TRACE_API = 128i32;
4037pub const WS_TRACE_API_REMOVE_CUSTOM_HEADER: WS_TRACE_API = 129i32;
4038pub const WS_TRACE_API_ADD_CUSTOM_HEADER: WS_TRACE_API = 130i32;
4039pub const WS_TRACE_API_ADD_MAPPED_HEADER: WS_TRACE_API = 131i32;
4040pub const WS_TRACE_API_REMOVE_MAPPED_HEADER: WS_TRACE_API = 132i32;
4041pub const WS_TRACE_API_GET_MAPPED_HEADER: WS_TRACE_API = 133i32;
4042pub const WS_TRACE_API_WRITE_BODY: WS_TRACE_API = 134i32;
4043pub const WS_TRACE_API_READ_BODY: WS_TRACE_API = 135i32;
4044pub const WS_TRACE_API_WRITE_ENVELOPE_START: WS_TRACE_API = 136i32;
4045pub const WS_TRACE_API_WRITE_ENVELOPE_END: WS_TRACE_API = 137i32;
4046pub const WS_TRACE_API_READ_ENVELOPE_START: WS_TRACE_API = 138i32;
4047pub const WS_TRACE_API_READ_ENVELOPE_END: WS_TRACE_API = 139i32;
4048pub const WS_TRACE_API_GET_MESSAGE_PROPERTY: WS_TRACE_API = 140i32;
4049pub const WS_TRACE_API_SET_MESSAGE_PROPERTY: WS_TRACE_API = 141i32;
4050pub const WS_TRACE_API_ADDRESS_MESSAGE: WS_TRACE_API = 142i32;
4051pub const WS_TRACE_API_CHECK_MUST_UNDERSTAND_HEADERS: WS_TRACE_API = 143i32;
4052pub const WS_TRACE_API_MARK_HEADER_AS_UNDERSTOOD: WS_TRACE_API = 144i32;
4053pub const WS_TRACE_API_FILL_BODY: WS_TRACE_API = 145i32;
4054pub const WS_TRACE_API_FLUSH_BODY: WS_TRACE_API = 146i32;
4055pub const WS_TRACE_API_REQUEST_SECURITY_TOKEN: WS_TRACE_API = 147i32;
4056pub const WS_TRACE_API_GET_SECURITY_TOKEN_PROPERTY: WS_TRACE_API = 148i32;
4057pub const WS_TRACE_API_CREATE_XML_SECURITY_TOKEN: WS_TRACE_API = 149i32;
4058pub const WS_TRACE_API_FREE_SECURITY_TOKEN: WS_TRACE_API = 150i32;
4059pub const WS_TRACE_API_REVOKE_SECURITY_CONTEXT: WS_TRACE_API = 151i32;
4060pub const WS_TRACE_API_GET_SECURITY_CONTEXT_PROPERTY: WS_TRACE_API = 152i32;
4061pub const WS_TRACE_API_READ_ELEMENT_TYPE: WS_TRACE_API = 153i32;
4062pub const WS_TRACE_API_READ_ATTRIBUTE_TYPE: WS_TRACE_API = 154i32;
4063pub const WS_TRACE_API_READ_TYPE: WS_TRACE_API = 155i32;
4064pub const WS_TRACE_API_WRITE_ELEMENT_TYPE: WS_TRACE_API = 156i32;
4065pub const WS_TRACE_API_WRITE_ATTRIBUTE_TYPE: WS_TRACE_API = 157i32;
4066pub const WS_TRACE_API_WRITE_TYPE: WS_TRACE_API = 158i32;
4067pub const WS_TRACE_API_SERVICE_REGISTER_FOR_CANCEL: WS_TRACE_API = 159i32;
4068pub const WS_TRACE_API_GET_SERVICE_HOST_PROPERTY: WS_TRACE_API = 160i32;
4069pub const WS_TRACE_API_CREATE_SERVICE_HOST: WS_TRACE_API = 161i32;
4070pub const WS_TRACE_API_OPEN_SERVICE_HOST: WS_TRACE_API = 162i32;
4071pub const WS_TRACE_API_CLOSE_SERVICE_HOST: WS_TRACE_API = 163i32;
4072pub const WS_TRACE_API_ABORT_SERVICE_HOST: WS_TRACE_API = 164i32;
4073pub const WS_TRACE_API_FREE_SERVICE_HOST: WS_TRACE_API = 165i32;
4074pub const WS_TRACE_API_RESET_SERVICE_HOST: WS_TRACE_API = 166i32;
4075pub const WS_TRACE_API_GET_SERVICE_PROXY_PROPERTY: WS_TRACE_API = 167i32;
4076pub const WS_TRACE_API_CREATE_SERVICE_PROXY: WS_TRACE_API = 168i32;
4077pub const WS_TRACE_API_OPEN_SERVICE_PROXY: WS_TRACE_API = 169i32;
4078pub const WS_TRACE_API_CLOSE_SERVICE_PROXY: WS_TRACE_API = 170i32;
4079pub const WS_TRACE_API_ABORT_SERVICE_PROXY: WS_TRACE_API = 171i32;
4080pub const WS_TRACE_API_FREE_SERVICE_PROXY: WS_TRACE_API = 172i32;
4081pub const WS_TRACE_API_RESET_SERVICE_PROXY: WS_TRACE_API = 173i32;
4082pub const WS_TRACE_API_ABORT_CALL: WS_TRACE_API = 174i32;
4083pub const WS_TRACE_API_CALL: WS_TRACE_API = 175i32;
4084pub const WS_TRACE_API_DECODE_URL: WS_TRACE_API = 176i32;
4085pub const WS_TRACE_API_ENCODE_URL: WS_TRACE_API = 177i32;
4086pub const WS_TRACE_API_COMBINE_URL: WS_TRACE_API = 178i32;
4087pub const WS_TRACE_API_DATETIME_TO_FILETIME: WS_TRACE_API = 179i32;
4088pub const WS_TRACE_API_FILETIME_TO_DATETIME: WS_TRACE_API = 180i32;
4089pub const WS_TRACE_API_DUMP_MEMORY: WS_TRACE_API = 181i32;
4090pub const WS_TRACE_API_SET_AUTOFAIL: WS_TRACE_API = 182i32;
4091pub const WS_TRACE_API_CREATE_METADATA: WS_TRACE_API = 183i32;
4092pub const WS_TRACE_API_READ_METADATA: WS_TRACE_API = 184i32;
4093pub const WS_TRACE_API_FREE_METADATA: WS_TRACE_API = 185i32;
4094pub const WS_TRACE_API_RESET_METADATA: WS_TRACE_API = 186i32;
4095pub const WS_TRACE_API_GET_METADATA_PROPERTY: WS_TRACE_API = 187i32;
4096pub const WS_TRACE_API_GET_MISSING_METADATA_DOCUMENT_ADDRESS: WS_TRACE_API = 188i32;
4097pub const WS_TRACE_API_GET_METADATA_ENDPOINTS: WS_TRACE_API = 189i32;
4098pub const WS_TRACE_API_MATCH_POLICY_ALTERNATIVE: WS_TRACE_API = 190i32;
4099pub const WS_TRACE_API_GET_POLICY_PROPERTY: WS_TRACE_API = 191i32;
4100pub const WS_TRACE_API_GET_POLICY_ALTERNATIVE_COUNT: WS_TRACE_API = 192i32;
4101pub const WS_TRACE_API_WS_CREATE_SERVICE_PROXY_FROM_TEMPLATE: WS_TRACE_API = 193i32;
4102pub const WS_TRACE_API_WS_CREATE_SERVICE_HOST_FROM_TEMPLATE: WS_TRACE_API = 194i32;
4103pub type WS_TRANSFER_MODE = i32;
4104pub const WS_STREAMED_INPUT_TRANSFER_MODE: WS_TRANSFER_MODE = 1i32;
4105pub const WS_STREAMED_OUTPUT_TRANSFER_MODE: WS_TRANSFER_MODE = 2i32;
4106pub const WS_BUFFERED_TRANSFER_MODE: WS_TRANSFER_MODE = 0i32;
4107pub const WS_STREAMED_TRANSFER_MODE: WS_TRANSFER_MODE = 3i32;
4108pub type WS_TRUST_VERSION = i32;
4109pub const WS_TRUST_VERSION_FEBRUARY_2005: WS_TRUST_VERSION = 1i32;
4110pub const WS_TRUST_VERSION_1_3: WS_TRUST_VERSION = 2i32;
4111pub type WS_TYPE = i32;
4112pub const WS_BOOL_TYPE: WS_TYPE = 0i32;
4113pub const WS_INT8_TYPE: WS_TYPE = 1i32;
4114pub const WS_INT16_TYPE: WS_TYPE = 2i32;
4115pub const WS_INT32_TYPE: WS_TYPE = 3i32;
4116pub const WS_INT64_TYPE: WS_TYPE = 4i32;
4117pub const WS_UINT8_TYPE: WS_TYPE = 5i32;
4118pub const WS_UINT16_TYPE: WS_TYPE = 6i32;
4119pub const WS_UINT32_TYPE: WS_TYPE = 7i32;
4120pub const WS_UINT64_TYPE: WS_TYPE = 8i32;
4121pub const WS_FLOAT_TYPE: WS_TYPE = 9i32;
4122pub const WS_DOUBLE_TYPE: WS_TYPE = 10i32;
4123pub const WS_DECIMAL_TYPE: WS_TYPE = 11i32;
4124pub const WS_DATETIME_TYPE: WS_TYPE = 12i32;
4125pub const WS_TIMESPAN_TYPE: WS_TYPE = 13i32;
4126pub const WS_GUID_TYPE: WS_TYPE = 14i32;
4127pub const WS_UNIQUE_ID_TYPE: WS_TYPE = 15i32;
4128pub const WS_STRING_TYPE: WS_TYPE = 16i32;
4129pub const WS_WSZ_TYPE: WS_TYPE = 17i32;
4130pub const WS_BYTES_TYPE: WS_TYPE = 18i32;
4131pub const WS_XML_STRING_TYPE: WS_TYPE = 19i32;
4132pub const WS_XML_QNAME_TYPE: WS_TYPE = 20i32;
4133pub const WS_XML_BUFFER_TYPE: WS_TYPE = 21i32;
4134pub const WS_CHAR_ARRAY_TYPE: WS_TYPE = 22i32;
4135pub const WS_UTF8_ARRAY_TYPE: WS_TYPE = 23i32;
4136pub const WS_BYTE_ARRAY_TYPE: WS_TYPE = 24i32;
4137pub const WS_DESCRIPTION_TYPE: WS_TYPE = 25i32;
4138pub const WS_STRUCT_TYPE: WS_TYPE = 26i32;
4139pub const WS_CUSTOM_TYPE: WS_TYPE = 27i32;
4140pub const WS_ENDPOINT_ADDRESS_TYPE: WS_TYPE = 28i32;
4141pub const WS_FAULT_TYPE: WS_TYPE = 29i32;
4142pub const WS_VOID_TYPE: WS_TYPE = 30i32;
4143pub const WS_ENUM_TYPE: WS_TYPE = 31i32;
4144pub const WS_DURATION_TYPE: WS_TYPE = 32i32;
4145pub const WS_UNION_TYPE: WS_TYPE = 33i32;
4146pub const WS_ANY_ATTRIBUTES_TYPE: WS_TYPE = 34i32;
4147pub type WS_TYPE_MAPPING = i32;
4148pub const WS_ELEMENT_TYPE_MAPPING: WS_TYPE_MAPPING = 1i32;
4149pub const WS_ATTRIBUTE_TYPE_MAPPING: WS_TYPE_MAPPING = 2i32;
4150pub const WS_ELEMENT_CONTENT_TYPE_MAPPING: WS_TYPE_MAPPING = 3i32;
4151pub const WS_ANY_ELEMENT_TYPE_MAPPING: WS_TYPE_MAPPING = 4i32;
4152#[repr(C)]
4153pub struct WS_UINT16_DESCRIPTION {
4154 pub minValue: u16,
4155 pub maxValue: u16,
4156}
4157impl ::core::marker::Copy for WS_UINT16_DESCRIPTION {}
4158impl ::core::clone::Clone for WS_UINT16_DESCRIPTION {
4159 fn clone(&self) -> Self {
4160 *self
4161 }
4162}
4163#[repr(C)]
4164pub struct WS_UINT32_DESCRIPTION {
4165 pub minValue: u32,
4166 pub maxValue: u32,
4167}
4168impl ::core::marker::Copy for WS_UINT32_DESCRIPTION {}
4169impl ::core::clone::Clone for WS_UINT32_DESCRIPTION {
4170 fn clone(&self) -> Self {
4171 *self
4172 }
4173}
4174#[repr(C)]
4175pub struct WS_UINT64_DESCRIPTION {
4176 pub minValue: u64,
4177 pub maxValue: u64,
4178}
4179impl ::core::marker::Copy for WS_UINT64_DESCRIPTION {}
4180impl ::core::clone::Clone for WS_UINT64_DESCRIPTION {
4181 fn clone(&self) -> Self {
4182 *self
4183 }
4184}
4185#[repr(C)]
4186pub struct WS_UINT8_DESCRIPTION {
4187 pub minValue: u8,
4188 pub maxValue: u8,
4189}
4190impl ::core::marker::Copy for WS_UINT8_DESCRIPTION {}
4191impl ::core::clone::Clone for WS_UINT8_DESCRIPTION {
4192 fn clone(&self) -> Self {
4193 *self
4194 }
4195}
4196#[repr(C)]
4197#[cfg(feature = "Win32_Foundation")]
4198pub struct WS_UNION_DESCRIPTION {
4199 pub size: u32,
4200 pub alignment: u32,
4201 pub fields: *mut *mut WS_UNION_FIELD_DESCRIPTION,
4202 pub fieldCount: u32,
4203 pub enumOffset: u32,
4204 pub noneEnumValue: i32,
4205 pub valueIndices: *mut u32,
4206}
4207#[cfg(feature = "Win32_Foundation")]
4208impl ::core::marker::Copy for WS_UNION_DESCRIPTION {}
4209#[cfg(feature = "Win32_Foundation")]
4210impl ::core::clone::Clone for WS_UNION_DESCRIPTION {
4211 fn clone(&self) -> Self {
4212 *self
4213 }
4214}
4215#[repr(C)]
4216#[cfg(feature = "Win32_Foundation")]
4217pub struct WS_UNION_FIELD_DESCRIPTION {
4218 pub value: i32,
4219 pub field: WS_FIELD_DESCRIPTION,
4220}
4221#[cfg(feature = "Win32_Foundation")]
4222impl ::core::marker::Copy for WS_UNION_FIELD_DESCRIPTION {}
4223#[cfg(feature = "Win32_Foundation")]
4224impl ::core::clone::Clone for WS_UNION_FIELD_DESCRIPTION {
4225 fn clone(&self) -> Self {
4226 *self
4227 }
4228}
4229#[repr(C)]
4230#[cfg(feature = "Win32_Foundation")]
4231pub struct WS_UNIQUE_ID {
4232 pub uri: WS_STRING,
4233 pub guid: ::windows_sys::core::GUID,
4234}
4235#[cfg(feature = "Win32_Foundation")]
4236impl ::core::marker::Copy for WS_UNIQUE_ID {}
4237#[cfg(feature = "Win32_Foundation")]
4238impl ::core::clone::Clone for WS_UNIQUE_ID {
4239 fn clone(&self) -> Self {
4240 *self
4241 }
4242}
4243#[repr(C)]
4244pub struct WS_UNIQUE_ID_DESCRIPTION {
4245 pub minCharCount: u32,
4246 pub maxCharCount: u32,
4247}
4248impl ::core::marker::Copy for WS_UNIQUE_ID_DESCRIPTION {}
4249impl ::core::clone::Clone for WS_UNIQUE_ID_DESCRIPTION {
4250 fn clone(&self) -> Self {
4251 *self
4252 }
4253}
4254#[repr(C)]
4255pub struct WS_UNKNOWN_ENDPOINT_IDENTITY {
4256 pub identity: WS_ENDPOINT_IDENTITY,
4257 pub element: *mut WS_XML_BUFFER,
4258}
4259impl ::core::marker::Copy for WS_UNKNOWN_ENDPOINT_IDENTITY {}
4260impl ::core::clone::Clone for WS_UNKNOWN_ENDPOINT_IDENTITY {
4261 fn clone(&self) -> Self {
4262 *self
4263 }
4264}
4265#[repr(C)]
4266#[cfg(feature = "Win32_Foundation")]
4267pub struct WS_UPN_ENDPOINT_IDENTITY {
4268 pub identity: WS_ENDPOINT_IDENTITY,
4269 pub upn: WS_STRING,
4270}
4271#[cfg(feature = "Win32_Foundation")]
4272impl ::core::marker::Copy for WS_UPN_ENDPOINT_IDENTITY {}
4273#[cfg(feature = "Win32_Foundation")]
4274impl ::core::clone::Clone for WS_UPN_ENDPOINT_IDENTITY {
4275 fn clone(&self) -> Self {
4276 *self
4277 }
4278}
4279#[repr(C)]
4280pub struct WS_URL {
4281 pub scheme: WS_URL_SCHEME_TYPE,
4282}
4283impl ::core::marker::Copy for WS_URL {}
4284impl ::core::clone::Clone for WS_URL {
4285 fn clone(&self) -> Self {
4286 *self
4287 }
4288}
4289pub const WS_URL_FLAGS_ALLOW_HOST_WILDCARDS: i32 = 1i32;
4290pub const WS_URL_FLAGS_NO_PATH_COLLAPSE: i32 = 2i32;
4291pub const WS_URL_FLAGS_ZERO_TERMINATE: i32 = 4i32;
4292pub type WS_URL_SCHEME_TYPE = i32;
4293pub const WS_URL_HTTP_SCHEME_TYPE: WS_URL_SCHEME_TYPE = 0i32;
4294pub const WS_URL_HTTPS_SCHEME_TYPE: WS_URL_SCHEME_TYPE = 1i32;
4295pub const WS_URL_NETTCP_SCHEME_TYPE: WS_URL_SCHEME_TYPE = 2i32;
4296pub const WS_URL_SOAPUDP_SCHEME_TYPE: WS_URL_SCHEME_TYPE = 3i32;
4297pub const WS_URL_NETPIPE_SCHEME_TYPE: WS_URL_SCHEME_TYPE = 4i32;
4298#[repr(C)]
4299pub struct WS_USERNAME_CREDENTIAL {
4300 pub credentialType: WS_USERNAME_CREDENTIAL_TYPE,
4301}
4302impl ::core::marker::Copy for WS_USERNAME_CREDENTIAL {}
4303impl ::core::clone::Clone for WS_USERNAME_CREDENTIAL {
4304 fn clone(&self) -> Self {
4305 *self
4306 }
4307}
4308pub type WS_USERNAME_CREDENTIAL_TYPE = i32;
4309pub const WS_STRING_USERNAME_CREDENTIAL_TYPE: WS_USERNAME_CREDENTIAL_TYPE = 1i32;
4310#[repr(C)]
4311#[cfg(feature = "Win32_Foundation")]
4312pub struct WS_USERNAME_MESSAGE_SECURITY_BINDING {
4313 pub binding: WS_SECURITY_BINDING,
4314 pub bindingUsage: WS_MESSAGE_SECURITY_USAGE,
4315 pub clientCredential: *mut WS_USERNAME_CREDENTIAL,
4316 pub passwordValidator: WS_VALIDATE_PASSWORD_CALLBACK,
4317 pub passwordValidatorCallbackState: *mut ::core::ffi::c_void,
4318}
4319#[cfg(feature = "Win32_Foundation")]
4320impl ::core::marker::Copy for WS_USERNAME_MESSAGE_SECURITY_BINDING {}
4321#[cfg(feature = "Win32_Foundation")]
4322impl ::core::clone::Clone for WS_USERNAME_MESSAGE_SECURITY_BINDING {
4323 fn clone(&self) -> Self {
4324 *self
4325 }
4326}
4327#[repr(C)]
4328pub struct WS_USERNAME_MESSAGE_SECURITY_BINDING_CONSTRAINT {
4329 pub bindingConstraint: WS_SECURITY_BINDING_CONSTRAINT,
4330 pub bindingUsage: WS_MESSAGE_SECURITY_USAGE,
4331}
4332impl ::core::marker::Copy for WS_USERNAME_MESSAGE_SECURITY_BINDING_CONSTRAINT {}
4333impl ::core::clone::Clone for WS_USERNAME_MESSAGE_SECURITY_BINDING_CONSTRAINT {
4334 fn clone(&self) -> Self {
4335 *self
4336 }
4337}
4338#[repr(C)]
4339pub struct WS_USERNAME_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION {
4340 pub securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
4341 pub bindingUsage: WS_MESSAGE_SECURITY_USAGE,
4342}
4343impl ::core::marker::Copy for WS_USERNAME_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION {}
4344impl ::core::clone::Clone for WS_USERNAME_MESSAGE_SECURITY_BINDING_POLICY_DESCRIPTION {
4345 fn clone(&self) -> Self {
4346 *self
4347 }
4348}
4349#[repr(C)]
4350#[cfg(feature = "Win32_Foundation")]
4351pub struct WS_USERNAME_MESSAGE_SECURITY_BINDING_TEMPLATE {
4352 pub securityBindingProperties: WS_SECURITY_BINDING_PROPERTIES,
4353 pub clientCredential: *mut WS_USERNAME_CREDENTIAL,
4354 pub passwordValidator: WS_VALIDATE_PASSWORD_CALLBACK,
4355 pub passwordValidatorCallbackState: *mut ::core::ffi::c_void,
4356}
4357#[cfg(feature = "Win32_Foundation")]
4358impl ::core::marker::Copy for WS_USERNAME_MESSAGE_SECURITY_BINDING_TEMPLATE {}
4359#[cfg(feature = "Win32_Foundation")]
4360impl ::core::clone::Clone for WS_USERNAME_MESSAGE_SECURITY_BINDING_TEMPLATE {
4361 fn clone(&self) -> Self {
4362 *self
4363 }
4364}
4365#[repr(C)]
4366pub struct WS_UTF8_ARRAY_DESCRIPTION {
4367 pub minByteCount: u32,
4368 pub maxByteCount: u32,
4369}
4370impl ::core::marker::Copy for WS_UTF8_ARRAY_DESCRIPTION {}
4371impl ::core::clone::Clone for WS_UTF8_ARRAY_DESCRIPTION {
4372 fn clone(&self) -> Self {
4373 *self
4374 }
4375}
4376#[cfg(feature = "Win32_Foundation")]
4377pub type WS_VALIDATE_PASSWORD_CALLBACK = unsafe extern "system" fn(passwordvalidatorcallbackstate: *const ::core::ffi::c_void, username: *const WS_STRING, password: *const WS_STRING, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
4378pub type WS_VALIDATE_SAML_CALLBACK = unsafe extern "system" fn(samlvalidatorcallbackstate: *const ::core::ffi::c_void, samlassertion: *const WS_XML_BUFFER, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
4379pub type WS_VALUE_TYPE = i32;
4380pub const WS_BOOL_VALUE_TYPE: WS_VALUE_TYPE = 0i32;
4381pub const WS_INT8_VALUE_TYPE: WS_VALUE_TYPE = 1i32;
4382pub const WS_INT16_VALUE_TYPE: WS_VALUE_TYPE = 2i32;
4383pub const WS_INT32_VALUE_TYPE: WS_VALUE_TYPE = 3i32;
4384pub const WS_INT64_VALUE_TYPE: WS_VALUE_TYPE = 4i32;
4385pub const WS_UINT8_VALUE_TYPE: WS_VALUE_TYPE = 5i32;
4386pub const WS_UINT16_VALUE_TYPE: WS_VALUE_TYPE = 6i32;
4387pub const WS_UINT32_VALUE_TYPE: WS_VALUE_TYPE = 7i32;
4388pub const WS_UINT64_VALUE_TYPE: WS_VALUE_TYPE = 8i32;
4389pub const WS_FLOAT_VALUE_TYPE: WS_VALUE_TYPE = 9i32;
4390pub const WS_DOUBLE_VALUE_TYPE: WS_VALUE_TYPE = 10i32;
4391pub const WS_DECIMAL_VALUE_TYPE: WS_VALUE_TYPE = 11i32;
4392pub const WS_DATETIME_VALUE_TYPE: WS_VALUE_TYPE = 12i32;
4393pub const WS_TIMESPAN_VALUE_TYPE: WS_VALUE_TYPE = 13i32;
4394pub const WS_GUID_VALUE_TYPE: WS_VALUE_TYPE = 14i32;
4395pub const WS_DURATION_VALUE_TYPE: WS_VALUE_TYPE = 15i32;
4396#[repr(C)]
4397pub struct WS_VOID_DESCRIPTION {
4398 pub size: u32,
4399}
4400impl ::core::marker::Copy for WS_VOID_DESCRIPTION {}
4401impl ::core::clone::Clone for WS_VOID_DESCRIPTION {
4402 fn clone(&self) -> Self {
4403 *self
4404 }
4405}
4406#[repr(C)]
4407pub struct WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL {
4408 pub credentialType: WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE,
4409}
4410impl ::core::marker::Copy for WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL {}
4411impl ::core::clone::Clone for WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL {
4412 fn clone(&self) -> Self {
4413 *self
4414 }
4415}
4416pub type WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE = i32;
4417pub const WS_STRING_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE: WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE = 1i32;
4418pub const WS_DEFAULT_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE: WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE = 2i32;
4419pub const WS_OPAQUE_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE: WS_WINDOWS_INTEGRATED_AUTH_CREDENTIAL_TYPE = 3i32;
4420pub type WS_WINDOWS_INTEGRATED_AUTH_PACKAGE = i32;
4421pub const WS_WINDOWS_INTEGRATED_AUTH_PACKAGE_KERBEROS: WS_WINDOWS_INTEGRATED_AUTH_PACKAGE = 1i32;
4422pub const WS_WINDOWS_INTEGRATED_AUTH_PACKAGE_NTLM: WS_WINDOWS_INTEGRATED_AUTH_PACKAGE = 2i32;
4423pub const WS_WINDOWS_INTEGRATED_AUTH_PACKAGE_SPNEGO: WS_WINDOWS_INTEGRATED_AUTH_PACKAGE = 3i32;
4424pub type WS_WRITE_CALLBACK = unsafe extern "system" fn(callbackstate: *const ::core::ffi::c_void, buffers: *const WS_BYTES, count: u32, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
4425pub type WS_WRITE_MESSAGE_END_CALLBACK = unsafe extern "system" fn(channelinstance: *const ::core::ffi::c_void, message: *const WS_MESSAGE, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
4426pub type WS_WRITE_MESSAGE_START_CALLBACK = unsafe extern "system" fn(channelinstance: *const ::core::ffi::c_void, message: *const WS_MESSAGE, asynccontext: *const WS_ASYNC_CONTEXT, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
4427pub type WS_WRITE_OPTION = i32;
4428pub const WS_WRITE_REQUIRED_VALUE: WS_WRITE_OPTION = 1i32;
4429pub const WS_WRITE_REQUIRED_POINTER: WS_WRITE_OPTION = 2i32;
4430pub const WS_WRITE_NILLABLE_VALUE: WS_WRITE_OPTION = 3i32;
4431pub const WS_WRITE_NILLABLE_POINTER: WS_WRITE_OPTION = 4i32;
4432pub type WS_WRITE_TYPE_CALLBACK = unsafe extern "system" fn(writer: *const WS_XML_WRITER, typemapping: WS_TYPE_MAPPING, descriptiondata: *const ::core::ffi::c_void, value: *const ::core::ffi::c_void, valuesize: u32, error: *const WS_ERROR) -> ::windows_sys::core::HRESULT;
4433#[repr(C)]
4434pub struct WS_WSZ_DESCRIPTION {
4435 pub minCharCount: u32,
4436 pub maxCharCount: u32,
4437}
4438impl ::core::marker::Copy for WS_WSZ_DESCRIPTION {}
4439impl ::core::clone::Clone for WS_WSZ_DESCRIPTION {
4440 fn clone(&self) -> Self {
4441 *self
4442 }
4443}
4444#[repr(C)]
4445#[cfg(feature = "Win32_Foundation")]
4446pub struct WS_XML_ATTRIBUTE {
4447 pub singleQuote: u8,
4448 pub isXmlNs: u8,
4449 pub prefix: *mut WS_XML_STRING,
4450 pub localName: *mut WS_XML_STRING,
4451 pub ns: *mut WS_XML_STRING,
4452 pub value: *mut WS_XML_TEXT,
4453}
4454#[cfg(feature = "Win32_Foundation")]
4455impl ::core::marker::Copy for WS_XML_ATTRIBUTE {}
4456#[cfg(feature = "Win32_Foundation")]
4457impl ::core::clone::Clone for WS_XML_ATTRIBUTE {
4458 fn clone(&self) -> Self {
4459 *self
4460 }
4461}
4462#[repr(C)]
4463pub struct WS_XML_BASE64_TEXT {
4464 pub text: WS_XML_TEXT,
4465 pub bytes: *mut u8,
4466 pub length: u32,
4467}
4468impl ::core::marker::Copy for WS_XML_BASE64_TEXT {}
4469impl ::core::clone::Clone for WS_XML_BASE64_TEXT {
4470 fn clone(&self) -> Self {
4471 *self
4472 }
4473}
4474#[repr(C)]
4475#[cfg(feature = "Win32_Foundation")]
4476pub struct WS_XML_BOOL_TEXT {
4477 pub text: WS_XML_TEXT,
4478 pub value: super::super::Foundation::BOOL,
4479}
4480#[cfg(feature = "Win32_Foundation")]
4481impl ::core::marker::Copy for WS_XML_BOOL_TEXT {}
4482#[cfg(feature = "Win32_Foundation")]
4483impl ::core::clone::Clone for WS_XML_BOOL_TEXT {
4484 fn clone(&self) -> Self {
4485 *self
4486 }
4487}
4488#[repr(C)]
4489pub struct WS_XML_BUFFER(pub u8);
4490#[repr(C)]
4491pub struct WS_XML_BUFFER_PROPERTY {
4492 pub id: WS_XML_BUFFER_PROPERTY_ID,
4493 pub value: *mut ::core::ffi::c_void,
4494 pub valueSize: u32,
4495}
4496impl ::core::marker::Copy for WS_XML_BUFFER_PROPERTY {}
4497impl ::core::clone::Clone for WS_XML_BUFFER_PROPERTY {
4498 fn clone(&self) -> Self {
4499 *self
4500 }
4501}
4502pub type WS_XML_BUFFER_PROPERTY_ID = i32;
4503pub type WS_XML_CANONICALIZATION_ALGORITHM = i32;
4504pub const WS_EXCLUSIVE_XML_CANONICALIZATION_ALGORITHM: WS_XML_CANONICALIZATION_ALGORITHM = 0i32;
4505pub const WS_EXCLUSIVE_WITH_COMMENTS_XML_CANONICALIZATION_ALGORITHM: WS_XML_CANONICALIZATION_ALGORITHM = 1i32;
4506pub const WS_INCLUSIVE_XML_CANONICALIZATION_ALGORITHM: WS_XML_CANONICALIZATION_ALGORITHM = 2i32;
4507pub const WS_INCLUSIVE_WITH_COMMENTS_XML_CANONICALIZATION_ALGORITHM: WS_XML_CANONICALIZATION_ALGORITHM = 3i32;
4508#[repr(C)]
4509#[cfg(feature = "Win32_Foundation")]
4510pub struct WS_XML_CANONICALIZATION_INCLUSIVE_PREFIXES {
4511 pub prefixCount: u32,
4512 pub prefixes: *mut WS_XML_STRING,
4513}
4514#[cfg(feature = "Win32_Foundation")]
4515impl ::core::marker::Copy for WS_XML_CANONICALIZATION_INCLUSIVE_PREFIXES {}
4516#[cfg(feature = "Win32_Foundation")]
4517impl ::core::clone::Clone for WS_XML_CANONICALIZATION_INCLUSIVE_PREFIXES {
4518 fn clone(&self) -> Self {
4519 *self
4520 }
4521}
4522#[repr(C)]
4523pub struct WS_XML_CANONICALIZATION_PROPERTY {
4524 pub id: WS_XML_CANONICALIZATION_PROPERTY_ID,
4525 pub value: *mut ::core::ffi::c_void,
4526 pub valueSize: u32,
4527}
4528impl ::core::marker::Copy for WS_XML_CANONICALIZATION_PROPERTY {}
4529impl ::core::clone::Clone for WS_XML_CANONICALIZATION_PROPERTY {
4530 fn clone(&self) -> Self {
4531 *self
4532 }
4533}
4534pub type WS_XML_CANONICALIZATION_PROPERTY_ID = i32;
4535pub const WS_XML_CANONICALIZATION_PROPERTY_ALGORITHM: WS_XML_CANONICALIZATION_PROPERTY_ID = 0i32;
4536pub const WS_XML_CANONICALIZATION_PROPERTY_INCLUSIVE_PREFIXES: WS_XML_CANONICALIZATION_PROPERTY_ID = 1i32;
4537pub const WS_XML_CANONICALIZATION_PROPERTY_OMITTED_ELEMENT: WS_XML_CANONICALIZATION_PROPERTY_ID = 2i32;
4538pub const WS_XML_CANONICALIZATION_PROPERTY_OUTPUT_BUFFER_SIZE: WS_XML_CANONICALIZATION_PROPERTY_ID = 3i32;
4539#[repr(C)]
4540#[cfg(feature = "Win32_Foundation")]
4541pub struct WS_XML_COMMENT_NODE {
4542 pub node: WS_XML_NODE,
4543 pub value: WS_XML_STRING,
4544}
4545#[cfg(feature = "Win32_Foundation")]
4546impl ::core::marker::Copy for WS_XML_COMMENT_NODE {}
4547#[cfg(feature = "Win32_Foundation")]
4548impl ::core::clone::Clone for WS_XML_COMMENT_NODE {
4549 fn clone(&self) -> Self {
4550 *self
4551 }
4552}
4553#[repr(C)]
4554pub struct WS_XML_DATETIME_TEXT {
4555 pub text: WS_XML_TEXT,
4556 pub value: WS_DATETIME,
4557}
4558impl ::core::marker::Copy for WS_XML_DATETIME_TEXT {}
4559impl ::core::clone::Clone for WS_XML_DATETIME_TEXT {
4560 fn clone(&self) -> Self {
4561 *self
4562 }
4563}
4564#[repr(C)]
4565#[cfg(feature = "Win32_Foundation")]
4566pub struct WS_XML_DECIMAL_TEXT {
4567 pub text: WS_XML_TEXT,
4568 pub value: super::super::Foundation::DECIMAL,
4569}
4570#[cfg(feature = "Win32_Foundation")]
4571impl ::core::marker::Copy for WS_XML_DECIMAL_TEXT {}
4572#[cfg(feature = "Win32_Foundation")]
4573impl ::core::clone::Clone for WS_XML_DECIMAL_TEXT {
4574 fn clone(&self) -> Self {
4575 *self
4576 }
4577}
4578#[repr(C)]
4579#[cfg(feature = "Win32_Foundation")]
4580pub struct WS_XML_DICTIONARY {
4581 pub guid: ::windows_sys::core::GUID,
4582 pub strings: *mut WS_XML_STRING,
4583 pub stringCount: u32,
4584 pub isConst: super::super::Foundation::BOOL,
4585}
4586#[cfg(feature = "Win32_Foundation")]
4587impl ::core::marker::Copy for WS_XML_DICTIONARY {}
4588#[cfg(feature = "Win32_Foundation")]
4589impl ::core::clone::Clone for WS_XML_DICTIONARY {
4590 fn clone(&self) -> Self {
4591 *self
4592 }
4593}
4594#[repr(C)]
4595pub struct WS_XML_DOUBLE_TEXT {
4596 pub text: WS_XML_TEXT,
4597 pub value: f64,
4598}
4599impl ::core::marker::Copy for WS_XML_DOUBLE_TEXT {}
4600impl ::core::clone::Clone for WS_XML_DOUBLE_TEXT {
4601 fn clone(&self) -> Self {
4602 *self
4603 }
4604}
4605#[repr(C)]
4606#[cfg(feature = "Win32_Foundation")]
4607pub struct WS_XML_ELEMENT_NODE {
4608 pub node: WS_XML_NODE,
4609 pub prefix: *mut WS_XML_STRING,
4610 pub localName: *mut WS_XML_STRING,
4611 pub ns: *mut WS_XML_STRING,
4612 pub attributeCount: u32,
4613 pub attributes: *mut *mut WS_XML_ATTRIBUTE,
4614 pub isEmpty: super::super::Foundation::BOOL,
4615}
4616#[cfg(feature = "Win32_Foundation")]
4617impl ::core::marker::Copy for WS_XML_ELEMENT_NODE {}
4618#[cfg(feature = "Win32_Foundation")]
4619impl ::core::clone::Clone for WS_XML_ELEMENT_NODE {
4620 fn clone(&self) -> Self {
4621 *self
4622 }
4623}
4624#[repr(C)]
4625pub struct WS_XML_FLOAT_TEXT {
4626 pub text: WS_XML_TEXT,
4627 pub value: f32,
4628}
4629impl ::core::marker::Copy for WS_XML_FLOAT_TEXT {}
4630impl ::core::clone::Clone for WS_XML_FLOAT_TEXT {
4631 fn clone(&self) -> Self {
4632 *self
4633 }
4634}
4635#[repr(C)]
4636pub struct WS_XML_GUID_TEXT {
4637 pub text: WS_XML_TEXT,
4638 pub value: ::windows_sys::core::GUID,
4639}
4640impl ::core::marker::Copy for WS_XML_GUID_TEXT {}
4641impl ::core::clone::Clone for WS_XML_GUID_TEXT {
4642 fn clone(&self) -> Self {
4643 *self
4644 }
4645}
4646#[repr(C)]
4647pub struct WS_XML_INT32_TEXT {
4648 pub text: WS_XML_TEXT,
4649 pub value: i32,
4650}
4651impl ::core::marker::Copy for WS_XML_INT32_TEXT {}
4652impl ::core::clone::Clone for WS_XML_INT32_TEXT {
4653 fn clone(&self) -> Self {
4654 *self
4655 }
4656}
4657#[repr(C)]
4658pub struct WS_XML_INT64_TEXT {
4659 pub text: WS_XML_TEXT,
4660 pub value: i64,
4661}
4662impl ::core::marker::Copy for WS_XML_INT64_TEXT {}
4663impl ::core::clone::Clone for WS_XML_INT64_TEXT {
4664 fn clone(&self) -> Self {
4665 *self
4666 }
4667}
4668#[repr(C)]
4669pub struct WS_XML_LIST_TEXT {
4670 pub text: WS_XML_TEXT,
4671 pub itemCount: u32,
4672 pub items: *mut *mut WS_XML_TEXT,
4673}
4674impl ::core::marker::Copy for WS_XML_LIST_TEXT {}
4675impl ::core::clone::Clone for WS_XML_LIST_TEXT {
4676 fn clone(&self) -> Self {
4677 *self
4678 }
4679}
4680#[repr(C)]
4681pub struct WS_XML_NODE {
4682 pub nodeType: WS_XML_NODE_TYPE,
4683}
4684impl ::core::marker::Copy for WS_XML_NODE {}
4685impl ::core::clone::Clone for WS_XML_NODE {
4686 fn clone(&self) -> Self {
4687 *self
4688 }
4689}
4690#[repr(C)]
4691pub struct WS_XML_NODE_POSITION {
4692 pub buffer: *mut WS_XML_BUFFER,
4693 pub node: *mut ::core::ffi::c_void,
4694}
4695impl ::core::marker::Copy for WS_XML_NODE_POSITION {}
4696impl ::core::clone::Clone for WS_XML_NODE_POSITION {
4697 fn clone(&self) -> Self {
4698 *self
4699 }
4700}
4701pub type WS_XML_NODE_TYPE = i32;
4702pub const WS_XML_NODE_TYPE_ELEMENT: WS_XML_NODE_TYPE = 1i32;
4703pub const WS_XML_NODE_TYPE_TEXT: WS_XML_NODE_TYPE = 2i32;
4704pub const WS_XML_NODE_TYPE_END_ELEMENT: WS_XML_NODE_TYPE = 3i32;
4705pub const WS_XML_NODE_TYPE_COMMENT: WS_XML_NODE_TYPE = 4i32;
4706pub const WS_XML_NODE_TYPE_CDATA: WS_XML_NODE_TYPE = 6i32;
4707pub const WS_XML_NODE_TYPE_END_CDATA: WS_XML_NODE_TYPE = 7i32;
4708pub const WS_XML_NODE_TYPE_EOF: WS_XML_NODE_TYPE = 8i32;
4709pub const WS_XML_NODE_TYPE_BOF: WS_XML_NODE_TYPE = 9i32;
4710#[repr(C)]
4711#[cfg(feature = "Win32_Foundation")]
4712pub struct WS_XML_QNAME {
4713 pub localName: WS_XML_STRING,
4714 pub ns: WS_XML_STRING,
4715}
4716#[cfg(feature = "Win32_Foundation")]
4717impl ::core::marker::Copy for WS_XML_QNAME {}
4718#[cfg(feature = "Win32_Foundation")]
4719impl ::core::clone::Clone for WS_XML_QNAME {
4720 fn clone(&self) -> Self {
4721 *self
4722 }
4723}
4724#[repr(C)]
4725pub struct WS_XML_QNAME_DESCRIPTION {
4726 pub minLocalNameByteCount: u32,
4727 pub maxLocalNameByteCount: u32,
4728 pub minNsByteCount: u32,
4729 pub maxNsByteCount: u32,
4730}
4731impl ::core::marker::Copy for WS_XML_QNAME_DESCRIPTION {}
4732impl ::core::clone::Clone for WS_XML_QNAME_DESCRIPTION {
4733 fn clone(&self) -> Self {
4734 *self
4735 }
4736}
4737#[repr(C)]
4738#[cfg(feature = "Win32_Foundation")]
4739pub struct WS_XML_QNAME_TEXT {
4740 pub text: WS_XML_TEXT,
4741 pub prefix: *mut WS_XML_STRING,
4742 pub localName: *mut WS_XML_STRING,
4743 pub ns: *mut WS_XML_STRING,
4744}
4745#[cfg(feature = "Win32_Foundation")]
4746impl ::core::marker::Copy for WS_XML_QNAME_TEXT {}
4747#[cfg(feature = "Win32_Foundation")]
4748impl ::core::clone::Clone for WS_XML_QNAME_TEXT {
4749 fn clone(&self) -> Self {
4750 *self
4751 }
4752}
4753#[repr(C)]
4754pub struct WS_XML_READER(pub u8);
4755#[repr(C)]
4756#[cfg(feature = "Win32_Foundation")]
4757pub struct WS_XML_READER_BINARY_ENCODING {
4758 pub encoding: WS_XML_READER_ENCODING,
4759 pub staticDictionary: *mut WS_XML_DICTIONARY,
4760 pub dynamicDictionary: *mut WS_XML_DICTIONARY,
4761}
4762#[cfg(feature = "Win32_Foundation")]
4763impl ::core::marker::Copy for WS_XML_READER_BINARY_ENCODING {}
4764#[cfg(feature = "Win32_Foundation")]
4765impl ::core::clone::Clone for WS_XML_READER_BINARY_ENCODING {
4766 fn clone(&self) -> Self {
4767 *self
4768 }
4769}
4770#[repr(C)]
4771pub struct WS_XML_READER_BUFFER_INPUT {
4772 pub input: WS_XML_READER_INPUT,
4773 pub encodedData: *mut ::core::ffi::c_void,
4774 pub encodedDataSize: u32,
4775}
4776impl ::core::marker::Copy for WS_XML_READER_BUFFER_INPUT {}
4777impl ::core::clone::Clone for WS_XML_READER_BUFFER_INPUT {
4778 fn clone(&self) -> Self {
4779 *self
4780 }
4781}
4782#[repr(C)]
4783pub struct WS_XML_READER_ENCODING {
4784 pub encodingType: WS_XML_READER_ENCODING_TYPE,
4785}
4786impl ::core::marker::Copy for WS_XML_READER_ENCODING {}
4787impl ::core::clone::Clone for WS_XML_READER_ENCODING {
4788 fn clone(&self) -> Self {
4789 *self
4790 }
4791}
4792pub type WS_XML_READER_ENCODING_TYPE = i32;
4793pub const WS_XML_READER_ENCODING_TYPE_TEXT: WS_XML_READER_ENCODING_TYPE = 1i32;
4794pub const WS_XML_READER_ENCODING_TYPE_BINARY: WS_XML_READER_ENCODING_TYPE = 2i32;
4795pub const WS_XML_READER_ENCODING_TYPE_MTOM: WS_XML_READER_ENCODING_TYPE = 3i32;
4796pub const WS_XML_READER_ENCODING_TYPE_RAW: WS_XML_READER_ENCODING_TYPE = 4i32;
4797#[repr(C)]
4798pub struct WS_XML_READER_INPUT {
4799 pub inputType: WS_XML_READER_INPUT_TYPE,
4800}
4801impl ::core::marker::Copy for WS_XML_READER_INPUT {}
4802impl ::core::clone::Clone for WS_XML_READER_INPUT {
4803 fn clone(&self) -> Self {
4804 *self
4805 }
4806}
4807pub type WS_XML_READER_INPUT_TYPE = i32;
4808pub const WS_XML_READER_INPUT_TYPE_BUFFER: WS_XML_READER_INPUT_TYPE = 1i32;
4809pub const WS_XML_READER_INPUT_TYPE_STREAM: WS_XML_READER_INPUT_TYPE = 2i32;
4810#[repr(C)]
4811#[cfg(feature = "Win32_Foundation")]
4812pub struct WS_XML_READER_MTOM_ENCODING {
4813 pub encoding: WS_XML_READER_ENCODING,
4814 pub textEncoding: *mut WS_XML_READER_ENCODING,
4815 pub readMimeHeader: super::super::Foundation::BOOL,
4816 pub startInfo: WS_STRING,
4817 pub boundary: WS_STRING,
4818 pub startUri: WS_STRING,
4819}
4820#[cfg(feature = "Win32_Foundation")]
4821impl ::core::marker::Copy for WS_XML_READER_MTOM_ENCODING {}
4822#[cfg(feature = "Win32_Foundation")]
4823impl ::core::clone::Clone for WS_XML_READER_MTOM_ENCODING {
4824 fn clone(&self) -> Self {
4825 *self
4826 }
4827}
4828#[repr(C)]
4829pub struct WS_XML_READER_PROPERTIES {
4830 pub properties: *mut WS_XML_READER_PROPERTY,
4831 pub propertyCount: u32,
4832}
4833impl ::core::marker::Copy for WS_XML_READER_PROPERTIES {}
4834impl ::core::clone::Clone for WS_XML_READER_PROPERTIES {
4835 fn clone(&self) -> Self {
4836 *self
4837 }
4838}
4839#[repr(C)]
4840pub struct WS_XML_READER_PROPERTY {
4841 pub id: WS_XML_READER_PROPERTY_ID,
4842 pub value: *mut ::core::ffi::c_void,
4843 pub valueSize: u32,
4844}
4845impl ::core::marker::Copy for WS_XML_READER_PROPERTY {}
4846impl ::core::clone::Clone for WS_XML_READER_PROPERTY {
4847 fn clone(&self) -> Self {
4848 *self
4849 }
4850}
4851pub type WS_XML_READER_PROPERTY_ID = i32;
4852pub const WS_XML_READER_PROPERTY_MAX_DEPTH: WS_XML_READER_PROPERTY_ID = 0i32;
4853pub const WS_XML_READER_PROPERTY_ALLOW_FRAGMENT: WS_XML_READER_PROPERTY_ID = 1i32;
4854pub const WS_XML_READER_PROPERTY_MAX_ATTRIBUTES: WS_XML_READER_PROPERTY_ID = 2i32;
4855pub const WS_XML_READER_PROPERTY_READ_DECLARATION: WS_XML_READER_PROPERTY_ID = 3i32;
4856pub const WS_XML_READER_PROPERTY_CHARSET: WS_XML_READER_PROPERTY_ID = 4i32;
4857pub const WS_XML_READER_PROPERTY_ROW: WS_XML_READER_PROPERTY_ID = 5i32;
4858pub const WS_XML_READER_PROPERTY_COLUMN: WS_XML_READER_PROPERTY_ID = 6i32;
4859pub const WS_XML_READER_PROPERTY_UTF8_TRIM_SIZE: WS_XML_READER_PROPERTY_ID = 7i32;
4860pub const WS_XML_READER_PROPERTY_STREAM_BUFFER_SIZE: WS_XML_READER_PROPERTY_ID = 8i32;
4861pub const WS_XML_READER_PROPERTY_IN_ATTRIBUTE: WS_XML_READER_PROPERTY_ID = 9i32;
4862pub const WS_XML_READER_PROPERTY_STREAM_MAX_ROOT_MIME_PART_SIZE: WS_XML_READER_PROPERTY_ID = 10i32;
4863pub const WS_XML_READER_PROPERTY_STREAM_MAX_MIME_HEADERS_SIZE: WS_XML_READER_PROPERTY_ID = 11i32;
4864pub const WS_XML_READER_PROPERTY_MAX_MIME_PARTS: WS_XML_READER_PROPERTY_ID = 12i32;
4865pub const WS_XML_READER_PROPERTY_ALLOW_INVALID_CHARACTER_REFERENCES: WS_XML_READER_PROPERTY_ID = 13i32;
4866pub const WS_XML_READER_PROPERTY_MAX_NAMESPACES: WS_XML_READER_PROPERTY_ID = 14i32;
4867#[repr(C)]
4868pub struct WS_XML_READER_RAW_ENCODING {
4869 pub encoding: WS_XML_READER_ENCODING,
4870}
4871impl ::core::marker::Copy for WS_XML_READER_RAW_ENCODING {}
4872impl ::core::clone::Clone for WS_XML_READER_RAW_ENCODING {
4873 fn clone(&self) -> Self {
4874 *self
4875 }
4876}
4877#[repr(C)]
4878pub struct WS_XML_READER_STREAM_INPUT {
4879 pub input: WS_XML_READER_INPUT,
4880 pub readCallback: WS_READ_CALLBACK,
4881 pub readCallbackState: *mut ::core::ffi::c_void,
4882}
4883impl ::core::marker::Copy for WS_XML_READER_STREAM_INPUT {}
4884impl ::core::clone::Clone for WS_XML_READER_STREAM_INPUT {
4885 fn clone(&self) -> Self {
4886 *self
4887 }
4888}
4889#[repr(C)]
4890pub struct WS_XML_READER_TEXT_ENCODING {
4891 pub encoding: WS_XML_READER_ENCODING,
4892 pub charSet: WS_CHARSET,
4893}
4894impl ::core::marker::Copy for WS_XML_READER_TEXT_ENCODING {}
4895impl ::core::clone::Clone for WS_XML_READER_TEXT_ENCODING {
4896 fn clone(&self) -> Self {
4897 *self
4898 }
4899}
4900#[repr(C)]
4901pub struct WS_XML_SECURITY_TOKEN_PROPERTY {
4902 pub id: WS_XML_SECURITY_TOKEN_PROPERTY_ID,
4903 pub value: *mut ::core::ffi::c_void,
4904 pub valueSize: u32,
4905}
4906impl ::core::marker::Copy for WS_XML_SECURITY_TOKEN_PROPERTY {}
4907impl ::core::clone::Clone for WS_XML_SECURITY_TOKEN_PROPERTY {
4908 fn clone(&self) -> Self {
4909 *self
4910 }
4911}
4912pub type WS_XML_SECURITY_TOKEN_PROPERTY_ID = i32;
4913pub const WS_XML_SECURITY_TOKEN_PROPERTY_ATTACHED_REFERENCE: WS_XML_SECURITY_TOKEN_PROPERTY_ID = 1i32;
4914pub const WS_XML_SECURITY_TOKEN_PROPERTY_UNATTACHED_REFERENCE: WS_XML_SECURITY_TOKEN_PROPERTY_ID = 2i32;
4915pub const WS_XML_SECURITY_TOKEN_PROPERTY_VALID_FROM_TIME: WS_XML_SECURITY_TOKEN_PROPERTY_ID = 3i32;
4916pub const WS_XML_SECURITY_TOKEN_PROPERTY_VALID_TILL_TIME: WS_XML_SECURITY_TOKEN_PROPERTY_ID = 4i32;
4917#[repr(C)]
4918#[cfg(feature = "Win32_Foundation")]
4919pub struct WS_XML_STRING {
4920 pub length: u32,
4921 pub bytes: *mut u8,
4922 pub dictionary: *mut WS_XML_DICTIONARY,
4923 pub id: u32,
4924}
4925#[cfg(feature = "Win32_Foundation")]
4926impl ::core::marker::Copy for WS_XML_STRING {}
4927#[cfg(feature = "Win32_Foundation")]
4928impl ::core::clone::Clone for WS_XML_STRING {
4929 fn clone(&self) -> Self {
4930 *self
4931 }
4932}
4933#[repr(C)]
4934pub struct WS_XML_STRING_DESCRIPTION {
4935 pub minByteCount: u32,
4936 pub maxByteCount: u32,
4937}
4938impl ::core::marker::Copy for WS_XML_STRING_DESCRIPTION {}
4939impl ::core::clone::Clone for WS_XML_STRING_DESCRIPTION {
4940 fn clone(&self) -> Self {
4941 *self
4942 }
4943}
4944#[repr(C)]
4945pub struct WS_XML_TEXT {
4946 pub textType: WS_XML_TEXT_TYPE,
4947}
4948impl ::core::marker::Copy for WS_XML_TEXT {}
4949impl ::core::clone::Clone for WS_XML_TEXT {
4950 fn clone(&self) -> Self {
4951 *self
4952 }
4953}
4954#[repr(C)]
4955pub struct WS_XML_TEXT_NODE {
4956 pub node: WS_XML_NODE,
4957 pub text: *mut WS_XML_TEXT,
4958}
4959impl ::core::marker::Copy for WS_XML_TEXT_NODE {}
4960impl ::core::clone::Clone for WS_XML_TEXT_NODE {
4961 fn clone(&self) -> Self {
4962 *self
4963 }
4964}
4965pub type WS_XML_TEXT_TYPE = i32;
4966pub const WS_XML_TEXT_TYPE_UTF8: WS_XML_TEXT_TYPE = 1i32;
4967pub const WS_XML_TEXT_TYPE_UTF16: WS_XML_TEXT_TYPE = 2i32;
4968pub const WS_XML_TEXT_TYPE_BASE64: WS_XML_TEXT_TYPE = 3i32;
4969pub const WS_XML_TEXT_TYPE_BOOL: WS_XML_TEXT_TYPE = 4i32;
4970pub const WS_XML_TEXT_TYPE_INT32: WS_XML_TEXT_TYPE = 5i32;
4971pub const WS_XML_TEXT_TYPE_INT64: WS_XML_TEXT_TYPE = 6i32;
4972pub const WS_XML_TEXT_TYPE_UINT64: WS_XML_TEXT_TYPE = 7i32;
4973pub const WS_XML_TEXT_TYPE_FLOAT: WS_XML_TEXT_TYPE = 8i32;
4974pub const WS_XML_TEXT_TYPE_DOUBLE: WS_XML_TEXT_TYPE = 9i32;
4975pub const WS_XML_TEXT_TYPE_DECIMAL: WS_XML_TEXT_TYPE = 10i32;
4976pub const WS_XML_TEXT_TYPE_GUID: WS_XML_TEXT_TYPE = 11i32;
4977pub const WS_XML_TEXT_TYPE_UNIQUE_ID: WS_XML_TEXT_TYPE = 12i32;
4978pub const WS_XML_TEXT_TYPE_DATETIME: WS_XML_TEXT_TYPE = 13i32;
4979pub const WS_XML_TEXT_TYPE_TIMESPAN: WS_XML_TEXT_TYPE = 14i32;
4980pub const WS_XML_TEXT_TYPE_QNAME: WS_XML_TEXT_TYPE = 15i32;
4981pub const WS_XML_TEXT_TYPE_LIST: WS_XML_TEXT_TYPE = 16i32;
4982#[repr(C)]
4983pub struct WS_XML_TIMESPAN_TEXT {
4984 pub text: WS_XML_TEXT,
4985 pub value: WS_TIMESPAN,
4986}
4987impl ::core::marker::Copy for WS_XML_TIMESPAN_TEXT {}
4988impl ::core::clone::Clone for WS_XML_TIMESPAN_TEXT {
4989 fn clone(&self) -> Self {
4990 *self
4991 }
4992}
4993#[repr(C)]
4994pub struct WS_XML_TOKEN_MESSAGE_SECURITY_BINDING {
4995 pub binding: WS_SECURITY_BINDING,
4996 pub bindingUsage: WS_MESSAGE_SECURITY_USAGE,
4997 pub xmlToken: *mut WS_SECURITY_TOKEN,
4998}
4999impl ::core::marker::Copy for WS_XML_TOKEN_MESSAGE_SECURITY_BINDING {}
5000impl ::core::clone::Clone for WS_XML_TOKEN_MESSAGE_SECURITY_BINDING {
5001 fn clone(&self) -> Self {
5002 *self
5003 }
5004}
5005#[repr(C)]
5006pub struct WS_XML_UINT64_TEXT {
5007 pub text: WS_XML_TEXT,
5008 pub value: u64,
5009}
5010impl ::core::marker::Copy for WS_XML_UINT64_TEXT {}
5011impl ::core::clone::Clone for WS_XML_UINT64_TEXT {
5012 fn clone(&self) -> Self {
5013 *self
5014 }
5015}
5016#[repr(C)]
5017pub struct WS_XML_UNIQUE_ID_TEXT {
5018 pub text: WS_XML_TEXT,
5019 pub value: ::windows_sys::core::GUID,
5020}
5021impl ::core::marker::Copy for WS_XML_UNIQUE_ID_TEXT {}
5022impl ::core::clone::Clone for WS_XML_UNIQUE_ID_TEXT {
5023 fn clone(&self) -> Self {
5024 *self
5025 }
5026}
5027#[repr(C)]
5028pub struct WS_XML_UTF16_TEXT {
5029 pub text: WS_XML_TEXT,
5030 pub bytes: *mut u8,
5031 pub byteCount: u32,
5032}
5033impl ::core::marker::Copy for WS_XML_UTF16_TEXT {}
5034impl ::core::clone::Clone for WS_XML_UTF16_TEXT {
5035 fn clone(&self) -> Self {
5036 *self
5037 }
5038}
5039#[repr(C)]
5040#[cfg(feature = "Win32_Foundation")]
5041pub struct WS_XML_UTF8_TEXT {
5042 pub text: WS_XML_TEXT,
5043 pub value: WS_XML_STRING,
5044}
5045#[cfg(feature = "Win32_Foundation")]
5046impl ::core::marker::Copy for WS_XML_UTF8_TEXT {}
5047#[cfg(feature = "Win32_Foundation")]
5048impl ::core::clone::Clone for WS_XML_UTF8_TEXT {
5049 fn clone(&self) -> Self {
5050 *self
5051 }
5052}
5053#[repr(C)]
5054pub struct WS_XML_WRITER(pub u8);
5055#[repr(C)]
5056#[cfg(feature = "Win32_Foundation")]
5057pub struct WS_XML_WRITER_BINARY_ENCODING {
5058 pub encoding: WS_XML_WRITER_ENCODING,
5059 pub staticDictionary: *mut WS_XML_DICTIONARY,
5060 pub dynamicStringCallback: WS_DYNAMIC_STRING_CALLBACK,
5061 pub dynamicStringCallbackState: *mut ::core::ffi::c_void,
5062}
5063#[cfg(feature = "Win32_Foundation")]
5064impl ::core::marker::Copy for WS_XML_WRITER_BINARY_ENCODING {}
5065#[cfg(feature = "Win32_Foundation")]
5066impl ::core::clone::Clone for WS_XML_WRITER_BINARY_ENCODING {
5067 fn clone(&self) -> Self {
5068 *self
5069 }
5070}
5071#[repr(C)]
5072pub struct WS_XML_WRITER_BUFFER_OUTPUT {
5073 pub output: WS_XML_WRITER_OUTPUT,
5074}
5075impl ::core::marker::Copy for WS_XML_WRITER_BUFFER_OUTPUT {}
5076impl ::core::clone::Clone for WS_XML_WRITER_BUFFER_OUTPUT {
5077 fn clone(&self) -> Self {
5078 *self
5079 }
5080}
5081#[repr(C)]
5082pub struct WS_XML_WRITER_ENCODING {
5083 pub encodingType: WS_XML_WRITER_ENCODING_TYPE,
5084}
5085impl ::core::marker::Copy for WS_XML_WRITER_ENCODING {}
5086impl ::core::clone::Clone for WS_XML_WRITER_ENCODING {
5087 fn clone(&self) -> Self {
5088 *self
5089 }
5090}
5091pub type WS_XML_WRITER_ENCODING_TYPE = i32;
5092pub const WS_XML_WRITER_ENCODING_TYPE_TEXT: WS_XML_WRITER_ENCODING_TYPE = 1i32;
5093pub const WS_XML_WRITER_ENCODING_TYPE_BINARY: WS_XML_WRITER_ENCODING_TYPE = 2i32;
5094pub const WS_XML_WRITER_ENCODING_TYPE_MTOM: WS_XML_WRITER_ENCODING_TYPE = 3i32;
5095pub const WS_XML_WRITER_ENCODING_TYPE_RAW: WS_XML_WRITER_ENCODING_TYPE = 4i32;
5096#[repr(C)]
5097#[cfg(feature = "Win32_Foundation")]
5098pub struct WS_XML_WRITER_MTOM_ENCODING {
5099 pub encoding: WS_XML_WRITER_ENCODING,
5100 pub textEncoding: *mut WS_XML_WRITER_ENCODING,
5101 pub writeMimeHeader: super::super::Foundation::BOOL,
5102 pub boundary: WS_STRING,
5103 pub startInfo: WS_STRING,
5104 pub startUri: WS_STRING,
5105 pub maxInlineByteCount: u32,
5106}
5107#[cfg(feature = "Win32_Foundation")]
5108impl ::core::marker::Copy for WS_XML_WRITER_MTOM_ENCODING {}
5109#[cfg(feature = "Win32_Foundation")]
5110impl ::core::clone::Clone for WS_XML_WRITER_MTOM_ENCODING {
5111 fn clone(&self) -> Self {
5112 *self
5113 }
5114}
5115#[repr(C)]
5116pub struct WS_XML_WRITER_OUTPUT {
5117 pub outputType: WS_XML_WRITER_OUTPUT_TYPE,
5118}
5119impl ::core::marker::Copy for WS_XML_WRITER_OUTPUT {}
5120impl ::core::clone::Clone for WS_XML_WRITER_OUTPUT {
5121 fn clone(&self) -> Self {
5122 *self
5123 }
5124}
5125pub type WS_XML_WRITER_OUTPUT_TYPE = i32;
5126pub const WS_XML_WRITER_OUTPUT_TYPE_BUFFER: WS_XML_WRITER_OUTPUT_TYPE = 1i32;
5127pub const WS_XML_WRITER_OUTPUT_TYPE_STREAM: WS_XML_WRITER_OUTPUT_TYPE = 2i32;
5128#[repr(C)]
5129pub struct WS_XML_WRITER_PROPERTIES {
5130 pub properties: *mut WS_XML_WRITER_PROPERTY,
5131 pub propertyCount: u32,
5132}
5133impl ::core::marker::Copy for WS_XML_WRITER_PROPERTIES {}
5134impl ::core::clone::Clone for WS_XML_WRITER_PROPERTIES {
5135 fn clone(&self) -> Self {
5136 *self
5137 }
5138}
5139#[repr(C)]
5140pub struct WS_XML_WRITER_PROPERTY {
5141 pub id: WS_XML_WRITER_PROPERTY_ID,
5142 pub value: *mut ::core::ffi::c_void,
5143 pub valueSize: u32,
5144}
5145impl ::core::marker::Copy for WS_XML_WRITER_PROPERTY {}
5146impl ::core::clone::Clone for WS_XML_WRITER_PROPERTY {
5147 fn clone(&self) -> Self {
5148 *self
5149 }
5150}
5151pub type WS_XML_WRITER_PROPERTY_ID = i32;
5152pub const WS_XML_WRITER_PROPERTY_MAX_DEPTH: WS_XML_WRITER_PROPERTY_ID = 0i32;
5153pub const WS_XML_WRITER_PROPERTY_ALLOW_FRAGMENT: WS_XML_WRITER_PROPERTY_ID = 1i32;
5154pub const WS_XML_WRITER_PROPERTY_MAX_ATTRIBUTES: WS_XML_WRITER_PROPERTY_ID = 2i32;
5155pub const WS_XML_WRITER_PROPERTY_WRITE_DECLARATION: WS_XML_WRITER_PROPERTY_ID = 3i32;
5156pub const WS_XML_WRITER_PROPERTY_INDENT: WS_XML_WRITER_PROPERTY_ID = 4i32;
5157pub const WS_XML_WRITER_PROPERTY_BUFFER_TRIM_SIZE: WS_XML_WRITER_PROPERTY_ID = 5i32;
5158pub const WS_XML_WRITER_PROPERTY_CHARSET: WS_XML_WRITER_PROPERTY_ID = 6i32;
5159pub const WS_XML_WRITER_PROPERTY_BUFFERS: WS_XML_WRITER_PROPERTY_ID = 7i32;
5160pub const WS_XML_WRITER_PROPERTY_BUFFER_MAX_SIZE: WS_XML_WRITER_PROPERTY_ID = 8i32;
5161pub const WS_XML_WRITER_PROPERTY_BYTES: WS_XML_WRITER_PROPERTY_ID = 9i32;
5162pub const WS_XML_WRITER_PROPERTY_IN_ATTRIBUTE: WS_XML_WRITER_PROPERTY_ID = 10i32;
5163pub const WS_XML_WRITER_PROPERTY_MAX_MIME_PARTS_BUFFER_SIZE: WS_XML_WRITER_PROPERTY_ID = 11i32;
5164pub const WS_XML_WRITER_PROPERTY_INITIAL_BUFFER: WS_XML_WRITER_PROPERTY_ID = 12i32;
5165pub const WS_XML_WRITER_PROPERTY_ALLOW_INVALID_CHARACTER_REFERENCES: WS_XML_WRITER_PROPERTY_ID = 13i32;
5166pub const WS_XML_WRITER_PROPERTY_MAX_NAMESPACES: WS_XML_WRITER_PROPERTY_ID = 14i32;
5167pub const WS_XML_WRITER_PROPERTY_BYTES_WRITTEN: WS_XML_WRITER_PROPERTY_ID = 15i32;
5168pub const WS_XML_WRITER_PROPERTY_BYTES_TO_CLOSE: WS_XML_WRITER_PROPERTY_ID = 16i32;
5169pub const WS_XML_WRITER_PROPERTY_COMPRESS_EMPTY_ELEMENTS: WS_XML_WRITER_PROPERTY_ID = 17i32;
5170pub const WS_XML_WRITER_PROPERTY_EMIT_UNCOMPRESSED_EMPTY_ELEMENTS: WS_XML_WRITER_PROPERTY_ID = 18i32;
5171#[repr(C)]
5172pub struct WS_XML_WRITER_RAW_ENCODING {
5173 pub encoding: WS_XML_WRITER_ENCODING,
5174}
5175impl ::core::marker::Copy for WS_XML_WRITER_RAW_ENCODING {}
5176impl ::core::clone::Clone for WS_XML_WRITER_RAW_ENCODING {
5177 fn clone(&self) -> Self {
5178 *self
5179 }
5180}
5181#[repr(C)]
5182pub struct WS_XML_WRITER_STREAM_OUTPUT {
5183 pub output: WS_XML_WRITER_OUTPUT,
5184 pub writeCallback: WS_WRITE_CALLBACK,
5185 pub writeCallbackState: *mut ::core::ffi::c_void,
5186}
5187impl ::core::marker::Copy for WS_XML_WRITER_STREAM_OUTPUT {}
5188impl ::core::clone::Clone for WS_XML_WRITER_STREAM_OUTPUT {
5189 fn clone(&self) -> Self {
5190 *self
5191 }
5192}
5193#[repr(C)]
5194pub struct WS_XML_WRITER_TEXT_ENCODING {
5195 pub encoding: WS_XML_WRITER_ENCODING,
5196 pub charSet: WS_CHARSET,
5197}
5198impl ::core::marker::Copy for WS_XML_WRITER_TEXT_ENCODING {}
5199impl ::core::clone::Clone for WS_XML_WRITER_TEXT_ENCODING {
5200 fn clone(&self) -> Self {
5201 *self
5202 }
5203}
backport for Debian buster