1 #![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
2 #[cfg(feature = "Win32_Security_Cryptography_Catalog")]
3 pub mod Catalog;
4 #[cfg(feature = "Win32_Security_Cryptography_Certificates")]
5 pub mod Certificates;
6 #[cfg(feature = "Win32_Security_Cryptography_Sip")]
7 pub mod Sip;
8 pub const ACTION_REVOCATION_DEFAULT_CACHE: u32 = 131072u32;
9 pub const ACTION_REVOCATION_DEFAULT_ONLINE: u32 = 65536u32;
10 pub const ALG_CLASS_ALL: u32 = 57344u32;
11 pub const ALG_CLASS_ANY: u32 = 0u32;
12 pub const ALG_CLASS_DATA_ENCRYPT: u32 = 24576u32;
13 pub const ALG_CLASS_HASH: u32 = 32768u32;
14 pub const ALG_CLASS_KEY_EXCHANGE: u32 = 40960u32;
15 pub const ALG_CLASS_MSG_ENCRYPT: u32 = 16384u32;
16 pub const ALG_CLASS_SIGNATURE: u32 = 8192u32;
17 pub const ALG_SID_3DES: u32 = 3u32;
18 pub const ALG_SID_3DES_112: u32 = 9u32;
19 pub const ALG_SID_AES: u32 = 17u32;
20 pub const ALG_SID_AES_128: u32 = 14u32;
21 pub const ALG_SID_AES_192: u32 = 15u32;
22 pub const ALG_SID_AES_256: u32 = 16u32;
23 pub const ALG_SID_AGREED_KEY_ANY: u32 = 3u32;
24 pub const ALG_SID_ANY: u32 = 0u32;
25 pub const ALG_SID_CAST: u32 = 6u32;
26 pub const ALG_SID_CYLINK_MEK: u32 = 12u32;
27 pub const ALG_SID_DES: u32 = 1u32;
28 pub const ALG_SID_DESX: u32 = 4u32;
29 pub const ALG_SID_DH_EPHEM: u32 = 2u32;
30 pub const ALG_SID_DH_SANDF: u32 = 1u32;
31 pub const ALG_SID_DSS_ANY: u32 = 0u32;
32 pub const ALG_SID_DSS_DMS: u32 = 2u32;
33 pub const ALG_SID_DSS_PKCS: u32 = 1u32;
34 pub const ALG_SID_ECDH: u32 = 5u32;
35 pub const ALG_SID_ECDH_EPHEM: u32 = 6u32;
36 pub const ALG_SID_ECDSA: u32 = 3u32;
37 pub const ALG_SID_ECMQV: u32 = 1u32;
38 pub const ALG_SID_EXAMPLE: u32 = 80u32;
39 pub const ALG_SID_HASH_REPLACE_OWF: u32 = 11u32;
40 pub const ALG_SID_HMAC: u32 = 9u32;
41 pub const ALG_SID_IDEA: u32 = 5u32;
42 pub const ALG_SID_KEA: u32 = 4u32;
43 pub const ALG_SID_MAC: u32 = 5u32;
44 pub const ALG_SID_MD2: u32 = 1u32;
45 pub const ALG_SID_MD4: u32 = 2u32;
46 pub const ALG_SID_MD5: u32 = 3u32;
47 pub const ALG_SID_PCT1_MASTER: u32 = 4u32;
48 pub const ALG_SID_RC2: u32 = 2u32;
49 pub const ALG_SID_RC4: u32 = 1u32;
50 pub const ALG_SID_RC5: u32 = 13u32;
51 pub const ALG_SID_RIPEMD: u32 = 6u32;
52 pub const ALG_SID_RIPEMD160: u32 = 7u32;
53 pub const ALG_SID_RSA_ANY: u32 = 0u32;
54 pub const ALG_SID_RSA_ENTRUST: u32 = 3u32;
55 pub const ALG_SID_RSA_MSATWORK: u32 = 2u32;
56 pub const ALG_SID_RSA_PGP: u32 = 4u32;
57 pub const ALG_SID_RSA_PKCS: u32 = 1u32;
58 pub const ALG_SID_SAFERSK128: u32 = 8u32;
59 pub const ALG_SID_SAFERSK64: u32 = 7u32;
60 pub const ALG_SID_SCHANNEL_ENC_KEY: u32 = 7u32;
61 pub const ALG_SID_SCHANNEL_MAC_KEY: u32 = 3u32;
62 pub const ALG_SID_SCHANNEL_MASTER_HASH: u32 = 2u32;
63 pub const ALG_SID_SEAL: u32 = 2u32;
64 pub const ALG_SID_SHA: u32 = 4u32;
65 pub const ALG_SID_SHA1: u32 = 4u32;
66 pub const ALG_SID_SHA_256: u32 = 12u32;
67 pub const ALG_SID_SHA_384: u32 = 13u32;
68 pub const ALG_SID_SHA_512: u32 = 14u32;
69 pub const ALG_SID_SKIPJACK: u32 = 10u32;
70 pub const ALG_SID_SSL2_MASTER: u32 = 5u32;
71 pub const ALG_SID_SSL3SHAMD5: u32 = 8u32;
72 pub const ALG_SID_SSL3_MASTER: u32 = 1u32;
73 pub const ALG_SID_TEK: u32 = 11u32;
74 pub const ALG_SID_THIRDPARTY_ANY: u32 = 0u32;
75 pub const ALG_SID_TLS1PRF: u32 = 10u32;
76 pub const ALG_SID_TLS1_MASTER: u32 = 6u32;
77 pub const ALG_TYPE_ANY: u32 = 0u32;
78 pub const ALG_TYPE_BLOCK: u32 = 1536u32;
79 pub const ALG_TYPE_DH: u32 = 2560u32;
80 pub const ALG_TYPE_DSS: u32 = 512u32;
81 pub const ALG_TYPE_ECDH: u32 = 3584u32;
82 pub const ALG_TYPE_RSA: u32 = 1024u32;
83 pub const ALG_TYPE_SECURECHANNEL: u32 = 3072u32;
84 pub const ALG_TYPE_STREAM: u32 = 2048u32;
85 pub const ALG_TYPE_THIRDPARTY: u32 = 4096u32;
86 pub const AUDIT_CARD_DELETE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(1074070017i32 as _);
87 pub const AUDIT_CARD_IMPORT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(1074070018i32 as _);
88 pub const AUDIT_CARD_WRITTEN: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(1074070016i32 as _);
89 pub const AUDIT_SERVICE_IDLE_STOP: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(1074070022i32 as _);
90 pub const AUDIT_STORE_DELETE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(1074070021i32 as _);
91 pub const AUDIT_STORE_EXPORT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(1074070020i32 as _);
92 pub const AUDIT_STORE_IMPORT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(1074070019i32 as _);
93 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
94 #[repr(C)]
95 #[cfg(feature = "Win32_Foundation")]
96 pub struct AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA {
97     pub cbSize: u32,
98     pub dwRegPolicySettings: u32,
99     pub pSignerInfo: *mut CMSG_SIGNER_INFO,
100 }
101 #[cfg(feature = "Win32_Foundation")]
102 impl AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA {}
103 #[cfg(feature = "Win32_Foundation")]
104 impl ::std::default::Default for AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA {
default() -> Self105     fn default() -> Self {
106         unsafe { ::std::mem::zeroed() }
107     }
108 }
109 #[cfg(feature = "Win32_Foundation")]
110 impl ::std::fmt::Debug for AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result111     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
112         fmt.debug_struct("AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA").field("cbSize", &self.cbSize).field("dwRegPolicySettings", &self.dwRegPolicySettings).field("pSignerInfo", &self.pSignerInfo).finish()
113     }
114 }
115 #[cfg(feature = "Win32_Foundation")]
116 impl ::std::cmp::PartialEq for AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA {
eq(&self, other: &Self) -> bool117     fn eq(&self, other: &Self) -> bool {
118         self.cbSize == other.cbSize && self.dwRegPolicySettings == other.dwRegPolicySettings && self.pSignerInfo == other.pSignerInfo
119     }
120 }
121 #[cfg(feature = "Win32_Foundation")]
122 impl ::std::cmp::Eq for AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA {}
123 #[cfg(feature = "Win32_Foundation")]
124 unsafe impl ::windows::runtime::Abi for AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA {
125     type Abi = Self;
126     type DefaultType = Self;
127 }
128 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
129 #[repr(C)]
130 #[cfg(feature = "Win32_Foundation")]
131 pub struct AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS {
132     pub cbSize: u32,
133     pub fCommercial: super::super::Foundation::BOOL,
134 }
135 #[cfg(feature = "Win32_Foundation")]
136 impl AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS {}
137 #[cfg(feature = "Win32_Foundation")]
138 impl ::std::default::Default for AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS {
default() -> Self139     fn default() -> Self {
140         unsafe { ::std::mem::zeroed() }
141     }
142 }
143 #[cfg(feature = "Win32_Foundation")]
144 impl ::std::fmt::Debug for AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result145     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
146         fmt.debug_struct("AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS").field("cbSize", &self.cbSize).field("fCommercial", &self.fCommercial).finish()
147     }
148 }
149 #[cfg(feature = "Win32_Foundation")]
150 impl ::std::cmp::PartialEq for AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS {
eq(&self, other: &Self) -> bool151     fn eq(&self, other: &Self) -> bool {
152         self.cbSize == other.cbSize && self.fCommercial == other.fCommercial
153     }
154 }
155 #[cfg(feature = "Win32_Foundation")]
156 impl ::std::cmp::Eq for AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS {}
157 #[cfg(feature = "Win32_Foundation")]
158 unsafe impl ::windows::runtime::Abi for AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS {
159     type Abi = Self;
160     type DefaultType = Self;
161 }
162 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
163 #[repr(C)]
164 #[cfg(feature = "Win32_Foundation")]
165 pub struct AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA {
166     pub cbSize: u32,
167     pub dwRegPolicySettings: u32,
168     pub fCommercial: super::super::Foundation::BOOL,
169 }
170 #[cfg(feature = "Win32_Foundation")]
171 impl AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA {}
172 #[cfg(feature = "Win32_Foundation")]
173 impl ::std::default::Default for AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA {
default() -> Self174     fn default() -> Self {
175         unsafe { ::std::mem::zeroed() }
176     }
177 }
178 #[cfg(feature = "Win32_Foundation")]
179 impl ::std::fmt::Debug for AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result180     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
181         fmt.debug_struct("AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA").field("cbSize", &self.cbSize).field("dwRegPolicySettings", &self.dwRegPolicySettings).field("fCommercial", &self.fCommercial).finish()
182     }
183 }
184 #[cfg(feature = "Win32_Foundation")]
185 impl ::std::cmp::PartialEq for AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA {
eq(&self, other: &Self) -> bool186     fn eq(&self, other: &Self) -> bool {
187         self.cbSize == other.cbSize && self.dwRegPolicySettings == other.dwRegPolicySettings && self.fCommercial == other.fCommercial
188     }
189 }
190 #[cfg(feature = "Win32_Foundation")]
191 impl ::std::cmp::Eq for AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA {}
192 #[cfg(feature = "Win32_Foundation")]
193 unsafe impl ::windows::runtime::Abi for AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA {
194     type Abi = Self;
195     type DefaultType = Self;
196 }
197 pub const BASIC_CONSTRAINTS_CERT_CHAIN_POLICY_CA_FLAG: u32 = 2147483648u32;
198 pub const BASIC_CONSTRAINTS_CERT_CHAIN_POLICY_END_ENTITY_FLAG: u32 = 1073741824u32;
199 pub const BCRYPTBUFFER_VERSION: u32 = 0u32;
200 pub const BCRYPT_3DES_112_CBC_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(369u32 as _);
201 pub const BCRYPT_3DES_112_CFB_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(401u32 as _);
202 pub const BCRYPT_3DES_112_ECB_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(385u32 as _);
203 pub const BCRYPT_3DES_CBC_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(321u32 as _);
204 pub const BCRYPT_3DES_CFB_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(353u32 as _);
205 pub const BCRYPT_3DES_ECB_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(337u32 as _);
206 pub const BCRYPT_AES_CBC_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(417u32 as _);
207 pub const BCRYPT_AES_CCM_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(465u32 as _);
208 pub const BCRYPT_AES_CFB_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(449u32 as _);
209 pub const BCRYPT_AES_CMAC_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(257u32 as _);
210 pub const BCRYPT_AES_ECB_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(433u32 as _);
211 pub const BCRYPT_AES_GCM_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(481u32 as _);
212 pub const BCRYPT_AES_GMAC_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(273u32 as _);
213 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
214 #[repr(C)]
215 #[cfg(feature = "Win32_Foundation")]
216 pub struct BCRYPT_ALGORITHM_IDENTIFIER {
217     pub pszName: super::super::Foundation::PWSTR,
218     pub dwClass: u32,
219     pub dwFlags: u32,
220 }
221 #[cfg(feature = "Win32_Foundation")]
222 impl BCRYPT_ALGORITHM_IDENTIFIER {}
223 #[cfg(feature = "Win32_Foundation")]
224 impl ::std::default::Default for BCRYPT_ALGORITHM_IDENTIFIER {
default() -> Self225     fn default() -> Self {
226         unsafe { ::std::mem::zeroed() }
227     }
228 }
229 #[cfg(feature = "Win32_Foundation")]
230 impl ::std::fmt::Debug for BCRYPT_ALGORITHM_IDENTIFIER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result231     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
232         fmt.debug_struct("BCRYPT_ALGORITHM_IDENTIFIER").field("pszName", &self.pszName).field("dwClass", &self.dwClass).field("dwFlags", &self.dwFlags).finish()
233     }
234 }
235 #[cfg(feature = "Win32_Foundation")]
236 impl ::std::cmp::PartialEq for BCRYPT_ALGORITHM_IDENTIFIER {
eq(&self, other: &Self) -> bool237     fn eq(&self, other: &Self) -> bool {
238         self.pszName == other.pszName && self.dwClass == other.dwClass && self.dwFlags == other.dwFlags
239     }
240 }
241 #[cfg(feature = "Win32_Foundation")]
242 impl ::std::cmp::Eq for BCRYPT_ALGORITHM_IDENTIFIER {}
243 #[cfg(feature = "Win32_Foundation")]
244 unsafe impl ::windows::runtime::Abi for BCRYPT_ALGORITHM_IDENTIFIER {
245     type Abi = Self;
246     type DefaultType = Self;
247 }
248 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
249 #[repr(transparent)]
250 pub struct BCRYPT_ALG_HANDLE(pub isize);
251 impl ::std::default::Default for BCRYPT_ALG_HANDLE {
default() -> Self252     fn default() -> Self {
253         unsafe { ::std::mem::zeroed() }
254     }
255 }
256 unsafe impl ::windows::runtime::Handle for BCRYPT_ALG_HANDLE {}
257 unsafe impl ::windows::runtime::Abi for BCRYPT_ALG_HANDLE {
258     type Abi = Self;
259     type DefaultType = Self;
260 }
261 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
262 #[repr(C)]
263 pub struct BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO {
264     pub cbSize: u32,
265     pub dwInfoVersion: u32,
266     pub pbNonce: *mut u8,
267     pub cbNonce: u32,
268     pub pbAuthData: *mut u8,
269     pub cbAuthData: u32,
270     pub pbTag: *mut u8,
271     pub cbTag: u32,
272     pub pbMacContext: *mut u8,
273     pub cbMacContext: u32,
274     pub cbAAD: u32,
275     pub cbData: u64,
276     pub dwFlags: u32,
277 }
278 impl BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO {}
279 impl ::std::default::Default for BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO {
default() -> Self280     fn default() -> Self {
281         unsafe { ::std::mem::zeroed() }
282     }
283 }
284 impl ::std::fmt::Debug for BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result285     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
286         fmt.debug_struct("BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO")
287             .field("cbSize", &self.cbSize)
288             .field("dwInfoVersion", &self.dwInfoVersion)
289             .field("pbNonce", &self.pbNonce)
290             .field("cbNonce", &self.cbNonce)
291             .field("pbAuthData", &self.pbAuthData)
292             .field("cbAuthData", &self.cbAuthData)
293             .field("pbTag", &self.pbTag)
294             .field("cbTag", &self.cbTag)
295             .field("pbMacContext", &self.pbMacContext)
296             .field("cbMacContext", &self.cbMacContext)
297             .field("cbAAD", &self.cbAAD)
298             .field("cbData", &self.cbData)
299             .field("dwFlags", &self.dwFlags)
300             .finish()
301     }
302 }
303 impl ::std::cmp::PartialEq for BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO {
eq(&self, other: &Self) -> bool304     fn eq(&self, other: &Self) -> bool {
305         self.cbSize == other.cbSize && self.dwInfoVersion == other.dwInfoVersion && self.pbNonce == other.pbNonce && self.cbNonce == other.cbNonce && self.pbAuthData == other.pbAuthData && self.cbAuthData == other.cbAuthData && self.pbTag == other.pbTag && self.cbTag == other.cbTag && self.pbMacContext == other.pbMacContext && self.cbMacContext == other.cbMacContext && self.cbAAD == other.cbAAD && self.cbData == other.cbData && self.dwFlags == other.dwFlags
306     }
307 }
308 impl ::std::cmp::Eq for BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO {}
309 unsafe impl ::windows::runtime::Abi for BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO {
310     type Abi = Self;
311     type DefaultType = Self;
312 }
313 pub const BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO_VERSION: u32 = 1u32;
314 pub const BCRYPT_AUTH_MODE_CHAIN_CALLS_FLAG: u32 = 1u32;
315 pub const BCRYPT_AUTH_MODE_IN_PROGRESS_FLAG: u32 = 2u32;
316 pub const BCRYPT_BLOCK_PADDING: u32 = 1u32;
317 pub const BCRYPT_BUFFERS_LOCKED_FLAG: u32 = 64u32;
318 pub const BCRYPT_CAPI_AES_FLAG: u32 = 16u32;
319 pub const BCRYPT_CAPI_KDF_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(801u32 as _);
320 pub const BCRYPT_CHACHA20_POLY1305_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(929u32 as _);
321 pub const BCRYPT_DESX_CBC_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(545u32 as _);
322 pub const BCRYPT_DESX_CFB_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(577u32 as _);
323 pub const BCRYPT_DESX_ECB_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(561u32 as _);
324 pub const BCRYPT_DES_CBC_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(497u32 as _);
325 pub const BCRYPT_DES_CFB_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(529u32 as _);
326 pub const BCRYPT_DES_ECB_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(513u32 as _);
327 pub const BCRYPT_DH_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(641u32 as _);
328 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
329 #[repr(C)]
330 pub struct BCRYPT_DH_KEY_BLOB {
331     pub dwMagic: BCRYPT_DH_KEY_BLOB_MAGIC,
332     pub cbKey: u32,
333 }
334 impl BCRYPT_DH_KEY_BLOB {}
335 impl ::std::default::Default for BCRYPT_DH_KEY_BLOB {
default() -> Self336     fn default() -> Self {
337         unsafe { ::std::mem::zeroed() }
338     }
339 }
340 impl ::std::fmt::Debug for BCRYPT_DH_KEY_BLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result341     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
342         fmt.debug_struct("BCRYPT_DH_KEY_BLOB").field("dwMagic", &self.dwMagic).field("cbKey", &self.cbKey).finish()
343     }
344 }
345 impl ::std::cmp::PartialEq for BCRYPT_DH_KEY_BLOB {
eq(&self, other: &Self) -> bool346     fn eq(&self, other: &Self) -> bool {
347         self.dwMagic == other.dwMagic && self.cbKey == other.cbKey
348     }
349 }
350 impl ::std::cmp::Eq for BCRYPT_DH_KEY_BLOB {}
351 unsafe impl ::windows::runtime::Abi for BCRYPT_DH_KEY_BLOB {
352     type Abi = Self;
353     type DefaultType = Self;
354 }
355 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
356 #[repr(transparent)]
357 pub struct BCRYPT_DH_KEY_BLOB_MAGIC(pub u32);
358 pub const BCRYPT_DH_PUBLIC_MAGIC: BCRYPT_DH_KEY_BLOB_MAGIC = BCRYPT_DH_KEY_BLOB_MAGIC(1112557636u32);
359 pub const BCRYPT_DH_PRIVATE_MAGIC: BCRYPT_DH_KEY_BLOB_MAGIC = BCRYPT_DH_KEY_BLOB_MAGIC(1448101956u32);
360 impl ::std::convert::From<u32> for BCRYPT_DH_KEY_BLOB_MAGIC {
from(value: u32) -> Self361     fn from(value: u32) -> Self {
362         Self(value)
363     }
364 }
365 unsafe impl ::windows::runtime::Abi for BCRYPT_DH_KEY_BLOB_MAGIC {
366     type Abi = Self;
367     type DefaultType = Self;
368 }
369 impl ::std::ops::BitOr for BCRYPT_DH_KEY_BLOB_MAGIC {
370     type Output = Self;
bitor(self, rhs: Self) -> Self371     fn bitor(self, rhs: Self) -> Self {
372         Self(self.0 | rhs.0)
373     }
374 }
375 impl ::std::ops::BitAnd for BCRYPT_DH_KEY_BLOB_MAGIC {
376     type Output = Self;
bitand(self, rhs: Self) -> Self377     fn bitand(self, rhs: Self) -> Self {
378         Self(self.0 & rhs.0)
379     }
380 }
381 impl ::std::ops::BitOrAssign for BCRYPT_DH_KEY_BLOB_MAGIC {
bitor_assign(&mut self, rhs: Self)382     fn bitor_assign(&mut self, rhs: Self) {
383         self.0.bitor_assign(rhs.0)
384     }
385 }
386 impl ::std::ops::BitAndAssign for BCRYPT_DH_KEY_BLOB_MAGIC {
bitand_assign(&mut self, rhs: Self)387     fn bitand_assign(&mut self, rhs: Self) {
388         self.0.bitand_assign(rhs.0)
389     }
390 }
391 impl ::std::ops::Not for BCRYPT_DH_KEY_BLOB_MAGIC {
392     type Output = Self;
not(self) -> Self393     fn not(self) -> Self {
394         Self(self.0.not())
395     }
396 }
397 pub const BCRYPT_DH_PARAMETERS_MAGIC: u32 = 1297107012u32;
398 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
399 #[repr(C)]
400 pub struct BCRYPT_DH_PARAMETER_HEADER {
401     pub cbLength: u32,
402     pub dwMagic: u32,
403     pub cbKeyLength: u32,
404 }
405 impl BCRYPT_DH_PARAMETER_HEADER {}
406 impl ::std::default::Default for BCRYPT_DH_PARAMETER_HEADER {
default() -> Self407     fn default() -> Self {
408         unsafe { ::std::mem::zeroed() }
409     }
410 }
411 impl ::std::fmt::Debug for BCRYPT_DH_PARAMETER_HEADER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result412     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
413         fmt.debug_struct("BCRYPT_DH_PARAMETER_HEADER").field("cbLength", &self.cbLength).field("dwMagic", &self.dwMagic).field("cbKeyLength", &self.cbKeyLength).finish()
414     }
415 }
416 impl ::std::cmp::PartialEq for BCRYPT_DH_PARAMETER_HEADER {
eq(&self, other: &Self) -> bool417     fn eq(&self, other: &Self) -> bool {
418         self.cbLength == other.cbLength && self.dwMagic == other.dwMagic && self.cbKeyLength == other.cbKeyLength
419     }
420 }
421 impl ::std::cmp::Eq for BCRYPT_DH_PARAMETER_HEADER {}
422 unsafe impl ::windows::runtime::Abi for BCRYPT_DH_PARAMETER_HEADER {
423     type Abi = Self;
424     type DefaultType = Self;
425 }
426 pub const BCRYPT_DSA_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(721u32 as _);
427 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
428 #[repr(C)]
429 pub struct BCRYPT_DSA_KEY_BLOB {
430     pub dwMagic: BCRYPT_DSA_MAGIC,
431     pub cbKey: u32,
432     pub Count: [u8; 4],
433     pub Seed: [u8; 20],
434     pub q: [u8; 20],
435 }
436 impl BCRYPT_DSA_KEY_BLOB {}
437 impl ::std::default::Default for BCRYPT_DSA_KEY_BLOB {
default() -> Self438     fn default() -> Self {
439         unsafe { ::std::mem::zeroed() }
440     }
441 }
442 impl ::std::fmt::Debug for BCRYPT_DSA_KEY_BLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result443     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
444         fmt.debug_struct("BCRYPT_DSA_KEY_BLOB").field("dwMagic", &self.dwMagic).field("cbKey", &self.cbKey).field("Count", &self.Count).field("Seed", &self.Seed).field("q", &self.q).finish()
445     }
446 }
447 impl ::std::cmp::PartialEq for BCRYPT_DSA_KEY_BLOB {
eq(&self, other: &Self) -> bool448     fn eq(&self, other: &Self) -> bool {
449         self.dwMagic == other.dwMagic && self.cbKey == other.cbKey && self.Count == other.Count && self.Seed == other.Seed && self.q == other.q
450     }
451 }
452 impl ::std::cmp::Eq for BCRYPT_DSA_KEY_BLOB {}
453 unsafe impl ::windows::runtime::Abi for BCRYPT_DSA_KEY_BLOB {
454     type Abi = Self;
455     type DefaultType = Self;
456 }
457 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
458 #[repr(C)]
459 pub struct BCRYPT_DSA_KEY_BLOB_V2 {
460     pub dwMagic: BCRYPT_DSA_MAGIC,
461     pub cbKey: u32,
462     pub hashAlgorithm: HASHALGORITHM_ENUM,
463     pub standardVersion: DSAFIPSVERSION_ENUM,
464     pub cbSeedLength: u32,
465     pub cbGroupSize: u32,
466     pub Count: [u8; 4],
467 }
468 impl BCRYPT_DSA_KEY_BLOB_V2 {}
469 impl ::std::default::Default for BCRYPT_DSA_KEY_BLOB_V2 {
default() -> Self470     fn default() -> Self {
471         unsafe { ::std::mem::zeroed() }
472     }
473 }
474 impl ::std::fmt::Debug for BCRYPT_DSA_KEY_BLOB_V2 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result475     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
476         fmt.debug_struct("BCRYPT_DSA_KEY_BLOB_V2")
477             .field("dwMagic", &self.dwMagic)
478             .field("cbKey", &self.cbKey)
479             .field("hashAlgorithm", &self.hashAlgorithm)
480             .field("standardVersion", &self.standardVersion)
481             .field("cbSeedLength", &self.cbSeedLength)
482             .field("cbGroupSize", &self.cbGroupSize)
483             .field("Count", &self.Count)
484             .finish()
485     }
486 }
487 impl ::std::cmp::PartialEq for BCRYPT_DSA_KEY_BLOB_V2 {
eq(&self, other: &Self) -> bool488     fn eq(&self, other: &Self) -> bool {
489         self.dwMagic == other.dwMagic && self.cbKey == other.cbKey && self.hashAlgorithm == other.hashAlgorithm && self.standardVersion == other.standardVersion && self.cbSeedLength == other.cbSeedLength && self.cbGroupSize == other.cbGroupSize && self.Count == other.Count
490     }
491 }
492 impl ::std::cmp::Eq for BCRYPT_DSA_KEY_BLOB_V2 {}
493 unsafe impl ::windows::runtime::Abi for BCRYPT_DSA_KEY_BLOB_V2 {
494     type Abi = Self;
495     type DefaultType = Self;
496 }
497 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
498 #[repr(transparent)]
499 pub struct BCRYPT_DSA_MAGIC(pub u32);
500 pub const BCRYPT_DSA_PUBLIC_MAGIC: BCRYPT_DSA_MAGIC = BCRYPT_DSA_MAGIC(1112560452u32);
501 pub const BCRYPT_DSA_PRIVATE_MAGIC: BCRYPT_DSA_MAGIC = BCRYPT_DSA_MAGIC(1448104772u32);
502 impl ::std::convert::From<u32> for BCRYPT_DSA_MAGIC {
from(value: u32) -> Self503     fn from(value: u32) -> Self {
504         Self(value)
505     }
506 }
507 unsafe impl ::windows::runtime::Abi for BCRYPT_DSA_MAGIC {
508     type Abi = Self;
509     type DefaultType = Self;
510 }
511 impl ::std::ops::BitOr for BCRYPT_DSA_MAGIC {
512     type Output = Self;
bitor(self, rhs: Self) -> Self513     fn bitor(self, rhs: Self) -> Self {
514         Self(self.0 | rhs.0)
515     }
516 }
517 impl ::std::ops::BitAnd for BCRYPT_DSA_MAGIC {
518     type Output = Self;
bitand(self, rhs: Self) -> Self519     fn bitand(self, rhs: Self) -> Self {
520         Self(self.0 & rhs.0)
521     }
522 }
523 impl ::std::ops::BitOrAssign for BCRYPT_DSA_MAGIC {
bitor_assign(&mut self, rhs: Self)524     fn bitor_assign(&mut self, rhs: Self) {
525         self.0.bitor_assign(rhs.0)
526     }
527 }
528 impl ::std::ops::BitAndAssign for BCRYPT_DSA_MAGIC {
bitand_assign(&mut self, rhs: Self)529     fn bitand_assign(&mut self, rhs: Self) {
530         self.0.bitand_assign(rhs.0)
531     }
532 }
533 impl ::std::ops::Not for BCRYPT_DSA_MAGIC {
534     type Output = Self;
not(self) -> Self535     fn not(self) -> Self {
536         Self(self.0.not())
537     }
538 }
539 pub const BCRYPT_DSA_PARAMETERS_MAGIC: u32 = 1297109828u32;
540 pub const BCRYPT_DSA_PARAMETERS_MAGIC_V2: u32 = 843927620u32;
541 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
542 #[repr(C)]
543 pub struct BCRYPT_DSA_PARAMETER_HEADER {
544     pub cbLength: u32,
545     pub dwMagic: u32,
546     pub cbKeyLength: u32,
547     pub Count: [u8; 4],
548     pub Seed: [u8; 20],
549     pub q: [u8; 20],
550 }
551 impl BCRYPT_DSA_PARAMETER_HEADER {}
552 impl ::std::default::Default for BCRYPT_DSA_PARAMETER_HEADER {
default() -> Self553     fn default() -> Self {
554         unsafe { ::std::mem::zeroed() }
555     }
556 }
557 impl ::std::fmt::Debug for BCRYPT_DSA_PARAMETER_HEADER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result558     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
559         fmt.debug_struct("BCRYPT_DSA_PARAMETER_HEADER").field("cbLength", &self.cbLength).field("dwMagic", &self.dwMagic).field("cbKeyLength", &self.cbKeyLength).field("Count", &self.Count).field("Seed", &self.Seed).field("q", &self.q).finish()
560     }
561 }
562 impl ::std::cmp::PartialEq for BCRYPT_DSA_PARAMETER_HEADER {
eq(&self, other: &Self) -> bool563     fn eq(&self, other: &Self) -> bool {
564         self.cbLength == other.cbLength && self.dwMagic == other.dwMagic && self.cbKeyLength == other.cbKeyLength && self.Count == other.Count && self.Seed == other.Seed && self.q == other.q
565     }
566 }
567 impl ::std::cmp::Eq for BCRYPT_DSA_PARAMETER_HEADER {}
568 unsafe impl ::windows::runtime::Abi for BCRYPT_DSA_PARAMETER_HEADER {
569     type Abi = Self;
570     type DefaultType = Self;
571 }
572 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
573 #[repr(C)]
574 pub struct BCRYPT_DSA_PARAMETER_HEADER_V2 {
575     pub cbLength: u32,
576     pub dwMagic: u32,
577     pub cbKeyLength: u32,
578     pub hashAlgorithm: HASHALGORITHM_ENUM,
579     pub standardVersion: DSAFIPSVERSION_ENUM,
580     pub cbSeedLength: u32,
581     pub cbGroupSize: u32,
582     pub Count: [u8; 4],
583 }
584 impl BCRYPT_DSA_PARAMETER_HEADER_V2 {}
585 impl ::std::default::Default for BCRYPT_DSA_PARAMETER_HEADER_V2 {
default() -> Self586     fn default() -> Self {
587         unsafe { ::std::mem::zeroed() }
588     }
589 }
590 impl ::std::fmt::Debug for BCRYPT_DSA_PARAMETER_HEADER_V2 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result591     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
592         fmt.debug_struct("BCRYPT_DSA_PARAMETER_HEADER_V2")
593             .field("cbLength", &self.cbLength)
594             .field("dwMagic", &self.dwMagic)
595             .field("cbKeyLength", &self.cbKeyLength)
596             .field("hashAlgorithm", &self.hashAlgorithm)
597             .field("standardVersion", &self.standardVersion)
598             .field("cbSeedLength", &self.cbSeedLength)
599             .field("cbGroupSize", &self.cbGroupSize)
600             .field("Count", &self.Count)
601             .finish()
602     }
603 }
604 impl ::std::cmp::PartialEq for BCRYPT_DSA_PARAMETER_HEADER_V2 {
eq(&self, other: &Self) -> bool605     fn eq(&self, other: &Self) -> bool {
606         self.cbLength == other.cbLength && self.dwMagic == other.dwMagic && self.cbKeyLength == other.cbKeyLength && self.hashAlgorithm == other.hashAlgorithm && self.standardVersion == other.standardVersion && self.cbSeedLength == other.cbSeedLength && self.cbGroupSize == other.cbGroupSize && self.Count == other.Count
607     }
608 }
609 impl ::std::cmp::Eq for BCRYPT_DSA_PARAMETER_HEADER_V2 {}
610 unsafe impl ::windows::runtime::Abi for BCRYPT_DSA_PARAMETER_HEADER_V2 {
611     type Abi = Self;
612     type DefaultType = Self;
613 }
614 pub const BCRYPT_DSA_PRIVATE_MAGIC_V2: u32 = 844517444u32;
615 pub const BCRYPT_DSA_PUBLIC_MAGIC_V2: u32 = 843206724u32;
616 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
617 #[repr(C)]
618 pub struct BCRYPT_ECCFULLKEY_BLOB {
619     pub dwMagic: u32,
620     pub dwVersion: u32,
621     pub dwCurveType: ECC_CURVE_TYPE_ENUM,
622     pub dwCurveGenerationAlgId: ECC_CURVE_ALG_ID_ENUM,
623     pub cbFieldLength: u32,
624     pub cbSubgroupOrder: u32,
625     pub cbCofactor: u32,
626     pub cbSeed: u32,
627 }
628 impl BCRYPT_ECCFULLKEY_BLOB {}
629 impl ::std::default::Default for BCRYPT_ECCFULLKEY_BLOB {
default() -> Self630     fn default() -> Self {
631         unsafe { ::std::mem::zeroed() }
632     }
633 }
634 impl ::std::fmt::Debug for BCRYPT_ECCFULLKEY_BLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result635     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
636         fmt.debug_struct("BCRYPT_ECCFULLKEY_BLOB")
637             .field("dwMagic", &self.dwMagic)
638             .field("dwVersion", &self.dwVersion)
639             .field("dwCurveType", &self.dwCurveType)
640             .field("dwCurveGenerationAlgId", &self.dwCurveGenerationAlgId)
641             .field("cbFieldLength", &self.cbFieldLength)
642             .field("cbSubgroupOrder", &self.cbSubgroupOrder)
643             .field("cbCofactor", &self.cbCofactor)
644             .field("cbSeed", &self.cbSeed)
645             .finish()
646     }
647 }
648 impl ::std::cmp::PartialEq for BCRYPT_ECCFULLKEY_BLOB {
eq(&self, other: &Self) -> bool649     fn eq(&self, other: &Self) -> bool {
650         self.dwMagic == other.dwMagic && self.dwVersion == other.dwVersion && self.dwCurveType == other.dwCurveType && self.dwCurveGenerationAlgId == other.dwCurveGenerationAlgId && self.cbFieldLength == other.cbFieldLength && self.cbSubgroupOrder == other.cbSubgroupOrder && self.cbCofactor == other.cbCofactor && self.cbSeed == other.cbSeed
651     }
652 }
653 impl ::std::cmp::Eq for BCRYPT_ECCFULLKEY_BLOB {}
654 unsafe impl ::windows::runtime::Abi for BCRYPT_ECCFULLKEY_BLOB {
655     type Abi = Self;
656     type DefaultType = Self;
657 }
658 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
659 #[repr(C)]
660 pub struct BCRYPT_ECCKEY_BLOB {
661     pub dwMagic: u32,
662     pub cbKey: u32,
663 }
664 impl BCRYPT_ECCKEY_BLOB {}
665 impl ::std::default::Default for BCRYPT_ECCKEY_BLOB {
default() -> Self666     fn default() -> Self {
667         unsafe { ::std::mem::zeroed() }
668     }
669 }
670 impl ::std::fmt::Debug for BCRYPT_ECCKEY_BLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result671     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
672         fmt.debug_struct("BCRYPT_ECCKEY_BLOB").field("dwMagic", &self.dwMagic).field("cbKey", &self.cbKey).finish()
673     }
674 }
675 impl ::std::cmp::PartialEq for BCRYPT_ECCKEY_BLOB {
eq(&self, other: &Self) -> bool676     fn eq(&self, other: &Self) -> bool {
677         self.dwMagic == other.dwMagic && self.cbKey == other.cbKey
678     }
679 }
680 impl ::std::cmp::Eq for BCRYPT_ECCKEY_BLOB {}
681 unsafe impl ::windows::runtime::Abi for BCRYPT_ECCKEY_BLOB {
682     type Abi = Self;
683     type DefaultType = Self;
684 }
685 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
686 #[repr(C)]
687 #[cfg(feature = "Win32_Foundation")]
688 pub struct BCRYPT_ECC_CURVE_NAMES {
689     pub dwEccCurveNames: u32,
690     pub pEccCurveNames: *mut super::super::Foundation::PWSTR,
691 }
692 #[cfg(feature = "Win32_Foundation")]
693 impl BCRYPT_ECC_CURVE_NAMES {}
694 #[cfg(feature = "Win32_Foundation")]
695 impl ::std::default::Default for BCRYPT_ECC_CURVE_NAMES {
default() -> Self696     fn default() -> Self {
697         unsafe { ::std::mem::zeroed() }
698     }
699 }
700 #[cfg(feature = "Win32_Foundation")]
701 impl ::std::fmt::Debug for BCRYPT_ECC_CURVE_NAMES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result702     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
703         fmt.debug_struct("BCRYPT_ECC_CURVE_NAMES").field("dwEccCurveNames", &self.dwEccCurveNames).field("pEccCurveNames", &self.pEccCurveNames).finish()
704     }
705 }
706 #[cfg(feature = "Win32_Foundation")]
707 impl ::std::cmp::PartialEq for BCRYPT_ECC_CURVE_NAMES {
eq(&self, other: &Self) -> bool708     fn eq(&self, other: &Self) -> bool {
709         self.dwEccCurveNames == other.dwEccCurveNames && self.pEccCurveNames == other.pEccCurveNames
710     }
711 }
712 #[cfg(feature = "Win32_Foundation")]
713 impl ::std::cmp::Eq for BCRYPT_ECC_CURVE_NAMES {}
714 #[cfg(feature = "Win32_Foundation")]
715 unsafe impl ::windows::runtime::Abi for BCRYPT_ECC_CURVE_NAMES {
716     type Abi = Self;
717     type DefaultType = Self;
718 }
719 pub const BCRYPT_ECC_FULLKEY_BLOB_V1: u32 = 1u32;
720 pub const BCRYPT_ECC_PARAMETERS_MAGIC: u32 = 1346585413u32;
721 pub const BCRYPT_ECDH_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(657u32 as _);
722 pub const BCRYPT_ECDH_P256_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(673u32 as _);
723 pub const BCRYPT_ECDH_P384_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(689u32 as _);
724 pub const BCRYPT_ECDH_P521_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(705u32 as _);
725 pub const BCRYPT_ECDH_PRIVATE_GENERIC_MAGIC: u32 = 1447772997u32;
726 pub const BCRYPT_ECDH_PRIVATE_P256_MAGIC: u32 = 843793221u32;
727 pub const BCRYPT_ECDH_PRIVATE_P384_MAGIC: u32 = 877347653u32;
728 pub const BCRYPT_ECDH_PRIVATE_P521_MAGIC: u32 = 910902085u32;
729 pub const BCRYPT_ECDH_PUBLIC_GENERIC_MAGIC: u32 = 1347109701u32;
730 pub const BCRYPT_ECDH_PUBLIC_P256_MAGIC: u32 = 827016005u32;
731 pub const BCRYPT_ECDH_PUBLIC_P384_MAGIC: u32 = 860570437u32;
732 pub const BCRYPT_ECDH_PUBLIC_P521_MAGIC: u32 = 894124869u32;
733 pub const BCRYPT_ECDSA_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(241u32 as _);
734 pub const BCRYPT_ECDSA_P256_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(737u32 as _);
735 pub const BCRYPT_ECDSA_P384_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(753u32 as _);
736 pub const BCRYPT_ECDSA_P521_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(769u32 as _);
737 pub const BCRYPT_ECDSA_PRIVATE_GENERIC_MAGIC: u32 = 1447314245u32;
738 pub const BCRYPT_ECDSA_PRIVATE_P256_MAGIC: u32 = 844317509u32;
739 pub const BCRYPT_ECDSA_PRIVATE_P384_MAGIC: u32 = 877871941u32;
740 pub const BCRYPT_ECDSA_PRIVATE_P521_MAGIC: u32 = 911426373u32;
741 pub const BCRYPT_ECDSA_PUBLIC_GENERIC_MAGIC: u32 = 1346650949u32;
742 pub const BCRYPT_ECDSA_PUBLIC_P256_MAGIC: u32 = 827540293u32;
743 pub const BCRYPT_ECDSA_PUBLIC_P384_MAGIC: u32 = 861094725u32;
744 pub const BCRYPT_ECDSA_PUBLIC_P521_MAGIC: u32 = 894649157u32;
745 pub const BCRYPT_ENABLE_INCOMPATIBLE_FIPS_CHECKS: u32 = 256u32;
746 pub const BCRYPT_EXTENDED_KEYSIZE: u32 = 128u32;
747 pub const BCRYPT_GENERATE_IV: u32 = 32u32;
748 pub const BCRYPT_HASH_INTERFACE_MAJORVERSION_2: u32 = 2u32;
749 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
750 #[repr(transparent)]
751 pub struct BCRYPT_HASH_OPERATION_TYPE(pub i32);
752 pub const BCRYPT_HASH_OPERATION_HASH_DATA: BCRYPT_HASH_OPERATION_TYPE = BCRYPT_HASH_OPERATION_TYPE(1i32);
753 pub const BCRYPT_HASH_OPERATION_FINISH_HASH: BCRYPT_HASH_OPERATION_TYPE = BCRYPT_HASH_OPERATION_TYPE(2i32);
754 impl ::std::convert::From<i32> for BCRYPT_HASH_OPERATION_TYPE {
from(value: i32) -> Self755     fn from(value: i32) -> Self {
756         Self(value)
757     }
758 }
759 unsafe impl ::windows::runtime::Abi for BCRYPT_HASH_OPERATION_TYPE {
760     type Abi = Self;
761     type DefaultType = Self;
762 }
763 pub const BCRYPT_HKDF_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(913u32 as _);
764 pub const BCRYPT_HMAC_MD2_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(289u32 as _);
765 pub const BCRYPT_HMAC_MD4_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(305u32 as _);
766 pub const BCRYPT_HMAC_MD5_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(145u32 as _);
767 pub const BCRYPT_HMAC_SHA1_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(161u32 as _);
768 pub const BCRYPT_HMAC_SHA256_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(177u32 as _);
769 pub const BCRYPT_HMAC_SHA384_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(193u32 as _);
770 pub const BCRYPT_HMAC_SHA512_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(209u32 as _);
771 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
772 #[repr(transparent)]
773 pub struct BCRYPT_INTERFACE(pub u32);
774 pub const BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE: BCRYPT_INTERFACE = BCRYPT_INTERFACE(3u32);
775 pub const BCRYPT_CIPHER_INTERFACE: BCRYPT_INTERFACE = BCRYPT_INTERFACE(1u32);
776 pub const BCRYPT_HASH_INTERFACE: BCRYPT_INTERFACE = BCRYPT_INTERFACE(2u32);
777 pub const BCRYPT_RNG_INTERFACE: BCRYPT_INTERFACE = BCRYPT_INTERFACE(6u32);
778 pub const BCRYPT_SECRET_AGREEMENT_INTERFACE: BCRYPT_INTERFACE = BCRYPT_INTERFACE(4u32);
779 pub const BCRYPT_SIGNATURE_INTERFACE: BCRYPT_INTERFACE = BCRYPT_INTERFACE(5u32);
780 pub const NCRYPT_KEY_STORAGE_INTERFACE: BCRYPT_INTERFACE = BCRYPT_INTERFACE(65537u32);
781 pub const NCRYPT_SCHANNEL_INTERFACE: BCRYPT_INTERFACE = BCRYPT_INTERFACE(65538u32);
782 pub const NCRYPT_SCHANNEL_SIGNATURE_INTERFACE: BCRYPT_INTERFACE = BCRYPT_INTERFACE(65539u32);
783 impl ::std::convert::From<u32> for BCRYPT_INTERFACE {
from(value: u32) -> Self784     fn from(value: u32) -> Self {
785         Self(value)
786     }
787 }
788 unsafe impl ::windows::runtime::Abi for BCRYPT_INTERFACE {
789     type Abi = Self;
790     type DefaultType = Self;
791 }
792 impl ::std::ops::BitOr for BCRYPT_INTERFACE {
793     type Output = Self;
bitor(self, rhs: Self) -> Self794     fn bitor(self, rhs: Self) -> Self {
795         Self(self.0 | rhs.0)
796     }
797 }
798 impl ::std::ops::BitAnd for BCRYPT_INTERFACE {
799     type Output = Self;
bitand(self, rhs: Self) -> Self800     fn bitand(self, rhs: Self) -> Self {
801         Self(self.0 & rhs.0)
802     }
803 }
804 impl ::std::ops::BitOrAssign for BCRYPT_INTERFACE {
bitor_assign(&mut self, rhs: Self)805     fn bitor_assign(&mut self, rhs: Self) {
806         self.0.bitor_assign(rhs.0)
807     }
808 }
809 impl ::std::ops::BitAndAssign for BCRYPT_INTERFACE {
bitand_assign(&mut self, rhs: Self)810     fn bitand_assign(&mut self, rhs: Self) {
811         self.0.bitand_assign(rhs.0)
812     }
813 }
814 impl ::std::ops::Not for BCRYPT_INTERFACE {
815     type Output = Self;
not(self) -> Self816     fn not(self) -> Self {
817         Self(self.0.not())
818     }
819 }
820 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
821 #[repr(C)]
822 pub struct BCRYPT_INTERFACE_VERSION {
823     pub MajorVersion: u16,
824     pub MinorVersion: u16,
825 }
826 impl BCRYPT_INTERFACE_VERSION {}
827 impl ::std::default::Default for BCRYPT_INTERFACE_VERSION {
default() -> Self828     fn default() -> Self {
829         unsafe { ::std::mem::zeroed() }
830     }
831 }
832 impl ::std::fmt::Debug for BCRYPT_INTERFACE_VERSION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result833     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
834         fmt.debug_struct("BCRYPT_INTERFACE_VERSION").field("MajorVersion", &self.MajorVersion).field("MinorVersion", &self.MinorVersion).finish()
835     }
836 }
837 impl ::std::cmp::PartialEq for BCRYPT_INTERFACE_VERSION {
eq(&self, other: &Self) -> bool838     fn eq(&self, other: &Self) -> bool {
839         self.MajorVersion == other.MajorVersion && self.MinorVersion == other.MinorVersion
840     }
841 }
842 impl ::std::cmp::Eq for BCRYPT_INTERFACE_VERSION {}
843 unsafe impl ::windows::runtime::Abi for BCRYPT_INTERFACE_VERSION {
844     type Abi = Self;
845     type DefaultType = Self;
846 }
847 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
848 #[repr(C)]
849 pub struct BCRYPT_KEY_BLOB {
850     pub Magic: u32,
851 }
852 impl BCRYPT_KEY_BLOB {}
853 impl ::std::default::Default for BCRYPT_KEY_BLOB {
default() -> Self854     fn default() -> Self {
855         unsafe { ::std::mem::zeroed() }
856     }
857 }
858 impl ::std::fmt::Debug for BCRYPT_KEY_BLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result859     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
860         fmt.debug_struct("BCRYPT_KEY_BLOB").field("Magic", &self.Magic).finish()
861     }
862 }
863 impl ::std::cmp::PartialEq for BCRYPT_KEY_BLOB {
eq(&self, other: &Self) -> bool864     fn eq(&self, other: &Self) -> bool {
865         self.Magic == other.Magic
866     }
867 }
868 impl ::std::cmp::Eq for BCRYPT_KEY_BLOB {}
869 unsafe impl ::windows::runtime::Abi for BCRYPT_KEY_BLOB {
870     type Abi = Self;
871     type DefaultType = Self;
872 }
873 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
874 #[repr(C)]
875 pub struct BCRYPT_KEY_DATA_BLOB_HEADER {
876     pub dwMagic: u32,
877     pub dwVersion: u32,
878     pub cbKeyData: u32,
879 }
880 impl BCRYPT_KEY_DATA_BLOB_HEADER {}
881 impl ::std::default::Default for BCRYPT_KEY_DATA_BLOB_HEADER {
default() -> Self882     fn default() -> Self {
883         unsafe { ::std::mem::zeroed() }
884     }
885 }
886 impl ::std::fmt::Debug for BCRYPT_KEY_DATA_BLOB_HEADER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result887     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
888         fmt.debug_struct("BCRYPT_KEY_DATA_BLOB_HEADER").field("dwMagic", &self.dwMagic).field("dwVersion", &self.dwVersion).field("cbKeyData", &self.cbKeyData).finish()
889     }
890 }
891 impl ::std::cmp::PartialEq for BCRYPT_KEY_DATA_BLOB_HEADER {
eq(&self, other: &Self) -> bool892     fn eq(&self, other: &Self) -> bool {
893         self.dwMagic == other.dwMagic && self.dwVersion == other.dwVersion && self.cbKeyData == other.cbKeyData
894     }
895 }
896 impl ::std::cmp::Eq for BCRYPT_KEY_DATA_BLOB_HEADER {}
897 unsafe impl ::windows::runtime::Abi for BCRYPT_KEY_DATA_BLOB_HEADER {
898     type Abi = Self;
899     type DefaultType = Self;
900 }
901 pub const BCRYPT_KEY_DATA_BLOB_MAGIC: u32 = 1296188491u32;
902 pub const BCRYPT_KEY_DATA_BLOB_VERSION1: u32 = 1u32;
903 pub const BCRYPT_KEY_DERIVATION_INTERFACE: u32 = 7u32;
904 pub const BCRYPT_KEY_DERIVATION_OPERATION: u32 = 64u32;
905 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
906 #[repr(transparent)]
907 pub struct BCRYPT_KEY_HANDLE(pub isize);
908 impl ::std::default::Default for BCRYPT_KEY_HANDLE {
default() -> Self909     fn default() -> Self {
910         unsafe { ::std::mem::zeroed() }
911     }
912 }
913 unsafe impl ::windows::runtime::Handle for BCRYPT_KEY_HANDLE {}
914 unsafe impl ::windows::runtime::Abi for BCRYPT_KEY_HANDLE {
915     type Abi = Self;
916     type DefaultType = Self;
917 }
918 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
919 #[repr(C)]
920 pub struct BCRYPT_KEY_LENGTHS_STRUCT {
921     pub dwMinLength: u32,
922     pub dwMaxLength: u32,
923     pub dwIncrement: u32,
924 }
925 impl BCRYPT_KEY_LENGTHS_STRUCT {}
926 impl ::std::default::Default for BCRYPT_KEY_LENGTHS_STRUCT {
default() -> Self927     fn default() -> Self {
928         unsafe { ::std::mem::zeroed() }
929     }
930 }
931 impl ::std::fmt::Debug for BCRYPT_KEY_LENGTHS_STRUCT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result932     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
933         fmt.debug_struct("BCRYPT_KEY_LENGTHS_STRUCT").field("dwMinLength", &self.dwMinLength).field("dwMaxLength", &self.dwMaxLength).field("dwIncrement", &self.dwIncrement).finish()
934     }
935 }
936 impl ::std::cmp::PartialEq for BCRYPT_KEY_LENGTHS_STRUCT {
eq(&self, other: &Self) -> bool937     fn eq(&self, other: &Self) -> bool {
938         self.dwMinLength == other.dwMinLength && self.dwMaxLength == other.dwMaxLength && self.dwIncrement == other.dwIncrement
939     }
940 }
941 impl ::std::cmp::Eq for BCRYPT_KEY_LENGTHS_STRUCT {}
942 unsafe impl ::windows::runtime::Abi for BCRYPT_KEY_LENGTHS_STRUCT {
943     type Abi = Self;
944     type DefaultType = Self;
945 }
946 pub const BCRYPT_KEY_VALIDATION_RANGE: u32 = 16u32;
947 pub const BCRYPT_KEY_VALIDATION_RANGE_AND_ORDER: u32 = 24u32;
948 pub const BCRYPT_KEY_VALIDATION_REGENERATE: u32 = 32u32;
949 pub const BCRYPT_MD2_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(1u32 as _);
950 pub const BCRYPT_MD4_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(17u32 as _);
951 pub const BCRYPT_MD5_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(33u32 as _);
952 pub const BCRYPT_MULTI_FLAG: u32 = 64u32;
953 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
954 #[repr(C)]
955 pub struct BCRYPT_MULTI_HASH_OPERATION {
956     pub iHash: u32,
957     pub hashOperation: BCRYPT_HASH_OPERATION_TYPE,
958     pub pbBuffer: *mut u8,
959     pub cbBuffer: u32,
960 }
961 impl BCRYPT_MULTI_HASH_OPERATION {}
962 impl ::std::default::Default for BCRYPT_MULTI_HASH_OPERATION {
default() -> Self963     fn default() -> Self {
964         unsafe { ::std::mem::zeroed() }
965     }
966 }
967 impl ::std::fmt::Debug for BCRYPT_MULTI_HASH_OPERATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result968     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
969         fmt.debug_struct("BCRYPT_MULTI_HASH_OPERATION").field("iHash", &self.iHash).field("hashOperation", &self.hashOperation).field("pbBuffer", &self.pbBuffer).field("cbBuffer", &self.cbBuffer).finish()
970     }
971 }
972 impl ::std::cmp::PartialEq for BCRYPT_MULTI_HASH_OPERATION {
eq(&self, other: &Self) -> bool973     fn eq(&self, other: &Self) -> bool {
974         self.iHash == other.iHash && self.hashOperation == other.hashOperation && self.pbBuffer == other.pbBuffer && self.cbBuffer == other.cbBuffer
975     }
976 }
977 impl ::std::cmp::Eq for BCRYPT_MULTI_HASH_OPERATION {}
978 unsafe impl ::windows::runtime::Abi for BCRYPT_MULTI_HASH_OPERATION {
979     type Abi = Self;
980     type DefaultType = Self;
981 }
982 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
983 #[repr(C)]
984 pub struct BCRYPT_MULTI_OBJECT_LENGTH_STRUCT {
985     pub cbPerObject: u32,
986     pub cbPerElement: u32,
987 }
988 impl BCRYPT_MULTI_OBJECT_LENGTH_STRUCT {}
989 impl ::std::default::Default for BCRYPT_MULTI_OBJECT_LENGTH_STRUCT {
default() -> Self990     fn default() -> Self {
991         unsafe { ::std::mem::zeroed() }
992     }
993 }
994 impl ::std::fmt::Debug for BCRYPT_MULTI_OBJECT_LENGTH_STRUCT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result995     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
996         fmt.debug_struct("BCRYPT_MULTI_OBJECT_LENGTH_STRUCT").field("cbPerObject", &self.cbPerObject).field("cbPerElement", &self.cbPerElement).finish()
997     }
998 }
999 impl ::std::cmp::PartialEq for BCRYPT_MULTI_OBJECT_LENGTH_STRUCT {
eq(&self, other: &Self) -> bool1000     fn eq(&self, other: &Self) -> bool {
1001         self.cbPerObject == other.cbPerObject && self.cbPerElement == other.cbPerElement
1002     }
1003 }
1004 impl ::std::cmp::Eq for BCRYPT_MULTI_OBJECT_LENGTH_STRUCT {}
1005 unsafe impl ::windows::runtime::Abi for BCRYPT_MULTI_OBJECT_LENGTH_STRUCT {
1006     type Abi = Self;
1007     type DefaultType = Self;
1008 }
1009 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1010 #[repr(transparent)]
1011 pub struct BCRYPT_MULTI_OPERATION_TYPE(pub i32);
1012 pub const BCRYPT_OPERATION_TYPE_HASH: BCRYPT_MULTI_OPERATION_TYPE = BCRYPT_MULTI_OPERATION_TYPE(1i32);
1013 impl ::std::convert::From<i32> for BCRYPT_MULTI_OPERATION_TYPE {
from(value: i32) -> Self1014     fn from(value: i32) -> Self {
1015         Self(value)
1016     }
1017 }
1018 unsafe impl ::windows::runtime::Abi for BCRYPT_MULTI_OPERATION_TYPE {
1019     type Abi = Self;
1020     type DefaultType = Self;
1021 }
1022 pub const BCRYPT_NO_KEY_VALIDATION: u32 = 8u32;
1023 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1024 #[repr(C)]
1025 #[cfg(feature = "Win32_Foundation")]
1026 pub struct BCRYPT_OAEP_PADDING_INFO {
1027     pub pszAlgId: super::super::Foundation::PWSTR,
1028     pub pbLabel: *mut u8,
1029     pub cbLabel: u32,
1030 }
1031 #[cfg(feature = "Win32_Foundation")]
1032 impl BCRYPT_OAEP_PADDING_INFO {}
1033 #[cfg(feature = "Win32_Foundation")]
1034 impl ::std::default::Default for BCRYPT_OAEP_PADDING_INFO {
default() -> Self1035     fn default() -> Self {
1036         unsafe { ::std::mem::zeroed() }
1037     }
1038 }
1039 #[cfg(feature = "Win32_Foundation")]
1040 impl ::std::fmt::Debug for BCRYPT_OAEP_PADDING_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1041     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1042         fmt.debug_struct("BCRYPT_OAEP_PADDING_INFO").field("pszAlgId", &self.pszAlgId).field("pbLabel", &self.pbLabel).field("cbLabel", &self.cbLabel).finish()
1043     }
1044 }
1045 #[cfg(feature = "Win32_Foundation")]
1046 impl ::std::cmp::PartialEq for BCRYPT_OAEP_PADDING_INFO {
eq(&self, other: &Self) -> bool1047     fn eq(&self, other: &Self) -> bool {
1048         self.pszAlgId == other.pszAlgId && self.pbLabel == other.pbLabel && self.cbLabel == other.cbLabel
1049     }
1050 }
1051 #[cfg(feature = "Win32_Foundation")]
1052 impl ::std::cmp::Eq for BCRYPT_OAEP_PADDING_INFO {}
1053 #[cfg(feature = "Win32_Foundation")]
1054 unsafe impl ::windows::runtime::Abi for BCRYPT_OAEP_PADDING_INFO {
1055     type Abi = Self;
1056     type DefaultType = Self;
1057 }
1058 pub const BCRYPT_OBJECT_ALIGNMENT: u32 = 16u32;
1059 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1060 #[repr(C)]
1061 pub struct BCRYPT_OID {
1062     pub cbOID: u32,
1063     pub pbOID: *mut u8,
1064 }
1065 impl BCRYPT_OID {}
1066 impl ::std::default::Default for BCRYPT_OID {
default() -> Self1067     fn default() -> Self {
1068         unsafe { ::std::mem::zeroed() }
1069     }
1070 }
1071 impl ::std::fmt::Debug for BCRYPT_OID {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1072     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1073         fmt.debug_struct("BCRYPT_OID").field("cbOID", &self.cbOID).field("pbOID", &self.pbOID).finish()
1074     }
1075 }
1076 impl ::std::cmp::PartialEq for BCRYPT_OID {
eq(&self, other: &Self) -> bool1077     fn eq(&self, other: &Self) -> bool {
1078         self.cbOID == other.cbOID && self.pbOID == other.pbOID
1079     }
1080 }
1081 impl ::std::cmp::Eq for BCRYPT_OID {}
1082 unsafe impl ::windows::runtime::Abi for BCRYPT_OID {
1083     type Abi = Self;
1084     type DefaultType = Self;
1085 }
1086 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1087 #[repr(C)]
1088 pub struct BCRYPT_OID_LIST {
1089     pub dwOIDCount: u32,
1090     pub pOIDs: *mut BCRYPT_OID,
1091 }
1092 impl BCRYPT_OID_LIST {}
1093 impl ::std::default::Default for BCRYPT_OID_LIST {
default() -> Self1094     fn default() -> Self {
1095         unsafe { ::std::mem::zeroed() }
1096     }
1097 }
1098 impl ::std::fmt::Debug for BCRYPT_OID_LIST {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1099     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1100         fmt.debug_struct("BCRYPT_OID_LIST").field("dwOIDCount", &self.dwOIDCount).field("pOIDs", &self.pOIDs).finish()
1101     }
1102 }
1103 impl ::std::cmp::PartialEq for BCRYPT_OID_LIST {
eq(&self, other: &Self) -> bool1104     fn eq(&self, other: &Self) -> bool {
1105         self.dwOIDCount == other.dwOIDCount && self.pOIDs == other.pOIDs
1106     }
1107 }
1108 impl ::std::cmp::Eq for BCRYPT_OID_LIST {}
1109 unsafe impl ::windows::runtime::Abi for BCRYPT_OID_LIST {
1110     type Abi = Self;
1111     type DefaultType = Self;
1112 }
1113 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1114 #[repr(transparent)]
1115 pub struct BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS(pub u32);
1116 pub const BCRYPT_ALG_HANDLE_HMAC_FLAG: BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS = BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS(8u32);
1117 pub const BCRYPT_PROV_DISPATCH: BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS = BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS(1u32);
1118 pub const BCRYPT_HASH_REUSABLE_FLAG: BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS = BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS(32u32);
1119 impl ::std::convert::From<u32> for BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS {
from(value: u32) -> Self1120     fn from(value: u32) -> Self {
1121         Self(value)
1122     }
1123 }
1124 unsafe impl ::windows::runtime::Abi for BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS {
1125     type Abi = Self;
1126     type DefaultType = Self;
1127 }
1128 impl ::std::ops::BitOr for BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS {
1129     type Output = Self;
bitor(self, rhs: Self) -> Self1130     fn bitor(self, rhs: Self) -> Self {
1131         Self(self.0 | rhs.0)
1132     }
1133 }
1134 impl ::std::ops::BitAnd for BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS {
1135     type Output = Self;
bitand(self, rhs: Self) -> Self1136     fn bitand(self, rhs: Self) -> Self {
1137         Self(self.0 & rhs.0)
1138     }
1139 }
1140 impl ::std::ops::BitOrAssign for BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS {
bitor_assign(&mut self, rhs: Self)1141     fn bitor_assign(&mut self, rhs: Self) {
1142         self.0.bitor_assign(rhs.0)
1143     }
1144 }
1145 impl ::std::ops::BitAndAssign for BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS {
bitand_assign(&mut self, rhs: Self)1146     fn bitand_assign(&mut self, rhs: Self) {
1147         self.0.bitand_assign(rhs.0)
1148     }
1149 }
1150 impl ::std::ops::Not for BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS {
1151     type Output = Self;
not(self) -> Self1152     fn not(self) -> Self {
1153         Self(self.0.not())
1154     }
1155 }
1156 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1157 #[repr(transparent)]
1158 pub struct BCRYPT_OPERATION(pub u32);
1159 pub const BCRYPT_CIPHER_OPERATION: BCRYPT_OPERATION = BCRYPT_OPERATION(1u32);
1160 pub const BCRYPT_HASH_OPERATION: BCRYPT_OPERATION = BCRYPT_OPERATION(2u32);
1161 pub const BCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION: BCRYPT_OPERATION = BCRYPT_OPERATION(4u32);
1162 pub const BCRYPT_SECRET_AGREEMENT_OPERATION: BCRYPT_OPERATION = BCRYPT_OPERATION(8u32);
1163 pub const BCRYPT_SIGNATURE_OPERATION: BCRYPT_OPERATION = BCRYPT_OPERATION(16u32);
1164 pub const BCRYPT_RNG_OPERATION: BCRYPT_OPERATION = BCRYPT_OPERATION(32u32);
1165 impl ::std::convert::From<u32> for BCRYPT_OPERATION {
from(value: u32) -> Self1166     fn from(value: u32) -> Self {
1167         Self(value)
1168     }
1169 }
1170 unsafe impl ::windows::runtime::Abi for BCRYPT_OPERATION {
1171     type Abi = Self;
1172     type DefaultType = Self;
1173 }
1174 impl ::std::ops::BitOr for BCRYPT_OPERATION {
1175     type Output = Self;
bitor(self, rhs: Self) -> Self1176     fn bitor(self, rhs: Self) -> Self {
1177         Self(self.0 | rhs.0)
1178     }
1179 }
1180 impl ::std::ops::BitAnd for BCRYPT_OPERATION {
1181     type Output = Self;
bitand(self, rhs: Self) -> Self1182     fn bitand(self, rhs: Self) -> Self {
1183         Self(self.0 & rhs.0)
1184     }
1185 }
1186 impl ::std::ops::BitOrAssign for BCRYPT_OPERATION {
bitor_assign(&mut self, rhs: Self)1187     fn bitor_assign(&mut self, rhs: Self) {
1188         self.0.bitor_assign(rhs.0)
1189     }
1190 }
1191 impl ::std::ops::BitAndAssign for BCRYPT_OPERATION {
bitand_assign(&mut self, rhs: Self)1192     fn bitand_assign(&mut self, rhs: Self) {
1193         self.0.bitand_assign(rhs.0)
1194     }
1195 }
1196 impl ::std::ops::Not for BCRYPT_OPERATION {
1197     type Output = Self;
not(self) -> Self1198     fn not(self) -> Self {
1199         Self(self.0.not())
1200     }
1201 }
1202 pub const BCRYPT_PAD_PKCS1_OPTIONAL_HASH_OID: u32 = 16u32;
1203 pub const BCRYPT_PBKDF2_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(817u32 as _);
1204 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1205 #[repr(C)]
1206 #[cfg(feature = "Win32_Foundation")]
1207 pub struct BCRYPT_PKCS1_PADDING_INFO {
1208     pub pszAlgId: super::super::Foundation::PWSTR,
1209 }
1210 #[cfg(feature = "Win32_Foundation")]
1211 impl BCRYPT_PKCS1_PADDING_INFO {}
1212 #[cfg(feature = "Win32_Foundation")]
1213 impl ::std::default::Default for BCRYPT_PKCS1_PADDING_INFO {
default() -> Self1214     fn default() -> Self {
1215         unsafe { ::std::mem::zeroed() }
1216     }
1217 }
1218 #[cfg(feature = "Win32_Foundation")]
1219 impl ::std::fmt::Debug for BCRYPT_PKCS1_PADDING_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1220     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1221         fmt.debug_struct("BCRYPT_PKCS1_PADDING_INFO").field("pszAlgId", &self.pszAlgId).finish()
1222     }
1223 }
1224 #[cfg(feature = "Win32_Foundation")]
1225 impl ::std::cmp::PartialEq for BCRYPT_PKCS1_PADDING_INFO {
eq(&self, other: &Self) -> bool1226     fn eq(&self, other: &Self) -> bool {
1227         self.pszAlgId == other.pszAlgId
1228     }
1229 }
1230 #[cfg(feature = "Win32_Foundation")]
1231 impl ::std::cmp::Eq for BCRYPT_PKCS1_PADDING_INFO {}
1232 #[cfg(feature = "Win32_Foundation")]
1233 unsafe impl ::windows::runtime::Abi for BCRYPT_PKCS1_PADDING_INFO {
1234     type Abi = Self;
1235     type DefaultType = Self;
1236 }
1237 pub const BCRYPT_PRIVATE_KEY_FLAG: u32 = 2u32;
1238 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1239 #[repr(C)]
1240 #[cfg(feature = "Win32_Foundation")]
1241 pub struct BCRYPT_PROVIDER_NAME {
1242     pub pszProviderName: super::super::Foundation::PWSTR,
1243 }
1244 #[cfg(feature = "Win32_Foundation")]
1245 impl BCRYPT_PROVIDER_NAME {}
1246 #[cfg(feature = "Win32_Foundation")]
1247 impl ::std::default::Default for BCRYPT_PROVIDER_NAME {
default() -> Self1248     fn default() -> Self {
1249         unsafe { ::std::mem::zeroed() }
1250     }
1251 }
1252 #[cfg(feature = "Win32_Foundation")]
1253 impl ::std::fmt::Debug for BCRYPT_PROVIDER_NAME {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1254     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1255         fmt.debug_struct("BCRYPT_PROVIDER_NAME").field("pszProviderName", &self.pszProviderName).finish()
1256     }
1257 }
1258 #[cfg(feature = "Win32_Foundation")]
1259 impl ::std::cmp::PartialEq for BCRYPT_PROVIDER_NAME {
eq(&self, other: &Self) -> bool1260     fn eq(&self, other: &Self) -> bool {
1261         self.pszProviderName == other.pszProviderName
1262     }
1263 }
1264 #[cfg(feature = "Win32_Foundation")]
1265 impl ::std::cmp::Eq for BCRYPT_PROVIDER_NAME {}
1266 #[cfg(feature = "Win32_Foundation")]
1267 unsafe impl ::windows::runtime::Abi for BCRYPT_PROVIDER_NAME {
1268     type Abi = Self;
1269     type DefaultType = Self;
1270 }
1271 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1272 #[repr(C)]
1273 #[cfg(feature = "Win32_Foundation")]
1274 pub struct BCRYPT_PSS_PADDING_INFO {
1275     pub pszAlgId: super::super::Foundation::PWSTR,
1276     pub cbSalt: u32,
1277 }
1278 #[cfg(feature = "Win32_Foundation")]
1279 impl BCRYPT_PSS_PADDING_INFO {}
1280 #[cfg(feature = "Win32_Foundation")]
1281 impl ::std::default::Default for BCRYPT_PSS_PADDING_INFO {
default() -> Self1282     fn default() -> Self {
1283         unsafe { ::std::mem::zeroed() }
1284     }
1285 }
1286 #[cfg(feature = "Win32_Foundation")]
1287 impl ::std::fmt::Debug for BCRYPT_PSS_PADDING_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1288     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1289         fmt.debug_struct("BCRYPT_PSS_PADDING_INFO").field("pszAlgId", &self.pszAlgId).field("cbSalt", &self.cbSalt).finish()
1290     }
1291 }
1292 #[cfg(feature = "Win32_Foundation")]
1293 impl ::std::cmp::PartialEq for BCRYPT_PSS_PADDING_INFO {
eq(&self, other: &Self) -> bool1294     fn eq(&self, other: &Self) -> bool {
1295         self.pszAlgId == other.pszAlgId && self.cbSalt == other.cbSalt
1296     }
1297 }
1298 #[cfg(feature = "Win32_Foundation")]
1299 impl ::std::cmp::Eq for BCRYPT_PSS_PADDING_INFO {}
1300 #[cfg(feature = "Win32_Foundation")]
1301 unsafe impl ::windows::runtime::Abi for BCRYPT_PSS_PADDING_INFO {
1302     type Abi = Self;
1303     type DefaultType = Self;
1304 }
1305 pub const BCRYPT_PUBLIC_KEY_FLAG: u32 = 1u32;
1306 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1307 #[repr(transparent)]
1308 pub struct BCRYPT_QUERY_PROVIDER_MODE(pub u32);
1309 pub const CRYPT_ANY: BCRYPT_QUERY_PROVIDER_MODE = BCRYPT_QUERY_PROVIDER_MODE(4u32);
1310 pub const CRYPT_UM: BCRYPT_QUERY_PROVIDER_MODE = BCRYPT_QUERY_PROVIDER_MODE(1u32);
1311 pub const CRYPT_KM: BCRYPT_QUERY_PROVIDER_MODE = BCRYPT_QUERY_PROVIDER_MODE(2u32);
1312 pub const CRYPT_MM: BCRYPT_QUERY_PROVIDER_MODE = BCRYPT_QUERY_PROVIDER_MODE(3u32);
1313 impl ::std::convert::From<u32> for BCRYPT_QUERY_PROVIDER_MODE {
from(value: u32) -> Self1314     fn from(value: u32) -> Self {
1315         Self(value)
1316     }
1317 }
1318 unsafe impl ::windows::runtime::Abi for BCRYPT_QUERY_PROVIDER_MODE {
1319     type Abi = Self;
1320     type DefaultType = Self;
1321 }
1322 impl ::std::ops::BitOr for BCRYPT_QUERY_PROVIDER_MODE {
1323     type Output = Self;
bitor(self, rhs: Self) -> Self1324     fn bitor(self, rhs: Self) -> Self {
1325         Self(self.0 | rhs.0)
1326     }
1327 }
1328 impl ::std::ops::BitAnd for BCRYPT_QUERY_PROVIDER_MODE {
1329     type Output = Self;
bitand(self, rhs: Self) -> Self1330     fn bitand(self, rhs: Self) -> Self {
1331         Self(self.0 & rhs.0)
1332     }
1333 }
1334 impl ::std::ops::BitOrAssign for BCRYPT_QUERY_PROVIDER_MODE {
bitor_assign(&mut self, rhs: Self)1335     fn bitor_assign(&mut self, rhs: Self) {
1336         self.0.bitor_assign(rhs.0)
1337     }
1338 }
1339 impl ::std::ops::BitAndAssign for BCRYPT_QUERY_PROVIDER_MODE {
bitand_assign(&mut self, rhs: Self)1340     fn bitand_assign(&mut self, rhs: Self) {
1341         self.0.bitand_assign(rhs.0)
1342     }
1343 }
1344 impl ::std::ops::Not for BCRYPT_QUERY_PROVIDER_MODE {
1345     type Output = Self;
not(self) -> Self1346     fn not(self) -> Self {
1347         Self(self.0.not())
1348     }
1349 }
1350 pub const BCRYPT_RC2_CBC_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(593u32 as _);
1351 pub const BCRYPT_RC2_CFB_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(625u32 as _);
1352 pub const BCRYPT_RC2_ECB_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(609u32 as _);
1353 pub const BCRYPT_RC4_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(113u32 as _);
1354 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1355 #[repr(transparent)]
1356 pub struct BCRYPT_RESOLVE_PROVIDERS_FLAGS(pub u32);
1357 pub const CRYPT_ALL_FUNCTIONS: BCRYPT_RESOLVE_PROVIDERS_FLAGS = BCRYPT_RESOLVE_PROVIDERS_FLAGS(1u32);
1358 pub const CRYPT_ALL_PROVIDERS: BCRYPT_RESOLVE_PROVIDERS_FLAGS = BCRYPT_RESOLVE_PROVIDERS_FLAGS(2u32);
1359 impl ::std::convert::From<u32> for BCRYPT_RESOLVE_PROVIDERS_FLAGS {
from(value: u32) -> Self1360     fn from(value: u32) -> Self {
1361         Self(value)
1362     }
1363 }
1364 unsafe impl ::windows::runtime::Abi for BCRYPT_RESOLVE_PROVIDERS_FLAGS {
1365     type Abi = Self;
1366     type DefaultType = Self;
1367 }
1368 impl ::std::ops::BitOr for BCRYPT_RESOLVE_PROVIDERS_FLAGS {
1369     type Output = Self;
bitor(self, rhs: Self) -> Self1370     fn bitor(self, rhs: Self) -> Self {
1371         Self(self.0 | rhs.0)
1372     }
1373 }
1374 impl ::std::ops::BitAnd for BCRYPT_RESOLVE_PROVIDERS_FLAGS {
1375     type Output = Self;
bitand(self, rhs: Self) -> Self1376     fn bitand(self, rhs: Self) -> Self {
1377         Self(self.0 & rhs.0)
1378     }
1379 }
1380 impl ::std::ops::BitOrAssign for BCRYPT_RESOLVE_PROVIDERS_FLAGS {
bitor_assign(&mut self, rhs: Self)1381     fn bitor_assign(&mut self, rhs: Self) {
1382         self.0.bitor_assign(rhs.0)
1383     }
1384 }
1385 impl ::std::ops::BitAndAssign for BCRYPT_RESOLVE_PROVIDERS_FLAGS {
bitand_assign(&mut self, rhs: Self)1386     fn bitand_assign(&mut self, rhs: Self) {
1387         self.0.bitand_assign(rhs.0)
1388     }
1389 }
1390 impl ::std::ops::Not for BCRYPT_RESOLVE_PROVIDERS_FLAGS {
1391     type Output = Self;
not(self) -> Self1392     fn not(self) -> Self {
1393         Self(self.0.not())
1394     }
1395 }
1396 pub const BCRYPT_RNG_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(129u32 as _);
1397 pub const BCRYPT_RNG_USE_ENTROPY_IN_BUFFER: u32 = 1u32;
1398 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1399 #[repr(C)]
1400 pub struct BCRYPT_RSAKEY_BLOB {
1401     pub Magic: BCRYPT_RSAKEY_BLOB_MAGIC,
1402     pub BitLength: u32,
1403     pub cbPublicExp: u32,
1404     pub cbModulus: u32,
1405     pub cbPrime1: u32,
1406     pub cbPrime2: u32,
1407 }
1408 impl BCRYPT_RSAKEY_BLOB {}
1409 impl ::std::default::Default for BCRYPT_RSAKEY_BLOB {
default() -> Self1410     fn default() -> Self {
1411         unsafe { ::std::mem::zeroed() }
1412     }
1413 }
1414 impl ::std::fmt::Debug for BCRYPT_RSAKEY_BLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1415     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1416         fmt.debug_struct("BCRYPT_RSAKEY_BLOB").field("Magic", &self.Magic).field("BitLength", &self.BitLength).field("cbPublicExp", &self.cbPublicExp).field("cbModulus", &self.cbModulus).field("cbPrime1", &self.cbPrime1).field("cbPrime2", &self.cbPrime2).finish()
1417     }
1418 }
1419 impl ::std::cmp::PartialEq for BCRYPT_RSAKEY_BLOB {
eq(&self, other: &Self) -> bool1420     fn eq(&self, other: &Self) -> bool {
1421         self.Magic == other.Magic && self.BitLength == other.BitLength && self.cbPublicExp == other.cbPublicExp && self.cbModulus == other.cbModulus && self.cbPrime1 == other.cbPrime1 && self.cbPrime2 == other.cbPrime2
1422     }
1423 }
1424 impl ::std::cmp::Eq for BCRYPT_RSAKEY_BLOB {}
1425 unsafe impl ::windows::runtime::Abi for BCRYPT_RSAKEY_BLOB {
1426     type Abi = Self;
1427     type DefaultType = Self;
1428 }
1429 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1430 #[repr(transparent)]
1431 pub struct BCRYPT_RSAKEY_BLOB_MAGIC(pub u32);
1432 pub const BCRYPT_RSAPUBLIC_MAGIC: BCRYPT_RSAKEY_BLOB_MAGIC = BCRYPT_RSAKEY_BLOB_MAGIC(826364754u32);
1433 pub const BCRYPT_RSAPRIVATE_MAGIC: BCRYPT_RSAKEY_BLOB_MAGIC = BCRYPT_RSAKEY_BLOB_MAGIC(843141970u32);
1434 pub const BCRYPT_RSAFULLPRIVATE_MAGIC: BCRYPT_RSAKEY_BLOB_MAGIC = BCRYPT_RSAKEY_BLOB_MAGIC(859919186u32);
1435 impl ::std::convert::From<u32> for BCRYPT_RSAKEY_BLOB_MAGIC {
from(value: u32) -> Self1436     fn from(value: u32) -> Self {
1437         Self(value)
1438     }
1439 }
1440 unsafe impl ::windows::runtime::Abi for BCRYPT_RSAKEY_BLOB_MAGIC {
1441     type Abi = Self;
1442     type DefaultType = Self;
1443 }
1444 impl ::std::ops::BitOr for BCRYPT_RSAKEY_BLOB_MAGIC {
1445     type Output = Self;
bitor(self, rhs: Self) -> Self1446     fn bitor(self, rhs: Self) -> Self {
1447         Self(self.0 | rhs.0)
1448     }
1449 }
1450 impl ::std::ops::BitAnd for BCRYPT_RSAKEY_BLOB_MAGIC {
1451     type Output = Self;
bitand(self, rhs: Self) -> Self1452     fn bitand(self, rhs: Self) -> Self {
1453         Self(self.0 & rhs.0)
1454     }
1455 }
1456 impl ::std::ops::BitOrAssign for BCRYPT_RSAKEY_BLOB_MAGIC {
bitor_assign(&mut self, rhs: Self)1457     fn bitor_assign(&mut self, rhs: Self) {
1458         self.0.bitor_assign(rhs.0)
1459     }
1460 }
1461 impl ::std::ops::BitAndAssign for BCRYPT_RSAKEY_BLOB_MAGIC {
bitand_assign(&mut self, rhs: Self)1462     fn bitand_assign(&mut self, rhs: Self) {
1463         self.0.bitand_assign(rhs.0)
1464     }
1465 }
1466 impl ::std::ops::Not for BCRYPT_RSAKEY_BLOB_MAGIC {
1467     type Output = Self;
not(self) -> Self1468     fn not(self) -> Self {
1469         Self(self.0.not())
1470     }
1471 }
1472 pub const BCRYPT_RSA_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(225u32 as _);
1473 pub const BCRYPT_RSA_SIGN_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(785u32 as _);
1474 pub const BCRYPT_SHA1_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(49u32 as _);
1475 pub const BCRYPT_SHA256_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(65u32 as _);
1476 pub const BCRYPT_SHA384_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(81u32 as _);
1477 pub const BCRYPT_SHA512_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(97u32 as _);
1478 pub const BCRYPT_SP800108_CTR_HMAC_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(833u32 as _);
1479 pub const BCRYPT_SP80056A_CONCAT_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(849u32 as _);
1480 pub const BCRYPT_SUPPORTED_PAD_OAEP: u32 = 8u32;
1481 pub const BCRYPT_SUPPORTED_PAD_PKCS1_ENC: u32 = 2u32;
1482 pub const BCRYPT_SUPPORTED_PAD_PKCS1_SIG: u32 = 4u32;
1483 pub const BCRYPT_SUPPORTED_PAD_PSS: u32 = 16u32;
1484 pub const BCRYPT_SUPPORTED_PAD_ROUTER: u32 = 1u32;
1485 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1486 #[repr(transparent)]
1487 pub struct BCRYPT_TABLE(pub u32);
1488 pub const CRYPT_LOCAL: BCRYPT_TABLE = BCRYPT_TABLE(1u32);
1489 pub const CRYPT_DOMAIN: BCRYPT_TABLE = BCRYPT_TABLE(2u32);
1490 impl ::std::convert::From<u32> for BCRYPT_TABLE {
from(value: u32) -> Self1491     fn from(value: u32) -> Self {
1492         Self(value)
1493     }
1494 }
1495 unsafe impl ::windows::runtime::Abi for BCRYPT_TABLE {
1496     type Abi = Self;
1497     type DefaultType = Self;
1498 }
1499 impl ::std::ops::BitOr for BCRYPT_TABLE {
1500     type Output = Self;
bitor(self, rhs: Self) -> Self1501     fn bitor(self, rhs: Self) -> Self {
1502         Self(self.0 | rhs.0)
1503     }
1504 }
1505 impl ::std::ops::BitAnd for BCRYPT_TABLE {
1506     type Output = Self;
bitand(self, rhs: Self) -> Self1507     fn bitand(self, rhs: Self) -> Self {
1508         Self(self.0 & rhs.0)
1509     }
1510 }
1511 impl ::std::ops::BitOrAssign for BCRYPT_TABLE {
bitor_assign(&mut self, rhs: Self)1512     fn bitor_assign(&mut self, rhs: Self) {
1513         self.0.bitor_assign(rhs.0)
1514     }
1515 }
1516 impl ::std::ops::BitAndAssign for BCRYPT_TABLE {
bitand_assign(&mut self, rhs: Self)1517     fn bitand_assign(&mut self, rhs: Self) {
1518         self.0.bitand_assign(rhs.0)
1519     }
1520 }
1521 impl ::std::ops::Not for BCRYPT_TABLE {
1522     type Output = Self;
not(self) -> Self1523     fn not(self) -> Self {
1524         Self(self.0.not())
1525     }
1526 }
1527 pub const BCRYPT_TLS1_1_KDF_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(865u32 as _);
1528 pub const BCRYPT_TLS1_2_KDF_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(881u32 as _);
1529 pub const BCRYPT_TLS_CBC_HMAC_VERIFY_FLAG: u32 = 4u32;
1530 pub const BCRYPT_USE_SYSTEM_PREFERRED_RNG: u32 = 2u32;
1531 pub const BCRYPT_XTS_AES_ALG_HANDLE: BCRYPT_ALG_HANDLE = BCRYPT_ALG_HANDLE(897u32 as _);
1532 #[cfg(feature = "Win32_Foundation")]
1533 #[inline]
BCryptAddContextFunction<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, dwinterface: BCRYPT_INTERFACE, pszfunction: Param3, dwposition: u32) -> ::windows::runtime::Result<()>1534 pub unsafe fn BCryptAddContextFunction<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, dwinterface: BCRYPT_INTERFACE, pszfunction: Param3, dwposition: u32) -> ::windows::runtime::Result<()> {
1535     #[cfg(windows)]
1536     {
1537         #[link(name = "windows")]
1538         extern "system" {
1539             fn BCryptAddContextFunction(dwtable: BCRYPT_TABLE, pszcontext: super::super::Foundation::PWSTR, dwinterface: BCRYPT_INTERFACE, pszfunction: super::super::Foundation::PWSTR, dwposition: u32) -> super::super::Foundation::NTSTATUS;
1540         }
1541         BCryptAddContextFunction(::std::mem::transmute(dwtable), pszcontext.into_param().abi(), ::std::mem::transmute(dwinterface), pszfunction.into_param().abi(), ::std::mem::transmute(dwposition)).ok()
1542     }
1543     #[cfg(not(windows))]
1544     unimplemented!("Unsupported target OS");
1545 }
1546 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1547 #[repr(C)]
1548 pub struct BCryptBuffer {
1549     pub cbBuffer: u32,
1550     pub BufferType: u32,
1551     pub pvBuffer: *mut ::std::ffi::c_void,
1552 }
1553 impl BCryptBuffer {}
1554 impl ::std::default::Default for BCryptBuffer {
default() -> Self1555     fn default() -> Self {
1556         unsafe { ::std::mem::zeroed() }
1557     }
1558 }
1559 impl ::std::fmt::Debug for BCryptBuffer {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1560     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1561         fmt.debug_struct("BCryptBuffer").field("cbBuffer", &self.cbBuffer).field("BufferType", &self.BufferType).field("pvBuffer", &self.pvBuffer).finish()
1562     }
1563 }
1564 impl ::std::cmp::PartialEq for BCryptBuffer {
eq(&self, other: &Self) -> bool1565     fn eq(&self, other: &Self) -> bool {
1566         self.cbBuffer == other.cbBuffer && self.BufferType == other.BufferType && self.pvBuffer == other.pvBuffer
1567     }
1568 }
1569 impl ::std::cmp::Eq for BCryptBuffer {}
1570 unsafe impl ::windows::runtime::Abi for BCryptBuffer {
1571     type Abi = Self;
1572     type DefaultType = Self;
1573 }
1574 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1575 #[repr(C)]
1576 pub struct BCryptBufferDesc {
1577     pub ulVersion: u32,
1578     pub cBuffers: u32,
1579     pub pBuffers: *mut BCryptBuffer,
1580 }
1581 impl BCryptBufferDesc {}
1582 impl ::std::default::Default for BCryptBufferDesc {
default() -> Self1583     fn default() -> Self {
1584         unsafe { ::std::mem::zeroed() }
1585     }
1586 }
1587 impl ::std::fmt::Debug for BCryptBufferDesc {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1588     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1589         fmt.debug_struct("BCryptBufferDesc").field("ulVersion", &self.ulVersion).field("cBuffers", &self.cBuffers).field("pBuffers", &self.pBuffers).finish()
1590     }
1591 }
1592 impl ::std::cmp::PartialEq for BCryptBufferDesc {
eq(&self, other: &Self) -> bool1593     fn eq(&self, other: &Self) -> bool {
1594         self.ulVersion == other.ulVersion && self.cBuffers == other.cBuffers && self.pBuffers == other.pBuffers
1595     }
1596 }
1597 impl ::std::cmp::Eq for BCryptBufferDesc {}
1598 unsafe impl ::windows::runtime::Abi for BCryptBufferDesc {
1599     type Abi = Self;
1600     type DefaultType = Self;
1601 }
1602 #[cfg(feature = "Win32_Foundation")]
1603 #[inline]
BCryptCloseAlgorithmProvider<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>>(halgorithm: Param0, dwflags: u32) -> ::windows::runtime::Result<()>1604 pub unsafe fn BCryptCloseAlgorithmProvider<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>>(halgorithm: Param0, dwflags: u32) -> ::windows::runtime::Result<()> {
1605     #[cfg(windows)]
1606     {
1607         #[link(name = "windows")]
1608         extern "system" {
1609             fn BCryptCloseAlgorithmProvider(halgorithm: BCRYPT_ALG_HANDLE, dwflags: u32) -> super::super::Foundation::NTSTATUS;
1610         }
1611         BCryptCloseAlgorithmProvider(halgorithm.into_param().abi(), ::std::mem::transmute(dwflags)).ok()
1612     }
1613     #[cfg(not(windows))]
1614     unimplemented!("Unsupported target OS");
1615 }
1616 #[cfg(feature = "Win32_Foundation")]
1617 #[inline]
BCryptConfigureContext<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, pconfig: *const CRYPT_CONTEXT_CONFIG) -> ::windows::runtime::Result<()>1618 pub unsafe fn BCryptConfigureContext<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, pconfig: *const CRYPT_CONTEXT_CONFIG) -> ::windows::runtime::Result<()> {
1619     #[cfg(windows)]
1620     {
1621         #[link(name = "windows")]
1622         extern "system" {
1623             fn BCryptConfigureContext(dwtable: BCRYPT_TABLE, pszcontext: super::super::Foundation::PWSTR, pconfig: *const CRYPT_CONTEXT_CONFIG) -> super::super::Foundation::NTSTATUS;
1624         }
1625         BCryptConfigureContext(::std::mem::transmute(dwtable), pszcontext.into_param().abi(), ::std::mem::transmute(pconfig)).ok()
1626     }
1627     #[cfg(not(windows))]
1628     unimplemented!("Unsupported target OS");
1629 }
1630 #[cfg(feature = "Win32_Foundation")]
1631 #[inline]
BCryptConfigureContextFunction<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, dwinterface: BCRYPT_INTERFACE, pszfunction: Param3, pconfig: *const CRYPT_CONTEXT_FUNCTION_CONFIG) -> ::windows::runtime::Result<()>1632 pub unsafe fn BCryptConfigureContextFunction<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, dwinterface: BCRYPT_INTERFACE, pszfunction: Param3, pconfig: *const CRYPT_CONTEXT_FUNCTION_CONFIG) -> ::windows::runtime::Result<()> {
1633     #[cfg(windows)]
1634     {
1635         #[link(name = "windows")]
1636         extern "system" {
1637             fn BCryptConfigureContextFunction(dwtable: BCRYPT_TABLE, pszcontext: super::super::Foundation::PWSTR, dwinterface: BCRYPT_INTERFACE, pszfunction: super::super::Foundation::PWSTR, pconfig: *const CRYPT_CONTEXT_FUNCTION_CONFIG) -> super::super::Foundation::NTSTATUS;
1638         }
1639         BCryptConfigureContextFunction(::std::mem::transmute(dwtable), pszcontext.into_param().abi(), ::std::mem::transmute(dwinterface), pszfunction.into_param().abi(), ::std::mem::transmute(pconfig)).ok()
1640     }
1641     #[cfg(not(windows))]
1642     unimplemented!("Unsupported target OS");
1643 }
1644 #[cfg(feature = "Win32_Foundation")]
1645 #[inline]
BCryptCreateContext<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, pconfig: *const CRYPT_CONTEXT_CONFIG) -> ::windows::runtime::Result<()>1646 pub unsafe fn BCryptCreateContext<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, pconfig: *const CRYPT_CONTEXT_CONFIG) -> ::windows::runtime::Result<()> {
1647     #[cfg(windows)]
1648     {
1649         #[link(name = "windows")]
1650         extern "system" {
1651             fn BCryptCreateContext(dwtable: BCRYPT_TABLE, pszcontext: super::super::Foundation::PWSTR, pconfig: *const CRYPT_CONTEXT_CONFIG) -> super::super::Foundation::NTSTATUS;
1652         }
1653         BCryptCreateContext(::std::mem::transmute(dwtable), pszcontext.into_param().abi(), ::std::mem::transmute(pconfig)).ok()
1654     }
1655     #[cfg(not(windows))]
1656     unimplemented!("Unsupported target OS");
1657 }
1658 #[cfg(feature = "Win32_Foundation")]
1659 #[inline]
BCryptCreateHash<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>>(halgorithm: Param0, phhash: *mut *mut ::std::ffi::c_void, pbhashobject: *mut u8, cbhashobject: u32, pbsecret: *const u8, cbsecret: u32, dwflags: u32) -> ::windows::runtime::Result<()>1660 pub unsafe fn BCryptCreateHash<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>>(halgorithm: Param0, phhash: *mut *mut ::std::ffi::c_void, pbhashobject: *mut u8, cbhashobject: u32, pbsecret: *const u8, cbsecret: u32, dwflags: u32) -> ::windows::runtime::Result<()> {
1661     #[cfg(windows)]
1662     {
1663         #[link(name = "windows")]
1664         extern "system" {
1665             fn BCryptCreateHash(halgorithm: BCRYPT_ALG_HANDLE, phhash: *mut *mut ::std::ffi::c_void, pbhashobject: *mut u8, cbhashobject: u32, pbsecret: *const u8, cbsecret: u32, dwflags: u32) -> super::super::Foundation::NTSTATUS;
1666         }
1667         BCryptCreateHash(halgorithm.into_param().abi(), ::std::mem::transmute(phhash), ::std::mem::transmute(pbhashobject), ::std::mem::transmute(cbhashobject), ::std::mem::transmute(pbsecret), ::std::mem::transmute(cbsecret), ::std::mem::transmute(dwflags)).ok()
1668     }
1669     #[cfg(not(windows))]
1670     unimplemented!("Unsupported target OS");
1671 }
1672 #[cfg(feature = "Win32_Foundation")]
1673 #[inline]
BCryptCreateMultiHash<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>>(halgorithm: Param0, phhash: *mut *mut ::std::ffi::c_void, nhashes: u32, pbhashobject: *mut u8, cbhashobject: u32, pbsecret: *const u8, cbsecret: u32, dwflags: u32) -> ::windows::runtime::Result<()>1674 pub unsafe fn BCryptCreateMultiHash<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>>(halgorithm: Param0, phhash: *mut *mut ::std::ffi::c_void, nhashes: u32, pbhashobject: *mut u8, cbhashobject: u32, pbsecret: *const u8, cbsecret: u32, dwflags: u32) -> ::windows::runtime::Result<()> {
1675     #[cfg(windows)]
1676     {
1677         #[link(name = "windows")]
1678         extern "system" {
1679             fn BCryptCreateMultiHash(halgorithm: BCRYPT_ALG_HANDLE, phhash: *mut *mut ::std::ffi::c_void, nhashes: u32, pbhashobject: *mut u8, cbhashobject: u32, pbsecret: *const u8, cbsecret: u32, dwflags: u32) -> super::super::Foundation::NTSTATUS;
1680         }
1681         BCryptCreateMultiHash(halgorithm.into_param().abi(), ::std::mem::transmute(phhash), ::std::mem::transmute(nhashes), ::std::mem::transmute(pbhashobject), ::std::mem::transmute(cbhashobject), ::std::mem::transmute(pbsecret), ::std::mem::transmute(cbsecret), ::std::mem::transmute(dwflags)).ok()
1682     }
1683     #[cfg(not(windows))]
1684     unimplemented!("Unsupported target OS");
1685 }
1686 #[cfg(feature = "Win32_Foundation")]
1687 #[inline]
BCryptDecrypt<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hkey: Param0, pbinput: *const u8, cbinput: u32, ppaddinginfo: *const ::std::ffi::c_void, pbiv: *mut u8, cbiv: u32, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> ::windows::runtime::Result<()>1688 pub unsafe fn BCryptDecrypt<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hkey: Param0, pbinput: *const u8, cbinput: u32, ppaddinginfo: *const ::std::ffi::c_void, pbiv: *mut u8, cbiv: u32, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> ::windows::runtime::Result<()> {
1689     #[cfg(windows)]
1690     {
1691         #[link(name = "windows")]
1692         extern "system" {
1693             fn BCryptDecrypt(hkey: BCRYPT_KEY_HANDLE, pbinput: *const u8, cbinput: u32, ppaddinginfo: *const ::std::ffi::c_void, pbiv: *mut u8, cbiv: u32, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> super::super::Foundation::NTSTATUS;
1694         }
1695         BCryptDecrypt(
1696             hkey.into_param().abi(),
1697             ::std::mem::transmute(pbinput),
1698             ::std::mem::transmute(cbinput),
1699             ::std::mem::transmute(ppaddinginfo),
1700             ::std::mem::transmute(pbiv),
1701             ::std::mem::transmute(cbiv),
1702             ::std::mem::transmute(pboutput),
1703             ::std::mem::transmute(cboutput),
1704             ::std::mem::transmute(pcbresult),
1705             ::std::mem::transmute(dwflags),
1706         )
1707         .ok()
1708     }
1709     #[cfg(not(windows))]
1710     unimplemented!("Unsupported target OS");
1711 }
1712 #[cfg(feature = "Win32_Foundation")]
1713 #[inline]
BCryptDeleteContext<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1) -> ::windows::runtime::Result<()>1714 pub unsafe fn BCryptDeleteContext<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1) -> ::windows::runtime::Result<()> {
1715     #[cfg(windows)]
1716     {
1717         #[link(name = "windows")]
1718         extern "system" {
1719             fn BCryptDeleteContext(dwtable: BCRYPT_TABLE, pszcontext: super::super::Foundation::PWSTR) -> super::super::Foundation::NTSTATUS;
1720         }
1721         BCryptDeleteContext(::std::mem::transmute(dwtable), pszcontext.into_param().abi()).ok()
1722     }
1723     #[cfg(not(windows))]
1724     unimplemented!("Unsupported target OS");
1725 }
1726 #[cfg(feature = "Win32_Foundation")]
1727 #[inline]
BCryptDeriveKey<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hsharedsecret: *const ::std::ffi::c_void, pwszkdf: Param1, pparameterlist: *const BCryptBufferDesc, pbderivedkey: *mut u8, cbderivedkey: u32, pcbresult: *mut u32, dwflags: u32) -> ::windows::runtime::Result<()>1728 pub unsafe fn BCryptDeriveKey<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hsharedsecret: *const ::std::ffi::c_void, pwszkdf: Param1, pparameterlist: *const BCryptBufferDesc, pbderivedkey: *mut u8, cbderivedkey: u32, pcbresult: *mut u32, dwflags: u32) -> ::windows::runtime::Result<()> {
1729     #[cfg(windows)]
1730     {
1731         #[link(name = "windows")]
1732         extern "system" {
1733             fn BCryptDeriveKey(hsharedsecret: *const ::std::ffi::c_void, pwszkdf: super::super::Foundation::PWSTR, pparameterlist: *const BCryptBufferDesc, pbderivedkey: *mut u8, cbderivedkey: u32, pcbresult: *mut u32, dwflags: u32) -> super::super::Foundation::NTSTATUS;
1734         }
1735         BCryptDeriveKey(::std::mem::transmute(hsharedsecret), pwszkdf.into_param().abi(), ::std::mem::transmute(pparameterlist), ::std::mem::transmute(pbderivedkey), ::std::mem::transmute(cbderivedkey), ::std::mem::transmute(pcbresult), ::std::mem::transmute(dwflags)).ok()
1736     }
1737     #[cfg(not(windows))]
1738     unimplemented!("Unsupported target OS");
1739 }
1740 #[cfg(feature = "Win32_Foundation")]
1741 #[inline]
BCryptDeriveKeyCapi<'a, Param1: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>>(hhash: *const ::std::ffi::c_void, htargetalg: Param1, pbderivedkey: *mut u8, cbderivedkey: u32, dwflags: u32) -> ::windows::runtime::Result<()>1742 pub unsafe fn BCryptDeriveKeyCapi<'a, Param1: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>>(hhash: *const ::std::ffi::c_void, htargetalg: Param1, pbderivedkey: *mut u8, cbderivedkey: u32, dwflags: u32) -> ::windows::runtime::Result<()> {
1743     #[cfg(windows)]
1744     {
1745         #[link(name = "windows")]
1746         extern "system" {
1747             fn BCryptDeriveKeyCapi(hhash: *const ::std::ffi::c_void, htargetalg: BCRYPT_ALG_HANDLE, pbderivedkey: *mut u8, cbderivedkey: u32, dwflags: u32) -> super::super::Foundation::NTSTATUS;
1748         }
1749         BCryptDeriveKeyCapi(::std::mem::transmute(hhash), htargetalg.into_param().abi(), ::std::mem::transmute(pbderivedkey), ::std::mem::transmute(cbderivedkey), ::std::mem::transmute(dwflags)).ok()
1750     }
1751     #[cfg(not(windows))]
1752     unimplemented!("Unsupported target OS");
1753 }
1754 #[cfg(feature = "Win32_Foundation")]
1755 #[inline]
BCryptDeriveKeyPBKDF2<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>>(hprf: Param0, pbpassword: *const u8, cbpassword: u32, pbsalt: *const u8, cbsalt: u32, citerations: u64, pbderivedkey: *mut u8, cbderivedkey: u32, dwflags: u32) -> ::windows::runtime::Result<()>1756 pub unsafe fn BCryptDeriveKeyPBKDF2<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>>(hprf: Param0, pbpassword: *const u8, cbpassword: u32, pbsalt: *const u8, cbsalt: u32, citerations: u64, pbderivedkey: *mut u8, cbderivedkey: u32, dwflags: u32) -> ::windows::runtime::Result<()> {
1757     #[cfg(windows)]
1758     {
1759         #[link(name = "windows")]
1760         extern "system" {
1761             fn BCryptDeriveKeyPBKDF2(hprf: BCRYPT_ALG_HANDLE, pbpassword: *const u8, cbpassword: u32, pbsalt: *const u8, cbsalt: u32, citerations: u64, pbderivedkey: *mut u8, cbderivedkey: u32, dwflags: u32) -> super::super::Foundation::NTSTATUS;
1762         }
1763         BCryptDeriveKeyPBKDF2(hprf.into_param().abi(), ::std::mem::transmute(pbpassword), ::std::mem::transmute(cbpassword), ::std::mem::transmute(pbsalt), ::std::mem::transmute(cbsalt), ::std::mem::transmute(citerations), ::std::mem::transmute(pbderivedkey), ::std::mem::transmute(cbderivedkey), ::std::mem::transmute(dwflags)).ok()
1764     }
1765     #[cfg(not(windows))]
1766     unimplemented!("Unsupported target OS");
1767 }
1768 #[cfg(feature = "Win32_Foundation")]
1769 #[inline]
BCryptDestroyHash(hhash: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>1770 pub unsafe fn BCryptDestroyHash(hhash: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
1771     #[cfg(windows)]
1772     {
1773         #[link(name = "windows")]
1774         extern "system" {
1775             fn BCryptDestroyHash(hhash: *mut ::std::ffi::c_void) -> super::super::Foundation::NTSTATUS;
1776         }
1777         BCryptDestroyHash(::std::mem::transmute(hhash)).ok()
1778     }
1779     #[cfg(not(windows))]
1780     unimplemented!("Unsupported target OS");
1781 }
1782 #[cfg(feature = "Win32_Foundation")]
1783 #[inline]
BCryptDestroyKey<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hkey: Param0) -> ::windows::runtime::Result<()>1784 pub unsafe fn BCryptDestroyKey<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hkey: Param0) -> ::windows::runtime::Result<()> {
1785     #[cfg(windows)]
1786     {
1787         #[link(name = "windows")]
1788         extern "system" {
1789             fn BCryptDestroyKey(hkey: BCRYPT_KEY_HANDLE) -> super::super::Foundation::NTSTATUS;
1790         }
1791         BCryptDestroyKey(hkey.into_param().abi()).ok()
1792     }
1793     #[cfg(not(windows))]
1794     unimplemented!("Unsupported target OS");
1795 }
1796 #[cfg(feature = "Win32_Foundation")]
1797 #[inline]
BCryptDestroySecret(hsecret: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>1798 pub unsafe fn BCryptDestroySecret(hsecret: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
1799     #[cfg(windows)]
1800     {
1801         #[link(name = "windows")]
1802         extern "system" {
1803             fn BCryptDestroySecret(hsecret: *mut ::std::ffi::c_void) -> super::super::Foundation::NTSTATUS;
1804         }
1805         BCryptDestroySecret(::std::mem::transmute(hsecret)).ok()
1806     }
1807     #[cfg(not(windows))]
1808     unimplemented!("Unsupported target OS");
1809 }
1810 #[cfg(feature = "Win32_Foundation")]
1811 #[inline]
BCryptDuplicateHash(hhash: *const ::std::ffi::c_void, phnewhash: *mut *mut ::std::ffi::c_void, pbhashobject: *mut u8, cbhashobject: u32, dwflags: u32) -> ::windows::runtime::Result<()>1812 pub unsafe fn BCryptDuplicateHash(hhash: *const ::std::ffi::c_void, phnewhash: *mut *mut ::std::ffi::c_void, pbhashobject: *mut u8, cbhashobject: u32, dwflags: u32) -> ::windows::runtime::Result<()> {
1813     #[cfg(windows)]
1814     {
1815         #[link(name = "windows")]
1816         extern "system" {
1817             fn BCryptDuplicateHash(hhash: *const ::std::ffi::c_void, phnewhash: *mut *mut ::std::ffi::c_void, pbhashobject: *mut u8, cbhashobject: u32, dwflags: u32) -> super::super::Foundation::NTSTATUS;
1818         }
1819         BCryptDuplicateHash(::std::mem::transmute(hhash), ::std::mem::transmute(phnewhash), ::std::mem::transmute(pbhashobject), ::std::mem::transmute(cbhashobject), ::std::mem::transmute(dwflags)).ok()
1820     }
1821     #[cfg(not(windows))]
1822     unimplemented!("Unsupported target OS");
1823 }
1824 #[cfg(feature = "Win32_Foundation")]
1825 #[inline]
BCryptDuplicateKey<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hkey: Param0, phnewkey: *mut BCRYPT_KEY_HANDLE, pbkeyobject: *mut u8, cbkeyobject: u32, dwflags: u32) -> ::windows::runtime::Result<()>1826 pub unsafe fn BCryptDuplicateKey<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hkey: Param0, phnewkey: *mut BCRYPT_KEY_HANDLE, pbkeyobject: *mut u8, cbkeyobject: u32, dwflags: u32) -> ::windows::runtime::Result<()> {
1827     #[cfg(windows)]
1828     {
1829         #[link(name = "windows")]
1830         extern "system" {
1831             fn BCryptDuplicateKey(hkey: BCRYPT_KEY_HANDLE, phnewkey: *mut BCRYPT_KEY_HANDLE, pbkeyobject: *mut u8, cbkeyobject: u32, dwflags: u32) -> super::super::Foundation::NTSTATUS;
1832         }
1833         BCryptDuplicateKey(hkey.into_param().abi(), ::std::mem::transmute(phnewkey), ::std::mem::transmute(pbkeyobject), ::std::mem::transmute(cbkeyobject), ::std::mem::transmute(dwflags)).ok()
1834     }
1835     #[cfg(not(windows))]
1836     unimplemented!("Unsupported target OS");
1837 }
1838 #[cfg(feature = "Win32_Foundation")]
1839 #[inline]
BCryptEncrypt<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hkey: Param0, pbinput: *const u8, cbinput: u32, ppaddinginfo: *const ::std::ffi::c_void, pbiv: *mut u8, cbiv: u32, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> ::windows::runtime::Result<()>1840 pub unsafe fn BCryptEncrypt<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hkey: Param0, pbinput: *const u8, cbinput: u32, ppaddinginfo: *const ::std::ffi::c_void, pbiv: *mut u8, cbiv: u32, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> ::windows::runtime::Result<()> {
1841     #[cfg(windows)]
1842     {
1843         #[link(name = "windows")]
1844         extern "system" {
1845             fn BCryptEncrypt(hkey: BCRYPT_KEY_HANDLE, pbinput: *const u8, cbinput: u32, ppaddinginfo: *const ::std::ffi::c_void, pbiv: *mut u8, cbiv: u32, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> super::super::Foundation::NTSTATUS;
1846         }
1847         BCryptEncrypt(
1848             hkey.into_param().abi(),
1849             ::std::mem::transmute(pbinput),
1850             ::std::mem::transmute(cbinput),
1851             ::std::mem::transmute(ppaddinginfo),
1852             ::std::mem::transmute(pbiv),
1853             ::std::mem::transmute(cbiv),
1854             ::std::mem::transmute(pboutput),
1855             ::std::mem::transmute(cboutput),
1856             ::std::mem::transmute(pcbresult),
1857             ::std::mem::transmute(dwflags),
1858         )
1859         .ok()
1860     }
1861     #[cfg(not(windows))]
1862     unimplemented!("Unsupported target OS");
1863 }
1864 #[cfg(feature = "Win32_Foundation")]
1865 #[inline]
BCryptEnumAlgorithms(dwalgoperations: BCRYPT_OPERATION, palgcount: *mut u32, ppalglist: *mut *mut BCRYPT_ALGORITHM_IDENTIFIER, dwflags: u32) -> ::windows::runtime::Result<()>1866 pub unsafe fn BCryptEnumAlgorithms(dwalgoperations: BCRYPT_OPERATION, palgcount: *mut u32, ppalglist: *mut *mut BCRYPT_ALGORITHM_IDENTIFIER, dwflags: u32) -> ::windows::runtime::Result<()> {
1867     #[cfg(windows)]
1868     {
1869         #[link(name = "windows")]
1870         extern "system" {
1871             fn BCryptEnumAlgorithms(dwalgoperations: BCRYPT_OPERATION, palgcount: *mut u32, ppalglist: *mut *mut BCRYPT_ALGORITHM_IDENTIFIER, dwflags: u32) -> super::super::Foundation::NTSTATUS;
1872         }
1873         BCryptEnumAlgorithms(::std::mem::transmute(dwalgoperations), ::std::mem::transmute(palgcount), ::std::mem::transmute(ppalglist), ::std::mem::transmute(dwflags)).ok()
1874     }
1875     #[cfg(not(windows))]
1876     unimplemented!("Unsupported target OS");
1877 }
1878 #[cfg(feature = "Win32_Foundation")]
1879 #[inline]
BCryptEnumContextFunctionProviders<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, dwinterface: BCRYPT_INTERFACE, pszfunction: Param3, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_CONTEXT_FUNCTION_PROVIDERS) -> ::windows::runtime::Result<()>1880 pub unsafe fn BCryptEnumContextFunctionProviders<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, dwinterface: BCRYPT_INTERFACE, pszfunction: Param3, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_CONTEXT_FUNCTION_PROVIDERS) -> ::windows::runtime::Result<()> {
1881     #[cfg(windows)]
1882     {
1883         #[link(name = "windows")]
1884         extern "system" {
1885             fn BCryptEnumContextFunctionProviders(dwtable: BCRYPT_TABLE, pszcontext: super::super::Foundation::PWSTR, dwinterface: BCRYPT_INTERFACE, pszfunction: super::super::Foundation::PWSTR, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_CONTEXT_FUNCTION_PROVIDERS) -> super::super::Foundation::NTSTATUS;
1886         }
1887         BCryptEnumContextFunctionProviders(::std::mem::transmute(dwtable), pszcontext.into_param().abi(), ::std::mem::transmute(dwinterface), pszfunction.into_param().abi(), ::std::mem::transmute(pcbbuffer), ::std::mem::transmute(ppbuffer)).ok()
1888     }
1889     #[cfg(not(windows))]
1890     unimplemented!("Unsupported target OS");
1891 }
1892 #[cfg(feature = "Win32_Foundation")]
1893 #[inline]
BCryptEnumContextFunctions<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, dwinterface: BCRYPT_INTERFACE, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_CONTEXT_FUNCTIONS) -> ::windows::runtime::Result<()>1894 pub unsafe fn BCryptEnumContextFunctions<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, dwinterface: BCRYPT_INTERFACE, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_CONTEXT_FUNCTIONS) -> ::windows::runtime::Result<()> {
1895     #[cfg(windows)]
1896     {
1897         #[link(name = "windows")]
1898         extern "system" {
1899             fn BCryptEnumContextFunctions(dwtable: BCRYPT_TABLE, pszcontext: super::super::Foundation::PWSTR, dwinterface: BCRYPT_INTERFACE, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_CONTEXT_FUNCTIONS) -> super::super::Foundation::NTSTATUS;
1900         }
1901         BCryptEnumContextFunctions(::std::mem::transmute(dwtable), pszcontext.into_param().abi(), ::std::mem::transmute(dwinterface), ::std::mem::transmute(pcbbuffer), ::std::mem::transmute(ppbuffer)).ok()
1902     }
1903     #[cfg(not(windows))]
1904     unimplemented!("Unsupported target OS");
1905 }
1906 #[cfg(feature = "Win32_Foundation")]
1907 #[inline]
BCryptEnumContexts(dwtable: BCRYPT_TABLE, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_CONTEXTS) -> ::windows::runtime::Result<()>1908 pub unsafe fn BCryptEnumContexts(dwtable: BCRYPT_TABLE, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_CONTEXTS) -> ::windows::runtime::Result<()> {
1909     #[cfg(windows)]
1910     {
1911         #[link(name = "windows")]
1912         extern "system" {
1913             fn BCryptEnumContexts(dwtable: BCRYPT_TABLE, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_CONTEXTS) -> super::super::Foundation::NTSTATUS;
1914         }
1915         BCryptEnumContexts(::std::mem::transmute(dwtable), ::std::mem::transmute(pcbbuffer), ::std::mem::transmute(ppbuffer)).ok()
1916     }
1917     #[cfg(not(windows))]
1918     unimplemented!("Unsupported target OS");
1919 }
1920 #[cfg(feature = "Win32_Foundation")]
1921 #[inline]
BCryptEnumProviders<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pszalgid: Param0, pimplcount: *mut u32, ppimpllist: *mut *mut BCRYPT_PROVIDER_NAME, dwflags: u32) -> ::windows::runtime::Result<()>1922 pub unsafe fn BCryptEnumProviders<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pszalgid: Param0, pimplcount: *mut u32, ppimpllist: *mut *mut BCRYPT_PROVIDER_NAME, dwflags: u32) -> ::windows::runtime::Result<()> {
1923     #[cfg(windows)]
1924     {
1925         #[link(name = "windows")]
1926         extern "system" {
1927             fn BCryptEnumProviders(pszalgid: super::super::Foundation::PWSTR, pimplcount: *mut u32, ppimpllist: *mut *mut BCRYPT_PROVIDER_NAME, dwflags: u32) -> super::super::Foundation::NTSTATUS;
1928         }
1929         BCryptEnumProviders(pszalgid.into_param().abi(), ::std::mem::transmute(pimplcount), ::std::mem::transmute(ppimpllist), ::std::mem::transmute(dwflags)).ok()
1930     }
1931     #[cfg(not(windows))]
1932     unimplemented!("Unsupported target OS");
1933 }
1934 #[cfg(feature = "Win32_Foundation")]
1935 #[inline]
BCryptEnumRegisteredProviders(pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_PROVIDERS) -> ::windows::runtime::Result<()>1936 pub unsafe fn BCryptEnumRegisteredProviders(pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_PROVIDERS) -> ::windows::runtime::Result<()> {
1937     #[cfg(windows)]
1938     {
1939         #[link(name = "windows")]
1940         extern "system" {
1941             fn BCryptEnumRegisteredProviders(pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_PROVIDERS) -> super::super::Foundation::NTSTATUS;
1942         }
1943         BCryptEnumRegisteredProviders(::std::mem::transmute(pcbbuffer), ::std::mem::transmute(ppbuffer)).ok()
1944     }
1945     #[cfg(not(windows))]
1946     unimplemented!("Unsupported target OS");
1947 }
1948 #[cfg(feature = "Win32_Foundation")]
1949 #[inline]
BCryptExportKey<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>, Param1: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hkey: Param0, hexportkey: Param1, pszblobtype: Param2, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: u32) -> ::windows::runtime::Result<()>1950 pub unsafe fn BCryptExportKey<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>, Param1: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hkey: Param0, hexportkey: Param1, pszblobtype: Param2, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: u32) -> ::windows::runtime::Result<()> {
1951     #[cfg(windows)]
1952     {
1953         #[link(name = "windows")]
1954         extern "system" {
1955             fn BCryptExportKey(hkey: BCRYPT_KEY_HANDLE, hexportkey: BCRYPT_KEY_HANDLE, pszblobtype: super::super::Foundation::PWSTR, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: u32) -> super::super::Foundation::NTSTATUS;
1956         }
1957         BCryptExportKey(hkey.into_param().abi(), hexportkey.into_param().abi(), pszblobtype.into_param().abi(), ::std::mem::transmute(pboutput), ::std::mem::transmute(cboutput), ::std::mem::transmute(pcbresult), ::std::mem::transmute(dwflags)).ok()
1958     }
1959     #[cfg(not(windows))]
1960     unimplemented!("Unsupported target OS");
1961 }
1962 #[cfg(feature = "Win32_Foundation")]
1963 #[inline]
BCryptFinalizeKeyPair<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hkey: Param0, dwflags: u32) -> ::windows::runtime::Result<()>1964 pub unsafe fn BCryptFinalizeKeyPair<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hkey: Param0, dwflags: u32) -> ::windows::runtime::Result<()> {
1965     #[cfg(windows)]
1966     {
1967         #[link(name = "windows")]
1968         extern "system" {
1969             fn BCryptFinalizeKeyPair(hkey: BCRYPT_KEY_HANDLE, dwflags: u32) -> super::super::Foundation::NTSTATUS;
1970         }
1971         BCryptFinalizeKeyPair(hkey.into_param().abi(), ::std::mem::transmute(dwflags)).ok()
1972     }
1973     #[cfg(not(windows))]
1974     unimplemented!("Unsupported target OS");
1975 }
1976 #[cfg(feature = "Win32_Foundation")]
1977 #[inline]
BCryptFinishHash(hhash: *mut ::std::ffi::c_void, pboutput: *mut u8, cboutput: u32, dwflags: u32) -> ::windows::runtime::Result<()>1978 pub unsafe fn BCryptFinishHash(hhash: *mut ::std::ffi::c_void, pboutput: *mut u8, cboutput: u32, dwflags: u32) -> ::windows::runtime::Result<()> {
1979     #[cfg(windows)]
1980     {
1981         #[link(name = "windows")]
1982         extern "system" {
1983             fn BCryptFinishHash(hhash: *mut ::std::ffi::c_void, pboutput: *mut u8, cboutput: u32, dwflags: u32) -> super::super::Foundation::NTSTATUS;
1984         }
1985         BCryptFinishHash(::std::mem::transmute(hhash), ::std::mem::transmute(pboutput), ::std::mem::transmute(cboutput), ::std::mem::transmute(dwflags)).ok()
1986     }
1987     #[cfg(not(windows))]
1988     unimplemented!("Unsupported target OS");
1989 }
1990 #[inline]
BCryptFreeBuffer(pvbuffer: *const ::std::ffi::c_void)1991 pub unsafe fn BCryptFreeBuffer(pvbuffer: *const ::std::ffi::c_void) {
1992     #[cfg(windows)]
1993     {
1994         #[link(name = "windows")]
1995         extern "system" {
1996             fn BCryptFreeBuffer(pvbuffer: *const ::std::ffi::c_void);
1997         }
1998         ::std::mem::transmute(BCryptFreeBuffer(::std::mem::transmute(pvbuffer)))
1999     }
2000     #[cfg(not(windows))]
2001     unimplemented!("Unsupported target OS");
2002 }
2003 #[cfg(feature = "Win32_Foundation")]
2004 #[inline]
BCryptGenRandom<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>>(halgorithm: Param0, pbbuffer: *mut u8, cbbuffer: u32, dwflags: u32) -> ::windows::runtime::Result<()>2005 pub unsafe fn BCryptGenRandom<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>>(halgorithm: Param0, pbbuffer: *mut u8, cbbuffer: u32, dwflags: u32) -> ::windows::runtime::Result<()> {
2006     #[cfg(windows)]
2007     {
2008         #[link(name = "windows")]
2009         extern "system" {
2010             fn BCryptGenRandom(halgorithm: BCRYPT_ALG_HANDLE, pbbuffer: *mut u8, cbbuffer: u32, dwflags: u32) -> super::super::Foundation::NTSTATUS;
2011         }
2012         BCryptGenRandom(halgorithm.into_param().abi(), ::std::mem::transmute(pbbuffer), ::std::mem::transmute(cbbuffer), ::std::mem::transmute(dwflags)).ok()
2013     }
2014     #[cfg(not(windows))]
2015     unimplemented!("Unsupported target OS");
2016 }
2017 #[cfg(feature = "Win32_Foundation")]
2018 #[inline]
BCryptGenerateKeyPair<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>>(halgorithm: Param0, phkey: *mut BCRYPT_KEY_HANDLE, dwlength: u32, dwflags: u32) -> ::windows::runtime::Result<()>2019 pub unsafe fn BCryptGenerateKeyPair<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>>(halgorithm: Param0, phkey: *mut BCRYPT_KEY_HANDLE, dwlength: u32, dwflags: u32) -> ::windows::runtime::Result<()> {
2020     #[cfg(windows)]
2021     {
2022         #[link(name = "windows")]
2023         extern "system" {
2024             fn BCryptGenerateKeyPair(halgorithm: BCRYPT_ALG_HANDLE, phkey: *mut BCRYPT_KEY_HANDLE, dwlength: u32, dwflags: u32) -> super::super::Foundation::NTSTATUS;
2025         }
2026         BCryptGenerateKeyPair(halgorithm.into_param().abi(), ::std::mem::transmute(phkey), ::std::mem::transmute(dwlength), ::std::mem::transmute(dwflags)).ok()
2027     }
2028     #[cfg(not(windows))]
2029     unimplemented!("Unsupported target OS");
2030 }
2031 #[cfg(feature = "Win32_Foundation")]
2032 #[inline]
BCryptGenerateSymmetricKey<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>>(halgorithm: Param0, phkey: *mut BCRYPT_KEY_HANDLE, pbkeyobject: *mut u8, cbkeyobject: u32, pbsecret: *const u8, cbsecret: u32, dwflags: u32) -> ::windows::runtime::Result<()>2033 pub unsafe fn BCryptGenerateSymmetricKey<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>>(halgorithm: Param0, phkey: *mut BCRYPT_KEY_HANDLE, pbkeyobject: *mut u8, cbkeyobject: u32, pbsecret: *const u8, cbsecret: u32, dwflags: u32) -> ::windows::runtime::Result<()> {
2034     #[cfg(windows)]
2035     {
2036         #[link(name = "windows")]
2037         extern "system" {
2038             fn BCryptGenerateSymmetricKey(halgorithm: BCRYPT_ALG_HANDLE, phkey: *mut BCRYPT_KEY_HANDLE, pbkeyobject: *mut u8, cbkeyobject: u32, pbsecret: *const u8, cbsecret: u32, dwflags: u32) -> super::super::Foundation::NTSTATUS;
2039         }
2040         BCryptGenerateSymmetricKey(halgorithm.into_param().abi(), ::std::mem::transmute(phkey), ::std::mem::transmute(pbkeyobject), ::std::mem::transmute(cbkeyobject), ::std::mem::transmute(pbsecret), ::std::mem::transmute(cbsecret), ::std::mem::transmute(dwflags)).ok()
2041     }
2042     #[cfg(not(windows))]
2043     unimplemented!("Unsupported target OS");
2044 }
2045 #[cfg(feature = "Win32_Foundation")]
2046 #[inline]
BCryptGetFipsAlgorithmMode(pfenabled: *mut u8) -> ::windows::runtime::Result<()>2047 pub unsafe fn BCryptGetFipsAlgorithmMode(pfenabled: *mut u8) -> ::windows::runtime::Result<()> {
2048     #[cfg(windows)]
2049     {
2050         #[link(name = "windows")]
2051         extern "system" {
2052             fn BCryptGetFipsAlgorithmMode(pfenabled: *mut u8) -> super::super::Foundation::NTSTATUS;
2053         }
2054         BCryptGetFipsAlgorithmMode(::std::mem::transmute(pfenabled)).ok()
2055     }
2056     #[cfg(not(windows))]
2057     unimplemented!("Unsupported target OS");
2058 }
2059 #[cfg(feature = "Win32_Foundation")]
2060 #[inline]
BCryptGetProperty<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hobject: *const ::std::ffi::c_void, pszproperty: Param1, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: u32) -> ::windows::runtime::Result<()>2061 pub unsafe fn BCryptGetProperty<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hobject: *const ::std::ffi::c_void, pszproperty: Param1, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: u32) -> ::windows::runtime::Result<()> {
2062     #[cfg(windows)]
2063     {
2064         #[link(name = "windows")]
2065         extern "system" {
2066             fn BCryptGetProperty(hobject: *const ::std::ffi::c_void, pszproperty: super::super::Foundation::PWSTR, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: u32) -> super::super::Foundation::NTSTATUS;
2067         }
2068         BCryptGetProperty(::std::mem::transmute(hobject), pszproperty.into_param().abi(), ::std::mem::transmute(pboutput), ::std::mem::transmute(cboutput), ::std::mem::transmute(pcbresult), ::std::mem::transmute(dwflags)).ok()
2069     }
2070     #[cfg(not(windows))]
2071     unimplemented!("Unsupported target OS");
2072 }
2073 #[cfg(feature = "Win32_Foundation")]
2074 #[inline]
BCryptHash<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>>(halgorithm: Param0, pbsecret: *const u8, cbsecret: u32, pbinput: *const u8, cbinput: u32, pboutput: *mut u8, cboutput: u32) -> ::windows::runtime::Result<()>2075 pub unsafe fn BCryptHash<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>>(halgorithm: Param0, pbsecret: *const u8, cbsecret: u32, pbinput: *const u8, cbinput: u32, pboutput: *mut u8, cboutput: u32) -> ::windows::runtime::Result<()> {
2076     #[cfg(windows)]
2077     {
2078         #[link(name = "windows")]
2079         extern "system" {
2080             fn BCryptHash(halgorithm: BCRYPT_ALG_HANDLE, pbsecret: *const u8, cbsecret: u32, pbinput: *const u8, cbinput: u32, pboutput: *mut u8, cboutput: u32) -> super::super::Foundation::NTSTATUS;
2081         }
2082         BCryptHash(halgorithm.into_param().abi(), ::std::mem::transmute(pbsecret), ::std::mem::transmute(cbsecret), ::std::mem::transmute(pbinput), ::std::mem::transmute(cbinput), ::std::mem::transmute(pboutput), ::std::mem::transmute(cboutput)).ok()
2083     }
2084     #[cfg(not(windows))]
2085     unimplemented!("Unsupported target OS");
2086 }
2087 #[cfg(feature = "Win32_Foundation")]
2088 #[inline]
BCryptHashData(hhash: *mut ::std::ffi::c_void, pbinput: *const u8, cbinput: u32, dwflags: u32) -> ::windows::runtime::Result<()>2089 pub unsafe fn BCryptHashData(hhash: *mut ::std::ffi::c_void, pbinput: *const u8, cbinput: u32, dwflags: u32) -> ::windows::runtime::Result<()> {
2090     #[cfg(windows)]
2091     {
2092         #[link(name = "windows")]
2093         extern "system" {
2094             fn BCryptHashData(hhash: *mut ::std::ffi::c_void, pbinput: *const u8, cbinput: u32, dwflags: u32) -> super::super::Foundation::NTSTATUS;
2095         }
2096         BCryptHashData(::std::mem::transmute(hhash), ::std::mem::transmute(pbinput), ::std::mem::transmute(cbinput), ::std::mem::transmute(dwflags)).ok()
2097     }
2098     #[cfg(not(windows))]
2099     unimplemented!("Unsupported target OS");
2100 }
2101 #[cfg(feature = "Win32_Foundation")]
2102 #[inline]
BCryptImportKey<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>, Param1: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(halgorithm: Param0, himportkey: Param1, pszblobtype: Param2, phkey: *mut BCRYPT_KEY_HANDLE, pbkeyobject: *mut u8, cbkeyobject: u32, pbinput: *const u8, cbinput: u32, dwflags: u32) -> ::windows::runtime::Result<()>2103 pub unsafe fn BCryptImportKey<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>, Param1: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(halgorithm: Param0, himportkey: Param1, pszblobtype: Param2, phkey: *mut BCRYPT_KEY_HANDLE, pbkeyobject: *mut u8, cbkeyobject: u32, pbinput: *const u8, cbinput: u32, dwflags: u32) -> ::windows::runtime::Result<()> {
2104     #[cfg(windows)]
2105     {
2106         #[link(name = "windows")]
2107         extern "system" {
2108             fn BCryptImportKey(halgorithm: BCRYPT_ALG_HANDLE, himportkey: BCRYPT_KEY_HANDLE, pszblobtype: super::super::Foundation::PWSTR, phkey: *mut BCRYPT_KEY_HANDLE, pbkeyobject: *mut u8, cbkeyobject: u32, pbinput: *const u8, cbinput: u32, dwflags: u32) -> super::super::Foundation::NTSTATUS;
2109         }
2110         BCryptImportKey(halgorithm.into_param().abi(), himportkey.into_param().abi(), pszblobtype.into_param().abi(), ::std::mem::transmute(phkey), ::std::mem::transmute(pbkeyobject), ::std::mem::transmute(cbkeyobject), ::std::mem::transmute(pbinput), ::std::mem::transmute(cbinput), ::std::mem::transmute(dwflags)).ok()
2111     }
2112     #[cfg(not(windows))]
2113     unimplemented!("Unsupported target OS");
2114 }
2115 #[cfg(feature = "Win32_Foundation")]
2116 #[inline]
BCryptImportKeyPair<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>, Param1: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(halgorithm: Param0, himportkey: Param1, pszblobtype: Param2, phkey: *mut BCRYPT_KEY_HANDLE, pbinput: *const u8, cbinput: u32, dwflags: u32) -> ::windows::runtime::Result<()>2117 pub unsafe fn BCryptImportKeyPair<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_ALG_HANDLE>, Param1: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(halgorithm: Param0, himportkey: Param1, pszblobtype: Param2, phkey: *mut BCRYPT_KEY_HANDLE, pbinput: *const u8, cbinput: u32, dwflags: u32) -> ::windows::runtime::Result<()> {
2118     #[cfg(windows)]
2119     {
2120         #[link(name = "windows")]
2121         extern "system" {
2122             fn BCryptImportKeyPair(halgorithm: BCRYPT_ALG_HANDLE, himportkey: BCRYPT_KEY_HANDLE, pszblobtype: super::super::Foundation::PWSTR, phkey: *mut BCRYPT_KEY_HANDLE, pbinput: *const u8, cbinput: u32, dwflags: u32) -> super::super::Foundation::NTSTATUS;
2123         }
2124         BCryptImportKeyPair(halgorithm.into_param().abi(), himportkey.into_param().abi(), pszblobtype.into_param().abi(), ::std::mem::transmute(phkey), ::std::mem::transmute(pbinput), ::std::mem::transmute(cbinput), ::std::mem::transmute(dwflags)).ok()
2125     }
2126     #[cfg(not(windows))]
2127     unimplemented!("Unsupported target OS");
2128 }
2129 #[cfg(feature = "Win32_Foundation")]
2130 #[inline]
BCryptKeyDerivation<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hkey: Param0, pparameterlist: *const BCryptBufferDesc, pbderivedkey: *mut u8, cbderivedkey: u32, pcbresult: *mut u32, dwflags: u32) -> ::windows::runtime::Result<()>2131 pub unsafe fn BCryptKeyDerivation<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hkey: Param0, pparameterlist: *const BCryptBufferDesc, pbderivedkey: *mut u8, cbderivedkey: u32, pcbresult: *mut u32, dwflags: u32) -> ::windows::runtime::Result<()> {
2132     #[cfg(windows)]
2133     {
2134         #[link(name = "windows")]
2135         extern "system" {
2136             fn BCryptKeyDerivation(hkey: BCRYPT_KEY_HANDLE, pparameterlist: *const BCryptBufferDesc, pbderivedkey: *mut u8, cbderivedkey: u32, pcbresult: *mut u32, dwflags: u32) -> super::super::Foundation::NTSTATUS;
2137         }
2138         BCryptKeyDerivation(hkey.into_param().abi(), ::std::mem::transmute(pparameterlist), ::std::mem::transmute(pbderivedkey), ::std::mem::transmute(cbderivedkey), ::std::mem::transmute(pcbresult), ::std::mem::transmute(dwflags)).ok()
2139     }
2140     #[cfg(not(windows))]
2141     unimplemented!("Unsupported target OS");
2142 }
2143 #[cfg(feature = "Win32_Foundation")]
2144 #[inline]
BCryptOpenAlgorithmProvider<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(phalgorithm: *mut BCRYPT_ALG_HANDLE, pszalgid: Param1, pszimplementation: Param2, dwflags: BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS) -> ::windows::runtime::Result<()>2145 pub unsafe fn BCryptOpenAlgorithmProvider<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(phalgorithm: *mut BCRYPT_ALG_HANDLE, pszalgid: Param1, pszimplementation: Param2, dwflags: BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS) -> ::windows::runtime::Result<()> {
2146     #[cfg(windows)]
2147     {
2148         #[link(name = "windows")]
2149         extern "system" {
2150             fn BCryptOpenAlgorithmProvider(phalgorithm: *mut BCRYPT_ALG_HANDLE, pszalgid: super::super::Foundation::PWSTR, pszimplementation: super::super::Foundation::PWSTR, dwflags: BCRYPT_OPEN_ALGORITHM_PROVIDER_FLAGS) -> super::super::Foundation::NTSTATUS;
2151         }
2152         BCryptOpenAlgorithmProvider(::std::mem::transmute(phalgorithm), pszalgid.into_param().abi(), pszimplementation.into_param().abi(), ::std::mem::transmute(dwflags)).ok()
2153     }
2154     #[cfg(not(windows))]
2155     unimplemented!("Unsupported target OS");
2156 }
2157 #[cfg(feature = "Win32_Foundation")]
2158 #[inline]
BCryptProcessMultiOperations(hobject: *mut ::std::ffi::c_void, operationtype: BCRYPT_MULTI_OPERATION_TYPE, poperations: *const ::std::ffi::c_void, cboperations: u32, dwflags: u32) -> ::windows::runtime::Result<()>2159 pub unsafe fn BCryptProcessMultiOperations(hobject: *mut ::std::ffi::c_void, operationtype: BCRYPT_MULTI_OPERATION_TYPE, poperations: *const ::std::ffi::c_void, cboperations: u32, dwflags: u32) -> ::windows::runtime::Result<()> {
2160     #[cfg(windows)]
2161     {
2162         #[link(name = "windows")]
2163         extern "system" {
2164             fn BCryptProcessMultiOperations(hobject: *mut ::std::ffi::c_void, operationtype: BCRYPT_MULTI_OPERATION_TYPE, poperations: *const ::std::ffi::c_void, cboperations: u32, dwflags: u32) -> super::super::Foundation::NTSTATUS;
2165         }
2166         BCryptProcessMultiOperations(::std::mem::transmute(hobject), ::std::mem::transmute(operationtype), ::std::mem::transmute(poperations), ::std::mem::transmute(cboperations), ::std::mem::transmute(dwflags)).ok()
2167     }
2168     #[cfg(not(windows))]
2169     unimplemented!("Unsupported target OS");
2170 }
2171 #[cfg(feature = "Win32_Foundation")]
2172 #[inline]
BCryptQueryContextConfiguration<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_CONTEXT_CONFIG) -> ::windows::runtime::Result<()>2173 pub unsafe fn BCryptQueryContextConfiguration<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_CONTEXT_CONFIG) -> ::windows::runtime::Result<()> {
2174     #[cfg(windows)]
2175     {
2176         #[link(name = "windows")]
2177         extern "system" {
2178             fn BCryptQueryContextConfiguration(dwtable: BCRYPT_TABLE, pszcontext: super::super::Foundation::PWSTR, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_CONTEXT_CONFIG) -> super::super::Foundation::NTSTATUS;
2179         }
2180         BCryptQueryContextConfiguration(::std::mem::transmute(dwtable), pszcontext.into_param().abi(), ::std::mem::transmute(pcbbuffer), ::std::mem::transmute(ppbuffer)).ok()
2181     }
2182     #[cfg(not(windows))]
2183     unimplemented!("Unsupported target OS");
2184 }
2185 #[cfg(feature = "Win32_Foundation")]
2186 #[inline]
BCryptQueryContextFunctionConfiguration<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, dwinterface: BCRYPT_INTERFACE, pszfunction: Param3, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_CONTEXT_FUNCTION_CONFIG) -> ::windows::runtime::Result<()>2187 pub unsafe fn BCryptQueryContextFunctionConfiguration<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, dwinterface: BCRYPT_INTERFACE, pszfunction: Param3, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_CONTEXT_FUNCTION_CONFIG) -> ::windows::runtime::Result<()> {
2188     #[cfg(windows)]
2189     {
2190         #[link(name = "windows")]
2191         extern "system" {
2192             fn BCryptQueryContextFunctionConfiguration(dwtable: BCRYPT_TABLE, pszcontext: super::super::Foundation::PWSTR, dwinterface: BCRYPT_INTERFACE, pszfunction: super::super::Foundation::PWSTR, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_CONTEXT_FUNCTION_CONFIG) -> super::super::Foundation::NTSTATUS;
2193         }
2194         BCryptQueryContextFunctionConfiguration(::std::mem::transmute(dwtable), pszcontext.into_param().abi(), ::std::mem::transmute(dwinterface), pszfunction.into_param().abi(), ::std::mem::transmute(pcbbuffer), ::std::mem::transmute(ppbuffer)).ok()
2195     }
2196     #[cfg(not(windows))]
2197     unimplemented!("Unsupported target OS");
2198 }
2199 #[cfg(feature = "Win32_Foundation")]
2200 #[inline]
BCryptQueryContextFunctionProperty<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, dwinterface: BCRYPT_INTERFACE, pszfunction: Param3, pszproperty: Param4, pcbvalue: *mut u32, ppbvalue: *mut *mut u8) -> ::windows::runtime::Result<()>2201 pub unsafe fn BCryptQueryContextFunctionProperty<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, dwinterface: BCRYPT_INTERFACE, pszfunction: Param3, pszproperty: Param4, pcbvalue: *mut u32, ppbvalue: *mut *mut u8) -> ::windows::runtime::Result<()> {
2202     #[cfg(windows)]
2203     {
2204         #[link(name = "windows")]
2205         extern "system" {
2206             fn BCryptQueryContextFunctionProperty(dwtable: BCRYPT_TABLE, pszcontext: super::super::Foundation::PWSTR, dwinterface: BCRYPT_INTERFACE, pszfunction: super::super::Foundation::PWSTR, pszproperty: super::super::Foundation::PWSTR, pcbvalue: *mut u32, ppbvalue: *mut *mut u8) -> super::super::Foundation::NTSTATUS;
2207         }
2208         BCryptQueryContextFunctionProperty(::std::mem::transmute(dwtable), pszcontext.into_param().abi(), ::std::mem::transmute(dwinterface), pszfunction.into_param().abi(), pszproperty.into_param().abi(), ::std::mem::transmute(pcbvalue), ::std::mem::transmute(ppbvalue)).ok()
2209     }
2210     #[cfg(not(windows))]
2211     unimplemented!("Unsupported target OS");
2212 }
2213 #[cfg(feature = "Win32_Foundation")]
2214 #[inline]
BCryptQueryProviderRegistration<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pszprovider: Param0, dwmode: BCRYPT_QUERY_PROVIDER_MODE, dwinterface: BCRYPT_INTERFACE, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_PROVIDER_REG) -> ::windows::runtime::Result<()>2215 pub unsafe fn BCryptQueryProviderRegistration<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pszprovider: Param0, dwmode: BCRYPT_QUERY_PROVIDER_MODE, dwinterface: BCRYPT_INTERFACE, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_PROVIDER_REG) -> ::windows::runtime::Result<()> {
2216     #[cfg(windows)]
2217     {
2218         #[link(name = "windows")]
2219         extern "system" {
2220             fn BCryptQueryProviderRegistration(pszprovider: super::super::Foundation::PWSTR, dwmode: BCRYPT_QUERY_PROVIDER_MODE, dwinterface: BCRYPT_INTERFACE, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_PROVIDER_REG) -> super::super::Foundation::NTSTATUS;
2221         }
2222         BCryptQueryProviderRegistration(pszprovider.into_param().abi(), ::std::mem::transmute(dwmode), ::std::mem::transmute(dwinterface), ::std::mem::transmute(pcbbuffer), ::std::mem::transmute(ppbuffer)).ok()
2223     }
2224     #[cfg(not(windows))]
2225     unimplemented!("Unsupported target OS");
2226 }
2227 #[cfg(feature = "Win32_Foundation")]
2228 #[inline]
BCryptRegisterConfigChangeNotify(phevent: *mut super::super::Foundation::HANDLE) -> ::windows::runtime::Result<()>2229 pub unsafe fn BCryptRegisterConfigChangeNotify(phevent: *mut super::super::Foundation::HANDLE) -> ::windows::runtime::Result<()> {
2230     #[cfg(windows)]
2231     {
2232         #[link(name = "windows")]
2233         extern "system" {
2234             fn BCryptRegisterConfigChangeNotify(phevent: *mut super::super::Foundation::HANDLE) -> super::super::Foundation::NTSTATUS;
2235         }
2236         BCryptRegisterConfigChangeNotify(::std::mem::transmute(phevent)).ok()
2237     }
2238     #[cfg(not(windows))]
2239     unimplemented!("Unsupported target OS");
2240 }
2241 #[cfg(feature = "Win32_Foundation")]
2242 #[inline]
BCryptRemoveContextFunction<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, dwinterface: BCRYPT_INTERFACE, pszfunction: Param3) -> ::windows::runtime::Result<()>2243 pub unsafe fn BCryptRemoveContextFunction<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, dwinterface: BCRYPT_INTERFACE, pszfunction: Param3) -> ::windows::runtime::Result<()> {
2244     #[cfg(windows)]
2245     {
2246         #[link(name = "windows")]
2247         extern "system" {
2248             fn BCryptRemoveContextFunction(dwtable: BCRYPT_TABLE, pszcontext: super::super::Foundation::PWSTR, dwinterface: BCRYPT_INTERFACE, pszfunction: super::super::Foundation::PWSTR) -> super::super::Foundation::NTSTATUS;
2249         }
2250         BCryptRemoveContextFunction(::std::mem::transmute(dwtable), pszcontext.into_param().abi(), ::std::mem::transmute(dwinterface), pszfunction.into_param().abi()).ok()
2251     }
2252     #[cfg(not(windows))]
2253     unimplemented!("Unsupported target OS");
2254 }
2255 #[cfg(feature = "Win32_Foundation")]
2256 #[inline]
BCryptResolveProviders<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>( pszcontext: Param0, dwinterface: u32, pszfunction: Param2, pszprovider: Param3, dwmode: BCRYPT_QUERY_PROVIDER_MODE, dwflags: BCRYPT_RESOLVE_PROVIDERS_FLAGS, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_PROVIDER_REFS, ) -> ::windows::runtime::Result<()>2257 pub unsafe fn BCryptResolveProviders<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(
2258     pszcontext: Param0,
2259     dwinterface: u32,
2260     pszfunction: Param2,
2261     pszprovider: Param3,
2262     dwmode: BCRYPT_QUERY_PROVIDER_MODE,
2263     dwflags: BCRYPT_RESOLVE_PROVIDERS_FLAGS,
2264     pcbbuffer: *mut u32,
2265     ppbuffer: *mut *mut CRYPT_PROVIDER_REFS,
2266 ) -> ::windows::runtime::Result<()> {
2267     #[cfg(windows)]
2268     {
2269         #[link(name = "windows")]
2270         extern "system" {
2271             fn BCryptResolveProviders(pszcontext: super::super::Foundation::PWSTR, dwinterface: u32, pszfunction: super::super::Foundation::PWSTR, pszprovider: super::super::Foundation::PWSTR, dwmode: BCRYPT_QUERY_PROVIDER_MODE, dwflags: BCRYPT_RESOLVE_PROVIDERS_FLAGS, pcbbuffer: *mut u32, ppbuffer: *mut *mut CRYPT_PROVIDER_REFS) -> super::super::Foundation::NTSTATUS;
2272         }
2273         BCryptResolveProviders(pszcontext.into_param().abi(), ::std::mem::transmute(dwinterface), pszfunction.into_param().abi(), pszprovider.into_param().abi(), ::std::mem::transmute(dwmode), ::std::mem::transmute(dwflags), ::std::mem::transmute(pcbbuffer), ::std::mem::transmute(ppbuffer)).ok()
2274     }
2275     #[cfg(not(windows))]
2276     unimplemented!("Unsupported target OS");
2277 }
2278 #[cfg(feature = "Win32_Foundation")]
2279 #[inline]
BCryptSecretAgreement<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>, Param1: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hprivkey: Param0, hpubkey: Param1, phagreedsecret: *mut *mut ::std::ffi::c_void, dwflags: u32) -> ::windows::runtime::Result<()>2280 pub unsafe fn BCryptSecretAgreement<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>, Param1: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hprivkey: Param0, hpubkey: Param1, phagreedsecret: *mut *mut ::std::ffi::c_void, dwflags: u32) -> ::windows::runtime::Result<()> {
2281     #[cfg(windows)]
2282     {
2283         #[link(name = "windows")]
2284         extern "system" {
2285             fn BCryptSecretAgreement(hprivkey: BCRYPT_KEY_HANDLE, hpubkey: BCRYPT_KEY_HANDLE, phagreedsecret: *mut *mut ::std::ffi::c_void, dwflags: u32) -> super::super::Foundation::NTSTATUS;
2286         }
2287         BCryptSecretAgreement(hprivkey.into_param().abi(), hpubkey.into_param().abi(), ::std::mem::transmute(phagreedsecret), ::std::mem::transmute(dwflags)).ok()
2288     }
2289     #[cfg(not(windows))]
2290     unimplemented!("Unsupported target OS");
2291 }
2292 #[cfg(feature = "Win32_Foundation")]
2293 #[inline]
BCryptSetContextFunctionProperty<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, dwinterface: BCRYPT_INTERFACE, pszfunction: Param3, pszproperty: Param4, cbvalue: u32, pbvalue: *const u8) -> ::windows::runtime::Result<()>2294 pub unsafe fn BCryptSetContextFunctionProperty<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwtable: BCRYPT_TABLE, pszcontext: Param1, dwinterface: BCRYPT_INTERFACE, pszfunction: Param3, pszproperty: Param4, cbvalue: u32, pbvalue: *const u8) -> ::windows::runtime::Result<()> {
2295     #[cfg(windows)]
2296     {
2297         #[link(name = "windows")]
2298         extern "system" {
2299             fn BCryptSetContextFunctionProperty(dwtable: BCRYPT_TABLE, pszcontext: super::super::Foundation::PWSTR, dwinterface: BCRYPT_INTERFACE, pszfunction: super::super::Foundation::PWSTR, pszproperty: super::super::Foundation::PWSTR, cbvalue: u32, pbvalue: *const u8) -> super::super::Foundation::NTSTATUS;
2300         }
2301         BCryptSetContextFunctionProperty(::std::mem::transmute(dwtable), pszcontext.into_param().abi(), ::std::mem::transmute(dwinterface), pszfunction.into_param().abi(), pszproperty.into_param().abi(), ::std::mem::transmute(cbvalue), ::std::mem::transmute(pbvalue)).ok()
2302     }
2303     #[cfg(not(windows))]
2304     unimplemented!("Unsupported target OS");
2305 }
2306 #[cfg(feature = "Win32_Foundation")]
2307 #[inline]
BCryptSetProperty<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hobject: *mut ::std::ffi::c_void, pszproperty: Param1, pbinput: *const u8, cbinput: u32, dwflags: u32) -> ::windows::runtime::Result<()>2308 pub unsafe fn BCryptSetProperty<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hobject: *mut ::std::ffi::c_void, pszproperty: Param1, pbinput: *const u8, cbinput: u32, dwflags: u32) -> ::windows::runtime::Result<()> {
2309     #[cfg(windows)]
2310     {
2311         #[link(name = "windows")]
2312         extern "system" {
2313             fn BCryptSetProperty(hobject: *mut ::std::ffi::c_void, pszproperty: super::super::Foundation::PWSTR, pbinput: *const u8, cbinput: u32, dwflags: u32) -> super::super::Foundation::NTSTATUS;
2314         }
2315         BCryptSetProperty(::std::mem::transmute(hobject), pszproperty.into_param().abi(), ::std::mem::transmute(pbinput), ::std::mem::transmute(cbinput), ::std::mem::transmute(dwflags)).ok()
2316     }
2317     #[cfg(not(windows))]
2318     unimplemented!("Unsupported target OS");
2319 }
2320 #[cfg(feature = "Win32_Foundation")]
2321 #[inline]
BCryptSignHash<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hkey: Param0, ppaddinginfo: *const ::std::ffi::c_void, pbinput: *const u8, cbinput: u32, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> ::windows::runtime::Result<()>2322 pub unsafe fn BCryptSignHash<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hkey: Param0, ppaddinginfo: *const ::std::ffi::c_void, pbinput: *const u8, cbinput: u32, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> ::windows::runtime::Result<()> {
2323     #[cfg(windows)]
2324     {
2325         #[link(name = "windows")]
2326         extern "system" {
2327             fn BCryptSignHash(hkey: BCRYPT_KEY_HANDLE, ppaddinginfo: *const ::std::ffi::c_void, pbinput: *const u8, cbinput: u32, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> super::super::Foundation::NTSTATUS;
2328         }
2329         BCryptSignHash(hkey.into_param().abi(), ::std::mem::transmute(ppaddinginfo), ::std::mem::transmute(pbinput), ::std::mem::transmute(cbinput), ::std::mem::transmute(pboutput), ::std::mem::transmute(cboutput), ::std::mem::transmute(pcbresult), ::std::mem::transmute(dwflags)).ok()
2330     }
2331     #[cfg(not(windows))]
2332     unimplemented!("Unsupported target OS");
2333 }
2334 #[cfg(feature = "Win32_Foundation")]
2335 #[inline]
BCryptUnregisterConfigChangeNotify<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hevent: Param0) -> ::windows::runtime::Result<()>2336 pub unsafe fn BCryptUnregisterConfigChangeNotify<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hevent: Param0) -> ::windows::runtime::Result<()> {
2337     #[cfg(windows)]
2338     {
2339         #[link(name = "windows")]
2340         extern "system" {
2341             fn BCryptUnregisterConfigChangeNotify(hevent: super::super::Foundation::HANDLE) -> super::super::Foundation::NTSTATUS;
2342         }
2343         BCryptUnregisterConfigChangeNotify(hevent.into_param().abi()).ok()
2344     }
2345     #[cfg(not(windows))]
2346     unimplemented!("Unsupported target OS");
2347 }
2348 #[cfg(feature = "Win32_Foundation")]
2349 #[inline]
BCryptVerifySignature<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hkey: Param0, ppaddinginfo: *const ::std::ffi::c_void, pbhash: *const u8, cbhash: u32, pbsignature: *const u8, cbsignature: u32, dwflags: NCRYPT_FLAGS) -> ::windows::runtime::Result<()>2350 pub unsafe fn BCryptVerifySignature<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hkey: Param0, ppaddinginfo: *const ::std::ffi::c_void, pbhash: *const u8, cbhash: u32, pbsignature: *const u8, cbsignature: u32, dwflags: NCRYPT_FLAGS) -> ::windows::runtime::Result<()> {
2351     #[cfg(windows)]
2352     {
2353         #[link(name = "windows")]
2354         extern "system" {
2355             fn BCryptVerifySignature(hkey: BCRYPT_KEY_HANDLE, ppaddinginfo: *const ::std::ffi::c_void, pbhash: *const u8, cbhash: u32, pbsignature: *const u8, cbsignature: u32, dwflags: NCRYPT_FLAGS) -> super::super::Foundation::NTSTATUS;
2356         }
2357         BCryptVerifySignature(hkey.into_param().abi(), ::std::mem::transmute(ppaddinginfo), ::std::mem::transmute(pbhash), ::std::mem::transmute(cbhash), ::std::mem::transmute(pbsignature), ::std::mem::transmute(cbsignature), ::std::mem::transmute(dwflags)).ok()
2358     }
2359     #[cfg(not(windows))]
2360     unimplemented!("Unsupported target OS");
2361 }
2362 pub const CALG_OID_INFO_CNG_ONLY: u32 = 4294967295u32;
2363 pub const CALG_OID_INFO_PARAMETERS: u32 = 4294967294u32;
2364 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2365 #[repr(transparent)]
2366 pub struct CASetupProperty(pub i32);
2367 pub const ENUM_SETUPPROP_INVALID: CASetupProperty = CASetupProperty(-1i32);
2368 pub const ENUM_SETUPPROP_CATYPE: CASetupProperty = CASetupProperty(0i32);
2369 pub const ENUM_SETUPPROP_CAKEYINFORMATION: CASetupProperty = CASetupProperty(1i32);
2370 pub const ENUM_SETUPPROP_INTERACTIVE: CASetupProperty = CASetupProperty(2i32);
2371 pub const ENUM_SETUPPROP_CANAME: CASetupProperty = CASetupProperty(3i32);
2372 pub const ENUM_SETUPPROP_CADSSUFFIX: CASetupProperty = CASetupProperty(4i32);
2373 pub const ENUM_SETUPPROP_VALIDITYPERIOD: CASetupProperty = CASetupProperty(5i32);
2374 pub const ENUM_SETUPPROP_VALIDITYPERIODUNIT: CASetupProperty = CASetupProperty(6i32);
2375 pub const ENUM_SETUPPROP_EXPIRATIONDATE: CASetupProperty = CASetupProperty(7i32);
2376 pub const ENUM_SETUPPROP_PRESERVEDATABASE: CASetupProperty = CASetupProperty(8i32);
2377 pub const ENUM_SETUPPROP_DATABASEDIRECTORY: CASetupProperty = CASetupProperty(9i32);
2378 pub const ENUM_SETUPPROP_LOGDIRECTORY: CASetupProperty = CASetupProperty(10i32);
2379 pub const ENUM_SETUPPROP_SHAREDFOLDER: CASetupProperty = CASetupProperty(11i32);
2380 pub const ENUM_SETUPPROP_PARENTCAMACHINE: CASetupProperty = CASetupProperty(12i32);
2381 pub const ENUM_SETUPPROP_PARENTCANAME: CASetupProperty = CASetupProperty(13i32);
2382 pub const ENUM_SETUPPROP_REQUESTFILE: CASetupProperty = CASetupProperty(14i32);
2383 pub const ENUM_SETUPPROP_WEBCAMACHINE: CASetupProperty = CASetupProperty(15i32);
2384 pub const ENUM_SETUPPROP_WEBCANAME: CASetupProperty = CASetupProperty(16i32);
2385 impl ::std::convert::From<i32> for CASetupProperty {
from(value: i32) -> Self2386     fn from(value: i32) -> Self {
2387         Self(value)
2388     }
2389 }
2390 unsafe impl ::windows::runtime::Abi for CASetupProperty {
2391     type Abi = Self;
2392     type DefaultType = Self;
2393 }
2394 pub const CCertSrvSetup: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2518620175, 62812, 16701, [169, 179, 125, 42, 244, 216, 228, 47]);
2395 pub const CCertSrvSetupKeyInformation: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(943143174, 21555, 17971, [176, 251, 41, 183, 231, 130, 98, 225]);
2396 pub const CCertificateEnrollmentPolicyServerSetup: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2950887986, 16817, 17821, [165, 222, 73, 173, 216, 167, 33, 130]);
2397 pub const CCertificateEnrollmentServerSetup: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2567107516, 34991, 19704, [174, 98, 113, 64, 83, 21, 82, 182]);
2398 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2399 #[repr(transparent)]
2400 pub struct CEPSetupProperty(pub i32);
2401 pub const ENUM_CEPSETUPPROP_AUTHENTICATION: CEPSetupProperty = CEPSetupProperty(0i32);
2402 pub const ENUM_CEPSETUPPROP_SSLCERTHASH: CEPSetupProperty = CEPSetupProperty(1i32);
2403 pub const ENUM_CEPSETUPPROP_URL: CEPSetupProperty = CEPSetupProperty(2i32);
2404 pub const ENUM_CEPSETUPPROP_KEYBASED_RENEWAL: CEPSetupProperty = CEPSetupProperty(3i32);
2405 impl ::std::convert::From<i32> for CEPSetupProperty {
from(value: i32) -> Self2406     fn from(value: i32) -> Self {
2407         Self(value)
2408     }
2409 }
2410 unsafe impl ::windows::runtime::Abi for CEPSetupProperty {
2411     type Abi = Self;
2412     type DefaultType = Self;
2413 }
2414 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2415 #[repr(C)]
2416 pub struct CERTIFICATE_CHAIN_BLOB {
2417     pub certCount: u32,
2418     pub rawCertificates: *mut CRYPTOAPI_BLOB,
2419 }
2420 impl CERTIFICATE_CHAIN_BLOB {}
2421 impl ::std::default::Default for CERTIFICATE_CHAIN_BLOB {
default() -> Self2422     fn default() -> Self {
2423         unsafe { ::std::mem::zeroed() }
2424     }
2425 }
2426 impl ::std::fmt::Debug for CERTIFICATE_CHAIN_BLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2427     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2428         fmt.debug_struct("CERTIFICATE_CHAIN_BLOB").field("certCount", &self.certCount).field("rawCertificates", &self.rawCertificates).finish()
2429     }
2430 }
2431 impl ::std::cmp::PartialEq for CERTIFICATE_CHAIN_BLOB {
eq(&self, other: &Self) -> bool2432     fn eq(&self, other: &Self) -> bool {
2433         self.certCount == other.certCount && self.rawCertificates == other.rawCertificates
2434     }
2435 }
2436 impl ::std::cmp::Eq for CERTIFICATE_CHAIN_BLOB {}
2437 unsafe impl ::windows::runtime::Abi for CERTIFICATE_CHAIN_BLOB {
2438     type Abi = Self;
2439     type DefaultType = Self;
2440 }
2441 pub const CERTVIEW_CRYPTUI_LPARAM: u32 = 8388608u32;
2442 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2443 #[repr(C)]
2444 #[cfg(feature = "Win32_Foundation")]
2445 pub struct CERT_ACCESS_DESCRIPTION {
2446     pub pszAccessMethod: super::super::Foundation::PSTR,
2447     pub AccessLocation: CERT_ALT_NAME_ENTRY,
2448 }
2449 #[cfg(feature = "Win32_Foundation")]
2450 impl CERT_ACCESS_DESCRIPTION {}
2451 #[cfg(feature = "Win32_Foundation")]
2452 impl ::std::default::Default for CERT_ACCESS_DESCRIPTION {
default() -> Self2453     fn default() -> Self {
2454         unsafe { ::std::mem::zeroed() }
2455     }
2456 }
2457 #[cfg(feature = "Win32_Foundation")]
2458 impl ::std::cmp::PartialEq for CERT_ACCESS_DESCRIPTION {
eq(&self, _other: &Self) -> bool2459     fn eq(&self, _other: &Self) -> bool {
2460         unimplemented!()
2461     }
2462 }
2463 #[cfg(feature = "Win32_Foundation")]
2464 impl ::std::cmp::Eq for CERT_ACCESS_DESCRIPTION {}
2465 #[cfg(feature = "Win32_Foundation")]
2466 unsafe impl ::windows::runtime::Abi for CERT_ACCESS_DESCRIPTION {
2467     type Abi = Self;
2468     type DefaultType = Self;
2469 }
2470 pub const CERT_ACCESS_STATE_GP_SYSTEM_STORE_FLAG: u32 = 8u32;
2471 pub const CERT_ACCESS_STATE_LM_SYSTEM_STORE_FLAG: u32 = 4u32;
2472 pub const CERT_ACCESS_STATE_PROP_ID: u32 = 14u32;
2473 pub const CERT_ACCESS_STATE_SHARED_USER_FLAG: u32 = 16u32;
2474 pub const CERT_ACCESS_STATE_SYSTEM_STORE_FLAG: u32 = 2u32;
2475 pub const CERT_ACCESS_STATE_WRITE_PERSIST_FLAG: u32 = 1u32;
2476 pub const CERT_AIA_URL_RETRIEVED_PROP_ID: u32 = 67u32;
2477 pub const CERT_ALT_NAME_EDI_PARTY_NAME: u32 = 6u32;
2478 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2479 #[repr(C)]
2480 #[cfg(feature = "Win32_Foundation")]
2481 pub struct CERT_ALT_NAME_ENTRY {
2482     pub dwAltNameChoice: u32,
2483     pub Anonymous: CERT_ALT_NAME_ENTRY_0,
2484 }
2485 #[cfg(feature = "Win32_Foundation")]
2486 impl CERT_ALT_NAME_ENTRY {}
2487 #[cfg(feature = "Win32_Foundation")]
2488 impl ::std::default::Default for CERT_ALT_NAME_ENTRY {
default() -> Self2489     fn default() -> Self {
2490         unsafe { ::std::mem::zeroed() }
2491     }
2492 }
2493 #[cfg(feature = "Win32_Foundation")]
2494 impl ::std::cmp::PartialEq for CERT_ALT_NAME_ENTRY {
eq(&self, _other: &Self) -> bool2495     fn eq(&self, _other: &Self) -> bool {
2496         unimplemented!()
2497     }
2498 }
2499 #[cfg(feature = "Win32_Foundation")]
2500 impl ::std::cmp::Eq for CERT_ALT_NAME_ENTRY {}
2501 #[cfg(feature = "Win32_Foundation")]
2502 unsafe impl ::windows::runtime::Abi for CERT_ALT_NAME_ENTRY {
2503     type Abi = Self;
2504     type DefaultType = Self;
2505 }
2506 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2507 #[repr(C)]
2508 #[cfg(feature = "Win32_Foundation")]
2509 pub union CERT_ALT_NAME_ENTRY_0 {
2510     pub pOtherName: *mut CERT_OTHER_NAME,
2511     pub pwszRfc822Name: super::super::Foundation::PWSTR,
2512     pub pwszDNSName: super::super::Foundation::PWSTR,
2513     pub DirectoryName: CRYPTOAPI_BLOB,
2514     pub pwszURL: super::super::Foundation::PWSTR,
2515     pub IPAddress: CRYPTOAPI_BLOB,
2516     pub pszRegisteredID: super::super::Foundation::PSTR,
2517 }
2518 #[cfg(feature = "Win32_Foundation")]
2519 impl CERT_ALT_NAME_ENTRY_0 {}
2520 #[cfg(feature = "Win32_Foundation")]
2521 impl ::std::default::Default for CERT_ALT_NAME_ENTRY_0 {
default() -> Self2522     fn default() -> Self {
2523         unsafe { ::std::mem::zeroed() }
2524     }
2525 }
2526 #[cfg(feature = "Win32_Foundation")]
2527 impl ::std::cmp::PartialEq for CERT_ALT_NAME_ENTRY_0 {
eq(&self, _other: &Self) -> bool2528     fn eq(&self, _other: &Self) -> bool {
2529         unimplemented!()
2530     }
2531 }
2532 #[cfg(feature = "Win32_Foundation")]
2533 impl ::std::cmp::Eq for CERT_ALT_NAME_ENTRY_0 {}
2534 #[cfg(feature = "Win32_Foundation")]
2535 unsafe impl ::windows::runtime::Abi for CERT_ALT_NAME_ENTRY_0 {
2536     type Abi = Self;
2537     type DefaultType = Self;
2538 }
2539 pub const CERT_ALT_NAME_ENTRY_ERR_INDEX_MASK: u32 = 255u32;
2540 pub const CERT_ALT_NAME_ENTRY_ERR_INDEX_SHIFT: u32 = 16u32;
2541 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2542 #[repr(C)]
2543 #[cfg(feature = "Win32_Foundation")]
2544 pub struct CERT_ALT_NAME_INFO {
2545     pub cAltEntry: u32,
2546     pub rgAltEntry: *mut CERT_ALT_NAME_ENTRY,
2547 }
2548 #[cfg(feature = "Win32_Foundation")]
2549 impl CERT_ALT_NAME_INFO {}
2550 #[cfg(feature = "Win32_Foundation")]
2551 impl ::std::default::Default for CERT_ALT_NAME_INFO {
default() -> Self2552     fn default() -> Self {
2553         unsafe { ::std::mem::zeroed() }
2554     }
2555 }
2556 #[cfg(feature = "Win32_Foundation")]
2557 impl ::std::fmt::Debug for CERT_ALT_NAME_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2558     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2559         fmt.debug_struct("CERT_ALT_NAME_INFO").field("cAltEntry", &self.cAltEntry).field("rgAltEntry", &self.rgAltEntry).finish()
2560     }
2561 }
2562 #[cfg(feature = "Win32_Foundation")]
2563 impl ::std::cmp::PartialEq for CERT_ALT_NAME_INFO {
eq(&self, other: &Self) -> bool2564     fn eq(&self, other: &Self) -> bool {
2565         self.cAltEntry == other.cAltEntry && self.rgAltEntry == other.rgAltEntry
2566     }
2567 }
2568 #[cfg(feature = "Win32_Foundation")]
2569 impl ::std::cmp::Eq for CERT_ALT_NAME_INFO {}
2570 #[cfg(feature = "Win32_Foundation")]
2571 unsafe impl ::windows::runtime::Abi for CERT_ALT_NAME_INFO {
2572     type Abi = Self;
2573     type DefaultType = Self;
2574 }
2575 pub const CERT_ALT_NAME_VALUE_ERR_INDEX_MASK: u32 = 65535u32;
2576 pub const CERT_ALT_NAME_VALUE_ERR_INDEX_SHIFT: u32 = 0u32;
2577 pub const CERT_ALT_NAME_X400_ADDRESS: u32 = 4u32;
2578 pub const CERT_ARCHIVED_KEY_HASH_PROP_ID: u32 = 65u32;
2579 pub const CERT_ARCHIVED_PROP_ID: u32 = 19u32;
2580 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2581 #[repr(C)]
2582 #[cfg(feature = "Win32_Foundation")]
2583 pub struct CERT_AUTHORITY_INFO_ACCESS {
2584     pub cAccDescr: u32,
2585     pub rgAccDescr: *mut CERT_ACCESS_DESCRIPTION,
2586 }
2587 #[cfg(feature = "Win32_Foundation")]
2588 impl CERT_AUTHORITY_INFO_ACCESS {}
2589 #[cfg(feature = "Win32_Foundation")]
2590 impl ::std::default::Default for CERT_AUTHORITY_INFO_ACCESS {
default() -> Self2591     fn default() -> Self {
2592         unsafe { ::std::mem::zeroed() }
2593     }
2594 }
2595 #[cfg(feature = "Win32_Foundation")]
2596 impl ::std::fmt::Debug for CERT_AUTHORITY_INFO_ACCESS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2597     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2598         fmt.debug_struct("CERT_AUTHORITY_INFO_ACCESS").field("cAccDescr", &self.cAccDescr).field("rgAccDescr", &self.rgAccDescr).finish()
2599     }
2600 }
2601 #[cfg(feature = "Win32_Foundation")]
2602 impl ::std::cmp::PartialEq for CERT_AUTHORITY_INFO_ACCESS {
eq(&self, other: &Self) -> bool2603     fn eq(&self, other: &Self) -> bool {
2604         self.cAccDescr == other.cAccDescr && self.rgAccDescr == other.rgAccDescr
2605     }
2606 }
2607 #[cfg(feature = "Win32_Foundation")]
2608 impl ::std::cmp::Eq for CERT_AUTHORITY_INFO_ACCESS {}
2609 #[cfg(feature = "Win32_Foundation")]
2610 unsafe impl ::windows::runtime::Abi for CERT_AUTHORITY_INFO_ACCESS {
2611     type Abi = Self;
2612     type DefaultType = Self;
2613 }
2614 pub const CERT_AUTHORITY_INFO_ACCESS_PROP_ID: u32 = 68u32;
2615 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2616 #[repr(C)]
2617 #[cfg(feature = "Win32_Foundation")]
2618 pub struct CERT_AUTHORITY_KEY_ID2_INFO {
2619     pub KeyId: CRYPTOAPI_BLOB,
2620     pub AuthorityCertIssuer: CERT_ALT_NAME_INFO,
2621     pub AuthorityCertSerialNumber: CRYPTOAPI_BLOB,
2622 }
2623 #[cfg(feature = "Win32_Foundation")]
2624 impl CERT_AUTHORITY_KEY_ID2_INFO {}
2625 #[cfg(feature = "Win32_Foundation")]
2626 impl ::std::default::Default for CERT_AUTHORITY_KEY_ID2_INFO {
default() -> Self2627     fn default() -> Self {
2628         unsafe { ::std::mem::zeroed() }
2629     }
2630 }
2631 #[cfg(feature = "Win32_Foundation")]
2632 impl ::std::fmt::Debug for CERT_AUTHORITY_KEY_ID2_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2633     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2634         fmt.debug_struct("CERT_AUTHORITY_KEY_ID2_INFO").field("KeyId", &self.KeyId).field("AuthorityCertIssuer", &self.AuthorityCertIssuer).field("AuthorityCertSerialNumber", &self.AuthorityCertSerialNumber).finish()
2635     }
2636 }
2637 #[cfg(feature = "Win32_Foundation")]
2638 impl ::std::cmp::PartialEq for CERT_AUTHORITY_KEY_ID2_INFO {
eq(&self, other: &Self) -> bool2639     fn eq(&self, other: &Self) -> bool {
2640         self.KeyId == other.KeyId && self.AuthorityCertIssuer == other.AuthorityCertIssuer && self.AuthorityCertSerialNumber == other.AuthorityCertSerialNumber
2641     }
2642 }
2643 #[cfg(feature = "Win32_Foundation")]
2644 impl ::std::cmp::Eq for CERT_AUTHORITY_KEY_ID2_INFO {}
2645 #[cfg(feature = "Win32_Foundation")]
2646 unsafe impl ::windows::runtime::Abi for CERT_AUTHORITY_KEY_ID2_INFO {
2647     type Abi = Self;
2648     type DefaultType = Self;
2649 }
2650 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2651 #[repr(C)]
2652 pub struct CERT_AUTHORITY_KEY_ID_INFO {
2653     pub KeyId: CRYPTOAPI_BLOB,
2654     pub CertIssuer: CRYPTOAPI_BLOB,
2655     pub CertSerialNumber: CRYPTOAPI_BLOB,
2656 }
2657 impl CERT_AUTHORITY_KEY_ID_INFO {}
2658 impl ::std::default::Default for CERT_AUTHORITY_KEY_ID_INFO {
default() -> Self2659     fn default() -> Self {
2660         unsafe { ::std::mem::zeroed() }
2661     }
2662 }
2663 impl ::std::fmt::Debug for CERT_AUTHORITY_KEY_ID_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2664     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2665         fmt.debug_struct("CERT_AUTHORITY_KEY_ID_INFO").field("KeyId", &self.KeyId).field("CertIssuer", &self.CertIssuer).field("CertSerialNumber", &self.CertSerialNumber).finish()
2666     }
2667 }
2668 impl ::std::cmp::PartialEq for CERT_AUTHORITY_KEY_ID_INFO {
eq(&self, other: &Self) -> bool2669     fn eq(&self, other: &Self) -> bool {
2670         self.KeyId == other.KeyId && self.CertIssuer == other.CertIssuer && self.CertSerialNumber == other.CertSerialNumber
2671     }
2672 }
2673 impl ::std::cmp::Eq for CERT_AUTHORITY_KEY_ID_INFO {}
2674 unsafe impl ::windows::runtime::Abi for CERT_AUTHORITY_KEY_ID_INFO {
2675     type Abi = Self;
2676     type DefaultType = Self;
2677 }
2678 pub const CERT_AUTH_ROOT_AUTO_UPDATE_DISABLE_PARTIAL_CHAIN_LOGGING_FLAG: u32 = 2u32;
2679 pub const CERT_AUTH_ROOT_AUTO_UPDATE_DISABLE_UNTRUSTED_ROOT_LOGGING_FLAG: u32 = 1u32;
2680 pub const CERT_AUTH_ROOT_SHA256_HASH_PROP_ID: u32 = 98u32;
2681 pub const CERT_AUTO_ENROLL_PROP_ID: u32 = 21u32;
2682 pub const CERT_AUTO_ENROLL_RETRY_PROP_ID: u32 = 66u32;
2683 pub const CERT_AUTO_UPDATE_DISABLE_RANDOM_QUERY_STRING_FLAG: u32 = 4u32;
2684 pub const CERT_BACKED_UP_PROP_ID: u32 = 69u32;
2685 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2686 #[repr(C)]
2687 #[cfg(feature = "Win32_Foundation")]
2688 pub struct CERT_BASIC_CONSTRAINTS2_INFO {
2689     pub fCA: super::super::Foundation::BOOL,
2690     pub fPathLenConstraint: super::super::Foundation::BOOL,
2691     pub dwPathLenConstraint: u32,
2692 }
2693 #[cfg(feature = "Win32_Foundation")]
2694 impl CERT_BASIC_CONSTRAINTS2_INFO {}
2695 #[cfg(feature = "Win32_Foundation")]
2696 impl ::std::default::Default for CERT_BASIC_CONSTRAINTS2_INFO {
default() -> Self2697     fn default() -> Self {
2698         unsafe { ::std::mem::zeroed() }
2699     }
2700 }
2701 #[cfg(feature = "Win32_Foundation")]
2702 impl ::std::fmt::Debug for CERT_BASIC_CONSTRAINTS2_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2703     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2704         fmt.debug_struct("CERT_BASIC_CONSTRAINTS2_INFO").field("fCA", &self.fCA).field("fPathLenConstraint", &self.fPathLenConstraint).field("dwPathLenConstraint", &self.dwPathLenConstraint).finish()
2705     }
2706 }
2707 #[cfg(feature = "Win32_Foundation")]
2708 impl ::std::cmp::PartialEq for CERT_BASIC_CONSTRAINTS2_INFO {
eq(&self, other: &Self) -> bool2709     fn eq(&self, other: &Self) -> bool {
2710         self.fCA == other.fCA && self.fPathLenConstraint == other.fPathLenConstraint && self.dwPathLenConstraint == other.dwPathLenConstraint
2711     }
2712 }
2713 #[cfg(feature = "Win32_Foundation")]
2714 impl ::std::cmp::Eq for CERT_BASIC_CONSTRAINTS2_INFO {}
2715 #[cfg(feature = "Win32_Foundation")]
2716 unsafe impl ::windows::runtime::Abi for CERT_BASIC_CONSTRAINTS2_INFO {
2717     type Abi = Self;
2718     type DefaultType = Self;
2719 }
2720 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2721 #[repr(C)]
2722 #[cfg(feature = "Win32_Foundation")]
2723 pub struct CERT_BASIC_CONSTRAINTS_INFO {
2724     pub SubjectType: CRYPT_BIT_BLOB,
2725     pub fPathLenConstraint: super::super::Foundation::BOOL,
2726     pub dwPathLenConstraint: u32,
2727     pub cSubtreesConstraint: u32,
2728     pub rgSubtreesConstraint: *mut CRYPTOAPI_BLOB,
2729 }
2730 #[cfg(feature = "Win32_Foundation")]
2731 impl CERT_BASIC_CONSTRAINTS_INFO {}
2732 #[cfg(feature = "Win32_Foundation")]
2733 impl ::std::default::Default for CERT_BASIC_CONSTRAINTS_INFO {
default() -> Self2734     fn default() -> Self {
2735         unsafe { ::std::mem::zeroed() }
2736     }
2737 }
2738 #[cfg(feature = "Win32_Foundation")]
2739 impl ::std::fmt::Debug for CERT_BASIC_CONSTRAINTS_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2740     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2741         fmt.debug_struct("CERT_BASIC_CONSTRAINTS_INFO")
2742             .field("SubjectType", &self.SubjectType)
2743             .field("fPathLenConstraint", &self.fPathLenConstraint)
2744             .field("dwPathLenConstraint", &self.dwPathLenConstraint)
2745             .field("cSubtreesConstraint", &self.cSubtreesConstraint)
2746             .field("rgSubtreesConstraint", &self.rgSubtreesConstraint)
2747             .finish()
2748     }
2749 }
2750 #[cfg(feature = "Win32_Foundation")]
2751 impl ::std::cmp::PartialEq for CERT_BASIC_CONSTRAINTS_INFO {
eq(&self, other: &Self) -> bool2752     fn eq(&self, other: &Self) -> bool {
2753         self.SubjectType == other.SubjectType && self.fPathLenConstraint == other.fPathLenConstraint && self.dwPathLenConstraint == other.dwPathLenConstraint && self.cSubtreesConstraint == other.cSubtreesConstraint && self.rgSubtreesConstraint == other.rgSubtreesConstraint
2754     }
2755 }
2756 #[cfg(feature = "Win32_Foundation")]
2757 impl ::std::cmp::Eq for CERT_BASIC_CONSTRAINTS_INFO {}
2758 #[cfg(feature = "Win32_Foundation")]
2759 unsafe impl ::windows::runtime::Abi for CERT_BASIC_CONSTRAINTS_INFO {
2760     type Abi = Self;
2761     type DefaultType = Self;
2762 }
2763 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2764 #[repr(C)]
2765 #[cfg(feature = "Win32_Foundation")]
2766 pub struct CERT_BIOMETRIC_DATA {
2767     pub dwTypeOfBiometricDataChoice: CERT_BIOMETRIC_DATA_TYPE,
2768     pub Anonymous: CERT_BIOMETRIC_DATA_0,
2769     pub HashedUrl: CERT_HASHED_URL,
2770 }
2771 #[cfg(feature = "Win32_Foundation")]
2772 impl CERT_BIOMETRIC_DATA {}
2773 #[cfg(feature = "Win32_Foundation")]
2774 impl ::std::default::Default for CERT_BIOMETRIC_DATA {
default() -> Self2775     fn default() -> Self {
2776         unsafe { ::std::mem::zeroed() }
2777     }
2778 }
2779 #[cfg(feature = "Win32_Foundation")]
2780 impl ::std::cmp::PartialEq for CERT_BIOMETRIC_DATA {
eq(&self, _other: &Self) -> bool2781     fn eq(&self, _other: &Self) -> bool {
2782         unimplemented!()
2783     }
2784 }
2785 #[cfg(feature = "Win32_Foundation")]
2786 impl ::std::cmp::Eq for CERT_BIOMETRIC_DATA {}
2787 #[cfg(feature = "Win32_Foundation")]
2788 unsafe impl ::windows::runtime::Abi for CERT_BIOMETRIC_DATA {
2789     type Abi = Self;
2790     type DefaultType = Self;
2791 }
2792 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2793 #[repr(C)]
2794 #[cfg(feature = "Win32_Foundation")]
2795 pub union CERT_BIOMETRIC_DATA_0 {
2796     pub dwPredefined: u32,
2797     pub pszObjId: super::super::Foundation::PSTR,
2798 }
2799 #[cfg(feature = "Win32_Foundation")]
2800 impl CERT_BIOMETRIC_DATA_0 {}
2801 #[cfg(feature = "Win32_Foundation")]
2802 impl ::std::default::Default for CERT_BIOMETRIC_DATA_0 {
default() -> Self2803     fn default() -> Self {
2804         unsafe { ::std::mem::zeroed() }
2805     }
2806 }
2807 #[cfg(feature = "Win32_Foundation")]
2808 impl ::std::cmp::PartialEq for CERT_BIOMETRIC_DATA_0 {
eq(&self, _other: &Self) -> bool2809     fn eq(&self, _other: &Self) -> bool {
2810         unimplemented!()
2811     }
2812 }
2813 #[cfg(feature = "Win32_Foundation")]
2814 impl ::std::cmp::Eq for CERT_BIOMETRIC_DATA_0 {}
2815 #[cfg(feature = "Win32_Foundation")]
2816 unsafe impl ::windows::runtime::Abi for CERT_BIOMETRIC_DATA_0 {
2817     type Abi = Self;
2818     type DefaultType = Self;
2819 }
2820 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2821 #[repr(transparent)]
2822 pub struct CERT_BIOMETRIC_DATA_TYPE(pub u32);
2823 pub const CERT_BIOMETRIC_PREDEFINED_DATA_CHOICE: CERT_BIOMETRIC_DATA_TYPE = CERT_BIOMETRIC_DATA_TYPE(1u32);
2824 pub const CERT_BIOMETRIC_OID_DATA_CHOICE: CERT_BIOMETRIC_DATA_TYPE = CERT_BIOMETRIC_DATA_TYPE(2u32);
2825 impl ::std::convert::From<u32> for CERT_BIOMETRIC_DATA_TYPE {
from(value: u32) -> Self2826     fn from(value: u32) -> Self {
2827         Self(value)
2828     }
2829 }
2830 unsafe impl ::windows::runtime::Abi for CERT_BIOMETRIC_DATA_TYPE {
2831     type Abi = Self;
2832     type DefaultType = Self;
2833 }
2834 impl ::std::ops::BitOr for CERT_BIOMETRIC_DATA_TYPE {
2835     type Output = Self;
bitor(self, rhs: Self) -> Self2836     fn bitor(self, rhs: Self) -> Self {
2837         Self(self.0 | rhs.0)
2838     }
2839 }
2840 impl ::std::ops::BitAnd for CERT_BIOMETRIC_DATA_TYPE {
2841     type Output = Self;
bitand(self, rhs: Self) -> Self2842     fn bitand(self, rhs: Self) -> Self {
2843         Self(self.0 & rhs.0)
2844     }
2845 }
2846 impl ::std::ops::BitOrAssign for CERT_BIOMETRIC_DATA_TYPE {
bitor_assign(&mut self, rhs: Self)2847     fn bitor_assign(&mut self, rhs: Self) {
2848         self.0.bitor_assign(rhs.0)
2849     }
2850 }
2851 impl ::std::ops::BitAndAssign for CERT_BIOMETRIC_DATA_TYPE {
bitand_assign(&mut self, rhs: Self)2852     fn bitand_assign(&mut self, rhs: Self) {
2853         self.0.bitand_assign(rhs.0)
2854     }
2855 }
2856 impl ::std::ops::Not for CERT_BIOMETRIC_DATA_TYPE {
2857     type Output = Self;
not(self) -> Self2858     fn not(self) -> Self {
2859         Self(self.0.not())
2860     }
2861 }
2862 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2863 #[repr(C)]
2864 #[cfg(feature = "Win32_Foundation")]
2865 pub struct CERT_BIOMETRIC_EXT_INFO {
2866     pub cBiometricData: u32,
2867     pub rgBiometricData: *mut CERT_BIOMETRIC_DATA,
2868 }
2869 #[cfg(feature = "Win32_Foundation")]
2870 impl CERT_BIOMETRIC_EXT_INFO {}
2871 #[cfg(feature = "Win32_Foundation")]
2872 impl ::std::default::Default for CERT_BIOMETRIC_EXT_INFO {
default() -> Self2873     fn default() -> Self {
2874         unsafe { ::std::mem::zeroed() }
2875     }
2876 }
2877 #[cfg(feature = "Win32_Foundation")]
2878 impl ::std::fmt::Debug for CERT_BIOMETRIC_EXT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2879     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2880         fmt.debug_struct("CERT_BIOMETRIC_EXT_INFO").field("cBiometricData", &self.cBiometricData).field("rgBiometricData", &self.rgBiometricData).finish()
2881     }
2882 }
2883 #[cfg(feature = "Win32_Foundation")]
2884 impl ::std::cmp::PartialEq for CERT_BIOMETRIC_EXT_INFO {
eq(&self, other: &Self) -> bool2885     fn eq(&self, other: &Self) -> bool {
2886         self.cBiometricData == other.cBiometricData && self.rgBiometricData == other.rgBiometricData
2887     }
2888 }
2889 #[cfg(feature = "Win32_Foundation")]
2890 impl ::std::cmp::Eq for CERT_BIOMETRIC_EXT_INFO {}
2891 #[cfg(feature = "Win32_Foundation")]
2892 unsafe impl ::windows::runtime::Abi for CERT_BIOMETRIC_EXT_INFO {
2893     type Abi = Self;
2894     type DefaultType = Self;
2895 }
2896 pub const CERT_BIOMETRIC_PICTURE_TYPE: u32 = 0u32;
2897 pub const CERT_BIOMETRIC_SIGNATURE_TYPE: u32 = 1u32;
2898 pub const CERT_BUNDLE_CERTIFICATE: u32 = 0u32;
2899 pub const CERT_BUNDLE_CRL: u32 = 1u32;
2900 pub const CERT_CASE_INSENSITIVE_IS_RDN_ATTRS_FLAG: u32 = 2u32;
2901 pub const CERT_CA_DISABLE_CRL_PROP_ID: u32 = 82u32;
2902 pub const CERT_CA_OCSP_AUTHORITY_INFO_ACCESS_PROP_ID: u32 = 81u32;
2903 pub const CERT_CA_SUBJECT_FLAG: u32 = 128u32;
2904 pub const CERT_CEP_PROP_ID: u32 = 87u32;
2905 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2906 #[repr(C)]
2907 #[cfg(feature = "Win32_Foundation")]
2908 pub struct CERT_CHAIN {
2909     pub cCerts: u32,
2910     pub certs: *mut CRYPTOAPI_BLOB,
2911     pub keyLocatorInfo: CRYPT_KEY_PROV_INFO,
2912 }
2913 #[cfg(feature = "Win32_Foundation")]
2914 impl CERT_CHAIN {}
2915 #[cfg(feature = "Win32_Foundation")]
2916 impl ::std::default::Default for CERT_CHAIN {
default() -> Self2917     fn default() -> Self {
2918         unsafe { ::std::mem::zeroed() }
2919     }
2920 }
2921 #[cfg(feature = "Win32_Foundation")]
2922 impl ::std::fmt::Debug for CERT_CHAIN {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2923     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2924         fmt.debug_struct("CERT_CHAIN").field("cCerts", &self.cCerts).field("certs", &self.certs).field("keyLocatorInfo", &self.keyLocatorInfo).finish()
2925     }
2926 }
2927 #[cfg(feature = "Win32_Foundation")]
2928 impl ::std::cmp::PartialEq for CERT_CHAIN {
eq(&self, other: &Self) -> bool2929     fn eq(&self, other: &Self) -> bool {
2930         self.cCerts == other.cCerts && self.certs == other.certs && self.keyLocatorInfo == other.keyLocatorInfo
2931     }
2932 }
2933 #[cfg(feature = "Win32_Foundation")]
2934 impl ::std::cmp::Eq for CERT_CHAIN {}
2935 #[cfg(feature = "Win32_Foundation")]
2936 unsafe impl ::windows::runtime::Abi for CERT_CHAIN {
2937     type Abi = Self;
2938     type DefaultType = Self;
2939 }
2940 pub const CERT_CHAIN_AUTO_CURRENT_USER: u32 = 1u32;
2941 pub const CERT_CHAIN_AUTO_FLUSH_DISABLE_FLAG: u32 = 1u32;
2942 pub const CERT_CHAIN_AUTO_HPKP_RULE_INFO: u32 = 8u32;
2943 pub const CERT_CHAIN_AUTO_IMPERSONATED: u32 = 3u32;
2944 pub const CERT_CHAIN_AUTO_LOCAL_MACHINE: u32 = 2u32;
2945 pub const CERT_CHAIN_AUTO_LOG_CREATE_FLAG: u32 = 2u32;
2946 pub const CERT_CHAIN_AUTO_LOG_FLUSH_FLAG: u32 = 8u32;
2947 pub const CERT_CHAIN_AUTO_LOG_FREE_FLAG: u32 = 4u32;
2948 pub const CERT_CHAIN_AUTO_NETWORK_INFO: u32 = 6u32;
2949 pub const CERT_CHAIN_AUTO_PINRULE_INFO: u32 = 5u32;
2950 pub const CERT_CHAIN_AUTO_PROCESS_INFO: u32 = 4u32;
2951 pub const CERT_CHAIN_AUTO_SERIAL_LOCAL_MACHINE: u32 = 7u32;
2952 pub const CERT_CHAIN_CACHE_END_CERT: u32 = 1u32;
2953 pub const CERT_CHAIN_CACHE_ONLY_URL_RETRIEVAL: u32 = 4u32;
2954 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2955 #[repr(C)]
2956 #[cfg(feature = "Win32_Foundation")]
2957 pub struct CERT_CHAIN_CONTEXT {
2958     pub cbSize: u32,
2959     pub TrustStatus: CERT_TRUST_STATUS,
2960     pub cChain: u32,
2961     pub rgpChain: *mut *mut CERT_SIMPLE_CHAIN,
2962     pub cLowerQualityChainContext: u32,
2963     pub rgpLowerQualityChainContext: *mut *mut CERT_CHAIN_CONTEXT,
2964     pub fHasRevocationFreshnessTime: super::super::Foundation::BOOL,
2965     pub dwRevocationFreshnessTime: u32,
2966     pub dwCreateFlags: u32,
2967     pub ChainId: ::windows::runtime::GUID,
2968 }
2969 #[cfg(feature = "Win32_Foundation")]
2970 impl CERT_CHAIN_CONTEXT {}
2971 #[cfg(feature = "Win32_Foundation")]
2972 impl ::std::default::Default for CERT_CHAIN_CONTEXT {
default() -> Self2973     fn default() -> Self {
2974         unsafe { ::std::mem::zeroed() }
2975     }
2976 }
2977 #[cfg(feature = "Win32_Foundation")]
2978 impl ::std::fmt::Debug for CERT_CHAIN_CONTEXT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2979     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2980         fmt.debug_struct("CERT_CHAIN_CONTEXT")
2981             .field("cbSize", &self.cbSize)
2982             .field("TrustStatus", &self.TrustStatus)
2983             .field("cChain", &self.cChain)
2984             .field("rgpChain", &self.rgpChain)
2985             .field("cLowerQualityChainContext", &self.cLowerQualityChainContext)
2986             .field("rgpLowerQualityChainContext", &self.rgpLowerQualityChainContext)
2987             .field("fHasRevocationFreshnessTime", &self.fHasRevocationFreshnessTime)
2988             .field("dwRevocationFreshnessTime", &self.dwRevocationFreshnessTime)
2989             .field("dwCreateFlags", &self.dwCreateFlags)
2990             .field("ChainId", &self.ChainId)
2991             .finish()
2992     }
2993 }
2994 #[cfg(feature = "Win32_Foundation")]
2995 impl ::std::cmp::PartialEq for CERT_CHAIN_CONTEXT {
eq(&self, other: &Self) -> bool2996     fn eq(&self, other: &Self) -> bool {
2997         self.cbSize == other.cbSize
2998             && self.TrustStatus == other.TrustStatus
2999             && self.cChain == other.cChain
3000             && self.rgpChain == other.rgpChain
3001             && self.cLowerQualityChainContext == other.cLowerQualityChainContext
3002             && self.rgpLowerQualityChainContext == other.rgpLowerQualityChainContext
3003             && self.fHasRevocationFreshnessTime == other.fHasRevocationFreshnessTime
3004             && self.dwRevocationFreshnessTime == other.dwRevocationFreshnessTime
3005             && self.dwCreateFlags == other.dwCreateFlags
3006             && self.ChainId == other.ChainId
3007     }
3008 }
3009 #[cfg(feature = "Win32_Foundation")]
3010 impl ::std::cmp::Eq for CERT_CHAIN_CONTEXT {}
3011 #[cfg(feature = "Win32_Foundation")]
3012 unsafe impl ::windows::runtime::Abi for CERT_CHAIN_CONTEXT {
3013     type Abi = Self;
3014     type DefaultType = Self;
3015 }
3016 pub const CERT_CHAIN_CRL_VALIDITY_EXT_PERIOD_HOURS_DEFAULT: u32 = 12u32;
3017 pub const CERT_CHAIN_DISABLE_AIA: u32 = 8192u32;
3018 pub const CERT_CHAIN_DISABLE_ALL_EKU_WEAK_FLAG: u32 = 65536u32;
3019 pub const CERT_CHAIN_DISABLE_AUTH_ROOT_AUTO_UPDATE: u32 = 256u32;
3020 pub const CERT_CHAIN_DISABLE_CODE_SIGNING_WEAK_FLAG: u32 = 4194304u32;
3021 pub const CERT_CHAIN_DISABLE_ECC_PARA_FLAG: u32 = 16u32;
3022 pub const CERT_CHAIN_DISABLE_FILE_HASH_WEAK_FLAG: u32 = 4096u32;
3023 pub const CERT_CHAIN_DISABLE_MD2_MD4: u32 = 4096u32;
3024 pub const CERT_CHAIN_DISABLE_MOTW_CODE_SIGNING_WEAK_FLAG: u32 = 8388608u32;
3025 pub const CERT_CHAIN_DISABLE_MOTW_FILE_HASH_WEAK_FLAG: u32 = 8192u32;
3026 pub const CERT_CHAIN_DISABLE_MOTW_TIMESTAMP_HASH_WEAK_FLAG: u32 = 32768u32;
3027 pub const CERT_CHAIN_DISABLE_MOTW_TIMESTAMP_WEAK_FLAG: u32 = 134217728u32;
3028 pub const CERT_CHAIN_DISABLE_MY_PEER_TRUST: u32 = 2048u32;
3029 pub const CERT_CHAIN_DISABLE_OPT_IN_SERVER_AUTH_WEAK_FLAG: u32 = 262144u32;
3030 pub const CERT_CHAIN_DISABLE_PASS1_QUALITY_FILTERING: u32 = 64u32;
3031 pub const CERT_CHAIN_DISABLE_SERVER_AUTH_WEAK_FLAG: u32 = 1048576u32;
3032 pub const CERT_CHAIN_DISABLE_TIMESTAMP_HASH_WEAK_FLAG: u32 = 16384u32;
3033 pub const CERT_CHAIN_DISABLE_TIMESTAMP_WEAK_FLAG: u32 = 67108864u32;
3034 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3035 #[repr(C)]
3036 #[cfg(feature = "Win32_Foundation")]
3037 pub struct CERT_CHAIN_ELEMENT {
3038     pub cbSize: u32,
3039     pub pCertContext: *mut CERT_CONTEXT,
3040     pub TrustStatus: CERT_TRUST_STATUS,
3041     pub pRevocationInfo: *mut CERT_REVOCATION_INFO,
3042     pub pIssuanceUsage: *mut CTL_USAGE,
3043     pub pApplicationUsage: *mut CTL_USAGE,
3044     pub pwszExtendedErrorInfo: super::super::Foundation::PWSTR,
3045 }
3046 #[cfg(feature = "Win32_Foundation")]
3047 impl CERT_CHAIN_ELEMENT {}
3048 #[cfg(feature = "Win32_Foundation")]
3049 impl ::std::default::Default for CERT_CHAIN_ELEMENT {
default() -> Self3050     fn default() -> Self {
3051         unsafe { ::std::mem::zeroed() }
3052     }
3053 }
3054 #[cfg(feature = "Win32_Foundation")]
3055 impl ::std::fmt::Debug for CERT_CHAIN_ELEMENT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3056     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3057         fmt.debug_struct("CERT_CHAIN_ELEMENT")
3058             .field("cbSize", &self.cbSize)
3059             .field("pCertContext", &self.pCertContext)
3060             .field("TrustStatus", &self.TrustStatus)
3061             .field("pRevocationInfo", &self.pRevocationInfo)
3062             .field("pIssuanceUsage", &self.pIssuanceUsage)
3063             .field("pApplicationUsage", &self.pApplicationUsage)
3064             .field("pwszExtendedErrorInfo", &self.pwszExtendedErrorInfo)
3065             .finish()
3066     }
3067 }
3068 #[cfg(feature = "Win32_Foundation")]
3069 impl ::std::cmp::PartialEq for CERT_CHAIN_ELEMENT {
eq(&self, other: &Self) -> bool3070     fn eq(&self, other: &Self) -> bool {
3071         self.cbSize == other.cbSize && self.pCertContext == other.pCertContext && self.TrustStatus == other.TrustStatus && self.pRevocationInfo == other.pRevocationInfo && self.pIssuanceUsage == other.pIssuanceUsage && self.pApplicationUsage == other.pApplicationUsage && self.pwszExtendedErrorInfo == other.pwszExtendedErrorInfo
3072     }
3073 }
3074 #[cfg(feature = "Win32_Foundation")]
3075 impl ::std::cmp::Eq for CERT_CHAIN_ELEMENT {}
3076 #[cfg(feature = "Win32_Foundation")]
3077 unsafe impl ::windows::runtime::Abi for CERT_CHAIN_ELEMENT {
3078     type Abi = Self;
3079     type DefaultType = Self;
3080 }
3081 pub const CERT_CHAIN_ENABLE_ALL_EKU_HYGIENE_FLAG: u32 = 131072u32;
3082 pub const CERT_CHAIN_ENABLE_CACHE_AUTO_UPDATE: u32 = 16u32;
3083 pub const CERT_CHAIN_ENABLE_CODE_SIGNING_HYGIENE_FLAG: u32 = 16777216u32;
3084 pub const CERT_CHAIN_ENABLE_MD2_MD4_FLAG: u32 = 1u32;
3085 pub const CERT_CHAIN_ENABLE_MOTW_CODE_SIGNING_HYGIENE_FLAG: u32 = 33554432u32;
3086 pub const CERT_CHAIN_ENABLE_MOTW_TIMESTAMP_HYGIENE_FLAG: u32 = 536870912u32;
3087 pub const CERT_CHAIN_ENABLE_ONLY_WEAK_LOGGING_FLAG: u32 = 8u32;
3088 pub const CERT_CHAIN_ENABLE_PEER_TRUST: u32 = 1024u32;
3089 pub const CERT_CHAIN_ENABLE_SERVER_AUTH_HYGIENE_FLAG: u32 = 2097152u32;
3090 pub const CERT_CHAIN_ENABLE_SHARE_STORE: u32 = 32u32;
3091 pub const CERT_CHAIN_ENABLE_TIMESTAMP_HYGIENE_FLAG: u32 = 268435456u32;
3092 pub const CERT_CHAIN_ENABLE_WEAK_LOGGING_FLAG: u32 = 4u32;
3093 pub const CERT_CHAIN_ENABLE_WEAK_RSA_ROOT_FLAG: u32 = 2u32;
3094 pub const CERT_CHAIN_ENABLE_WEAK_SETTINGS_FLAG: u32 = 2147483648u32;
3095 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3096 #[repr(C)]
3097 pub struct CERT_CHAIN_ENGINE_CONFIG {
3098     pub cbSize: u32,
3099     pub hRestrictedRoot: *mut ::std::ffi::c_void,
3100     pub hRestrictedTrust: *mut ::std::ffi::c_void,
3101     pub hRestrictedOther: *mut ::std::ffi::c_void,
3102     pub cAdditionalStore: u32,
3103     pub rghAdditionalStore: *mut *mut ::std::ffi::c_void,
3104     pub dwFlags: u32,
3105     pub dwUrlRetrievalTimeout: u32,
3106     pub MaximumCachedCertificates: u32,
3107     pub CycleDetectionModulus: u32,
3108     pub hExclusiveRoot: *mut ::std::ffi::c_void,
3109     pub hExclusiveTrustedPeople: *mut ::std::ffi::c_void,
3110     pub dwExclusiveFlags: u32,
3111 }
3112 impl CERT_CHAIN_ENGINE_CONFIG {}
3113 impl ::std::default::Default for CERT_CHAIN_ENGINE_CONFIG {
default() -> Self3114     fn default() -> Self {
3115         unsafe { ::std::mem::zeroed() }
3116     }
3117 }
3118 impl ::std::fmt::Debug for CERT_CHAIN_ENGINE_CONFIG {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3119     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3120         fmt.debug_struct("CERT_CHAIN_ENGINE_CONFIG")
3121             .field("cbSize", &self.cbSize)
3122             .field("hRestrictedRoot", &self.hRestrictedRoot)
3123             .field("hRestrictedTrust", &self.hRestrictedTrust)
3124             .field("hRestrictedOther", &self.hRestrictedOther)
3125             .field("cAdditionalStore", &self.cAdditionalStore)
3126             .field("rghAdditionalStore", &self.rghAdditionalStore)
3127             .field("dwFlags", &self.dwFlags)
3128             .field("dwUrlRetrievalTimeout", &self.dwUrlRetrievalTimeout)
3129             .field("MaximumCachedCertificates", &self.MaximumCachedCertificates)
3130             .field("CycleDetectionModulus", &self.CycleDetectionModulus)
3131             .field("hExclusiveRoot", &self.hExclusiveRoot)
3132             .field("hExclusiveTrustedPeople", &self.hExclusiveTrustedPeople)
3133             .field("dwExclusiveFlags", &self.dwExclusiveFlags)
3134             .finish()
3135     }
3136 }
3137 impl ::std::cmp::PartialEq for CERT_CHAIN_ENGINE_CONFIG {
eq(&self, other: &Self) -> bool3138     fn eq(&self, other: &Self) -> bool {
3139         self.cbSize == other.cbSize
3140             && self.hRestrictedRoot == other.hRestrictedRoot
3141             && self.hRestrictedTrust == other.hRestrictedTrust
3142             && self.hRestrictedOther == other.hRestrictedOther
3143             && self.cAdditionalStore == other.cAdditionalStore
3144             && self.rghAdditionalStore == other.rghAdditionalStore
3145             && self.dwFlags == other.dwFlags
3146             && self.dwUrlRetrievalTimeout == other.dwUrlRetrievalTimeout
3147             && self.MaximumCachedCertificates == other.MaximumCachedCertificates
3148             && self.CycleDetectionModulus == other.CycleDetectionModulus
3149             && self.hExclusiveRoot == other.hExclusiveRoot
3150             && self.hExclusiveTrustedPeople == other.hExclusiveTrustedPeople
3151             && self.dwExclusiveFlags == other.dwExclusiveFlags
3152     }
3153 }
3154 impl ::std::cmp::Eq for CERT_CHAIN_ENGINE_CONFIG {}
3155 unsafe impl ::windows::runtime::Abi for CERT_CHAIN_ENGINE_CONFIG {
3156     type Abi = Self;
3157     type DefaultType = Self;
3158 }
3159 pub const CERT_CHAIN_EXCLUSIVE_ENABLE_CA_FLAG: u32 = 1u32;
3160 pub const CERT_CHAIN_FIND_BY_ISSUER: u32 = 1u32;
3161 #[derive(:: std :: clone :: Clone)]
3162 #[repr(C)]
3163 #[cfg(feature = "Win32_Foundation")]
3164 pub struct CERT_CHAIN_FIND_BY_ISSUER_PARA {
3165     pub cbSize: u32,
3166     pub pszUsageIdentifier: super::super::Foundation::PSTR,
3167     pub dwKeySpec: u32,
3168     pub dwAcquirePrivateKeyFlags: u32,
3169     pub cIssuer: u32,
3170     pub rgIssuer: *mut CRYPTOAPI_BLOB,
3171     pub pfnFindCallback: ::std::option::Option<PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK>,
3172     pub pvFindArg: *mut ::std::ffi::c_void,
3173 }
3174 #[cfg(feature = "Win32_Foundation")]
3175 impl CERT_CHAIN_FIND_BY_ISSUER_PARA {}
3176 #[cfg(feature = "Win32_Foundation")]
3177 impl ::std::default::Default for CERT_CHAIN_FIND_BY_ISSUER_PARA {
default() -> Self3178     fn default() -> Self {
3179         unsafe { ::std::mem::zeroed() }
3180     }
3181 }
3182 #[cfg(feature = "Win32_Foundation")]
3183 impl ::std::fmt::Debug for CERT_CHAIN_FIND_BY_ISSUER_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3184     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3185         fmt.debug_struct("CERT_CHAIN_FIND_BY_ISSUER_PARA")
3186             .field("cbSize", &self.cbSize)
3187             .field("pszUsageIdentifier", &self.pszUsageIdentifier)
3188             .field("dwKeySpec", &self.dwKeySpec)
3189             .field("dwAcquirePrivateKeyFlags", &self.dwAcquirePrivateKeyFlags)
3190             .field("cIssuer", &self.cIssuer)
3191             .field("rgIssuer", &self.rgIssuer)
3192             .field("pvFindArg", &self.pvFindArg)
3193             .finish()
3194     }
3195 }
3196 #[cfg(feature = "Win32_Foundation")]
3197 impl ::std::cmp::PartialEq for CERT_CHAIN_FIND_BY_ISSUER_PARA {
eq(&self, other: &Self) -> bool3198     fn eq(&self, other: &Self) -> bool {
3199         self.cbSize == other.cbSize && self.pszUsageIdentifier == other.pszUsageIdentifier && self.dwKeySpec == other.dwKeySpec && self.dwAcquirePrivateKeyFlags == other.dwAcquirePrivateKeyFlags && self.cIssuer == other.cIssuer && self.rgIssuer == other.rgIssuer && self.pfnFindCallback.map(|f| f as usize) == other.pfnFindCallback.map(|f| f as usize) && self.pvFindArg == other.pvFindArg
3200     }
3201 }
3202 #[cfg(feature = "Win32_Foundation")]
3203 impl ::std::cmp::Eq for CERT_CHAIN_FIND_BY_ISSUER_PARA {}
3204 #[cfg(feature = "Win32_Foundation")]
3205 unsafe impl ::windows::runtime::Abi for CERT_CHAIN_FIND_BY_ISSUER_PARA {
3206     type Abi = ::std::mem::ManuallyDrop<Self>;
3207     type DefaultType = Self;
3208 }
3209 pub const CERT_CHAIN_HAS_MOTW: u32 = 16384u32;
3210 pub const CERT_CHAIN_MAX_AIA_URL_COUNT_IN_CERT_DEFAULT: u32 = 5u32;
3211 pub const CERT_CHAIN_MAX_AIA_URL_RETRIEVAL_BYTE_COUNT_DEFAULT: u32 = 100000u32;
3212 pub const CERT_CHAIN_MAX_AIA_URL_RETRIEVAL_CERT_COUNT_DEFAULT: u32 = 10u32;
3213 pub const CERT_CHAIN_MAX_AIA_URL_RETRIEVAL_COUNT_PER_CHAIN_DEFAULT: u32 = 3u32;
3214 pub const CERT_CHAIN_MAX_SSL_TIME_UPDATED_EVENT_COUNT_DEFAULT: u32 = 5u32;
3215 pub const CERT_CHAIN_MAX_SSL_TIME_UPDATED_EVENT_COUNT_DISABLE: u32 = 4294967295u32;
3216 pub const CERT_CHAIN_MIN_PUB_KEY_BIT_LENGTH_DISABLE: u32 = 4294967295u32;
3217 pub const CERT_CHAIN_MIN_RSA_PUB_KEY_BIT_LENGTH_DEFAULT: u32 = 1023u32;
3218 pub const CERT_CHAIN_MIN_RSA_PUB_KEY_BIT_LENGTH_DISABLE: u32 = 4294967295u32;
3219 pub const CERT_CHAIN_MOTW_IGNORE_AFTER_TIME_WEAK_FLAG: u32 = 1073741824u32;
3220 pub const CERT_CHAIN_ONLY_ADDITIONAL_AND_AUTH_ROOT: u32 = 32768u32;
3221 pub const CERT_CHAIN_OPTION_DISABLE_AIA_URL_RETRIEVAL: u32 = 2u32;
3222 pub const CERT_CHAIN_OPTION_ENABLE_SIA_URL_RETRIEVAL: u32 = 4u32;
3223 pub const CERT_CHAIN_OPT_IN_WEAK_FLAGS: u32 = 262144u32;
3224 pub const CERT_CHAIN_OPT_IN_WEAK_SIGNATURE: u32 = 65536u32;
3225 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3226 #[repr(C)]
3227 #[cfg(feature = "Win32_Foundation")]
3228 pub struct CERT_CHAIN_PARA {
3229     pub cbSize: u32,
3230     pub RequestedUsage: CERT_USAGE_MATCH,
3231 }
3232 #[cfg(feature = "Win32_Foundation")]
3233 impl CERT_CHAIN_PARA {}
3234 #[cfg(feature = "Win32_Foundation")]
3235 impl ::std::default::Default for CERT_CHAIN_PARA {
default() -> Self3236     fn default() -> Self {
3237         unsafe { ::std::mem::zeroed() }
3238     }
3239 }
3240 #[cfg(feature = "Win32_Foundation")]
3241 impl ::std::fmt::Debug for CERT_CHAIN_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3242     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3243         fmt.debug_struct("CERT_CHAIN_PARA").field("cbSize", &self.cbSize).field("RequestedUsage", &self.RequestedUsage).finish()
3244     }
3245 }
3246 #[cfg(feature = "Win32_Foundation")]
3247 impl ::std::cmp::PartialEq for CERT_CHAIN_PARA {
eq(&self, other: &Self) -> bool3248     fn eq(&self, other: &Self) -> bool {
3249         self.cbSize == other.cbSize && self.RequestedUsage == other.RequestedUsage
3250     }
3251 }
3252 #[cfg(feature = "Win32_Foundation")]
3253 impl ::std::cmp::Eq for CERT_CHAIN_PARA {}
3254 #[cfg(feature = "Win32_Foundation")]
3255 unsafe impl ::windows::runtime::Abi for CERT_CHAIN_PARA {
3256     type Abi = Self;
3257     type DefaultType = Self;
3258 }
3259 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3260 #[repr(transparent)]
3261 pub struct CERT_CHAIN_POLICY_FLAGS(pub u32);
3262 pub const CERT_CHAIN_POLICY_IGNORE_NOT_TIME_VALID_FLAG: CERT_CHAIN_POLICY_FLAGS = CERT_CHAIN_POLICY_FLAGS(1u32);
3263 pub const CERT_CHAIN_POLICY_IGNORE_CTL_NOT_TIME_VALID_FLAG: CERT_CHAIN_POLICY_FLAGS = CERT_CHAIN_POLICY_FLAGS(2u32);
3264 pub const CERT_CHAIN_POLICY_IGNORE_NOT_TIME_NESTED_FLAG: CERT_CHAIN_POLICY_FLAGS = CERT_CHAIN_POLICY_FLAGS(4u32);
3265 pub const CERT_CHAIN_POLICY_IGNORE_ALL_NOT_TIME_VALID_FLAGS: CERT_CHAIN_POLICY_FLAGS = CERT_CHAIN_POLICY_FLAGS(7u32);
3266 pub const CERT_CHAIN_POLICY_IGNORE_INVALID_BASIC_CONSTRAINTS_FLAG: CERT_CHAIN_POLICY_FLAGS = CERT_CHAIN_POLICY_FLAGS(8u32);
3267 pub const CERT_CHAIN_POLICY_ALLOW_UNKNOWN_CA_FLAG: CERT_CHAIN_POLICY_FLAGS = CERT_CHAIN_POLICY_FLAGS(16u32);
3268 pub const CERT_CHAIN_POLICY_IGNORE_WRONG_USAGE_FLAG: CERT_CHAIN_POLICY_FLAGS = CERT_CHAIN_POLICY_FLAGS(32u32);
3269 pub const CERT_CHAIN_POLICY_IGNORE_INVALID_NAME_FLAG: CERT_CHAIN_POLICY_FLAGS = CERT_CHAIN_POLICY_FLAGS(64u32);
3270 pub const CERT_CHAIN_POLICY_IGNORE_INVALID_POLICY_FLAG: CERT_CHAIN_POLICY_FLAGS = CERT_CHAIN_POLICY_FLAGS(128u32);
3271 pub const CERT_CHAIN_POLICY_IGNORE_END_REV_UNKNOWN_FLAG: CERT_CHAIN_POLICY_FLAGS = CERT_CHAIN_POLICY_FLAGS(256u32);
3272 pub const CERT_CHAIN_POLICY_IGNORE_CTL_SIGNER_REV_UNKNOWN_FLAG: CERT_CHAIN_POLICY_FLAGS = CERT_CHAIN_POLICY_FLAGS(512u32);
3273 pub const CERT_CHAIN_POLICY_IGNORE_CA_REV_UNKNOWN_FLAG: CERT_CHAIN_POLICY_FLAGS = CERT_CHAIN_POLICY_FLAGS(1024u32);
3274 pub const CERT_CHAIN_POLICY_IGNORE_ROOT_REV_UNKNOWN_FLAG: CERT_CHAIN_POLICY_FLAGS = CERT_CHAIN_POLICY_FLAGS(2048u32);
3275 pub const CERT_CHAIN_POLICY_IGNORE_ALL_REV_UNKNOWN_FLAGS: CERT_CHAIN_POLICY_FLAGS = CERT_CHAIN_POLICY_FLAGS(3840u32);
3276 pub const CERT_CHAIN_POLICY_ALLOW_TESTROOT_FLAG: CERT_CHAIN_POLICY_FLAGS = CERT_CHAIN_POLICY_FLAGS(32768u32);
3277 pub const CERT_CHAIN_POLICY_TRUST_TESTROOT_FLAG: CERT_CHAIN_POLICY_FLAGS = CERT_CHAIN_POLICY_FLAGS(16384u32);
3278 pub const CERT_CHAIN_POLICY_IGNORE_NOT_SUPPORTED_CRITICAL_EXT_FLAG: CERT_CHAIN_POLICY_FLAGS = CERT_CHAIN_POLICY_FLAGS(8192u32);
3279 pub const CERT_CHAIN_POLICY_IGNORE_PEER_TRUST_FLAG: CERT_CHAIN_POLICY_FLAGS = CERT_CHAIN_POLICY_FLAGS(4096u32);
3280 impl ::std::convert::From<u32> for CERT_CHAIN_POLICY_FLAGS {
from(value: u32) -> Self3281     fn from(value: u32) -> Self {
3282         Self(value)
3283     }
3284 }
3285 unsafe impl ::windows::runtime::Abi for CERT_CHAIN_POLICY_FLAGS {
3286     type Abi = Self;
3287     type DefaultType = Self;
3288 }
3289 impl ::std::ops::BitOr for CERT_CHAIN_POLICY_FLAGS {
3290     type Output = Self;
bitor(self, rhs: Self) -> Self3291     fn bitor(self, rhs: Self) -> Self {
3292         Self(self.0 | rhs.0)
3293     }
3294 }
3295 impl ::std::ops::BitAnd for CERT_CHAIN_POLICY_FLAGS {
3296     type Output = Self;
bitand(self, rhs: Self) -> Self3297     fn bitand(self, rhs: Self) -> Self {
3298         Self(self.0 & rhs.0)
3299     }
3300 }
3301 impl ::std::ops::BitOrAssign for CERT_CHAIN_POLICY_FLAGS {
bitor_assign(&mut self, rhs: Self)3302     fn bitor_assign(&mut self, rhs: Self) {
3303         self.0.bitor_assign(rhs.0)
3304     }
3305 }
3306 impl ::std::ops::BitAndAssign for CERT_CHAIN_POLICY_FLAGS {
bitand_assign(&mut self, rhs: Self)3307     fn bitand_assign(&mut self, rhs: Self) {
3308         self.0.bitand_assign(rhs.0)
3309     }
3310 }
3311 impl ::std::ops::Not for CERT_CHAIN_POLICY_FLAGS {
3312     type Output = Self;
not(self) -> Self3313     fn not(self) -> Self {
3314         Self(self.0.not())
3315     }
3316 }
3317 pub const CERT_CHAIN_POLICY_IGNORE_WEAK_SIGNATURE_FLAG: u32 = 134217728u32;
3318 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3319 #[repr(C)]
3320 pub struct CERT_CHAIN_POLICY_PARA {
3321     pub cbSize: u32,
3322     pub dwFlags: CERT_CHAIN_POLICY_FLAGS,
3323     pub pvExtraPolicyPara: *mut ::std::ffi::c_void,
3324 }
3325 impl CERT_CHAIN_POLICY_PARA {}
3326 impl ::std::default::Default for CERT_CHAIN_POLICY_PARA {
default() -> Self3327     fn default() -> Self {
3328         unsafe { ::std::mem::zeroed() }
3329     }
3330 }
3331 impl ::std::fmt::Debug for CERT_CHAIN_POLICY_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3332     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3333         fmt.debug_struct("CERT_CHAIN_POLICY_PARA").field("cbSize", &self.cbSize).field("dwFlags", &self.dwFlags).field("pvExtraPolicyPara", &self.pvExtraPolicyPara).finish()
3334     }
3335 }
3336 impl ::std::cmp::PartialEq for CERT_CHAIN_POLICY_PARA {
eq(&self, other: &Self) -> bool3337     fn eq(&self, other: &Self) -> bool {
3338         self.cbSize == other.cbSize && self.dwFlags == other.dwFlags && self.pvExtraPolicyPara == other.pvExtraPolicyPara
3339     }
3340 }
3341 impl ::std::cmp::Eq for CERT_CHAIN_POLICY_PARA {}
3342 unsafe impl ::windows::runtime::Abi for CERT_CHAIN_POLICY_PARA {
3343     type Abi = Self;
3344     type DefaultType = Self;
3345 }
3346 pub const CERT_CHAIN_POLICY_SSL_F12_ERROR_LEVEL: u32 = 2u32;
3347 pub const CERT_CHAIN_POLICY_SSL_F12_NONE_CATEGORY: u32 = 0u32;
3348 pub const CERT_CHAIN_POLICY_SSL_F12_ROOT_PROGRAM_CATEGORY: u32 = 2u32;
3349 pub const CERT_CHAIN_POLICY_SSL_F12_SUCCESS_LEVEL: u32 = 0u32;
3350 pub const CERT_CHAIN_POLICY_SSL_F12_WARNING_LEVEL: u32 = 1u32;
3351 pub const CERT_CHAIN_POLICY_SSL_F12_WEAK_CRYPTO_CATEGORY: u32 = 1u32;
3352 pub const CERT_CHAIN_POLICY_SSL_KEY_PIN_MISMATCH_ERROR: i32 = -2i32;
3353 pub const CERT_CHAIN_POLICY_SSL_KEY_PIN_MISMATCH_WARNING: u32 = 2u32;
3354 pub const CERT_CHAIN_POLICY_SSL_KEY_PIN_MITM_ERROR: i32 = -1i32;
3355 pub const CERT_CHAIN_POLICY_SSL_KEY_PIN_MITM_WARNING: u32 = 1u32;
3356 pub const CERT_CHAIN_POLICY_SSL_KEY_PIN_SUCCESS: u32 = 0u32;
3357 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3358 #[repr(C)]
3359 pub struct CERT_CHAIN_POLICY_STATUS {
3360     pub cbSize: u32,
3361     pub dwError: u32,
3362     pub lChainIndex: i32,
3363     pub lElementIndex: i32,
3364     pub pvExtraPolicyStatus: *mut ::std::ffi::c_void,
3365 }
3366 impl CERT_CHAIN_POLICY_STATUS {}
3367 impl ::std::default::Default for CERT_CHAIN_POLICY_STATUS {
default() -> Self3368     fn default() -> Self {
3369         unsafe { ::std::mem::zeroed() }
3370     }
3371 }
3372 impl ::std::fmt::Debug for CERT_CHAIN_POLICY_STATUS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3373     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3374         fmt.debug_struct("CERT_CHAIN_POLICY_STATUS").field("cbSize", &self.cbSize).field("dwError", &self.dwError).field("lChainIndex", &self.lChainIndex).field("lElementIndex", &self.lElementIndex).field("pvExtraPolicyStatus", &self.pvExtraPolicyStatus).finish()
3375     }
3376 }
3377 impl ::std::cmp::PartialEq for CERT_CHAIN_POLICY_STATUS {
eq(&self, other: &Self) -> bool3378     fn eq(&self, other: &Self) -> bool {
3379         self.cbSize == other.cbSize && self.dwError == other.dwError && self.lChainIndex == other.lChainIndex && self.lElementIndex == other.lElementIndex && self.pvExtraPolicyStatus == other.pvExtraPolicyStatus
3380     }
3381 }
3382 impl ::std::cmp::Eq for CERT_CHAIN_POLICY_STATUS {}
3383 unsafe impl ::windows::runtime::Abi for CERT_CHAIN_POLICY_STATUS {
3384     type Abi = Self;
3385     type DefaultType = Self;
3386 }
3387 pub const CERT_CHAIN_RETURN_LOWER_QUALITY_CONTEXTS: u32 = 128u32;
3388 pub const CERT_CHAIN_REVOCATION_ACCUMULATIVE_TIMEOUT: u32 = 134217728u32;
3389 pub const CERT_CHAIN_REVOCATION_CHECK_CACHE_ONLY: u32 = 2147483648u32;
3390 pub const CERT_CHAIN_REVOCATION_CHECK_CHAIN: u32 = 536870912u32;
3391 pub const CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT: u32 = 1073741824u32;
3392 pub const CERT_CHAIN_REVOCATION_CHECK_END_CERT: u32 = 268435456u32;
3393 pub const CERT_CHAIN_REVOCATION_CHECK_OCSP_CERT: u32 = 67108864u32;
3394 pub const CERT_CHAIN_STRONG_SIGN_DISABLE_END_CHECK_FLAG: u32 = 1u32;
3395 pub const CERT_CHAIN_THREAD_STORE_SYNC: u32 = 2u32;
3396 pub const CERT_CHAIN_TIMESTAMP_TIME: u32 = 512u32;
3397 pub const CERT_CHAIN_USE_LOCAL_MACHINE_STORE: u32 = 8u32;
3398 pub const CERT_CLOSE_STORE_CHECK_FLAG: u32 = 2u32;
3399 pub const CERT_CLOSE_STORE_FORCE_FLAG: u32 = 1u32;
3400 pub const CERT_CLR_DELETE_KEY_PROP_ID: u32 = 125u32;
3401 pub const CERT_COMPARE_ANY: u32 = 0u32;
3402 pub const CERT_COMPARE_ATTR: u32 = 3u32;
3403 pub const CERT_COMPARE_CERT_ID: u32 = 16u32;
3404 pub const CERT_COMPARE_CROSS_CERT_DIST_POINTS: u32 = 17u32;
3405 pub const CERT_COMPARE_CTL_USAGE: u32 = 10u32;
3406 pub const CERT_COMPARE_ENHKEY_USAGE: u32 = 10u32;
3407 pub const CERT_COMPARE_EXISTING: u32 = 13u32;
3408 pub const CERT_COMPARE_HASH: u32 = 1u32;
3409 pub const CERT_COMPARE_HASH_STR: u32 = 20u32;
3410 pub const CERT_COMPARE_HAS_PRIVATE_KEY: u32 = 21u32;
3411 pub const CERT_COMPARE_ISSUER_OF: u32 = 12u32;
3412 pub const CERT_COMPARE_KEY_IDENTIFIER: u32 = 15u32;
3413 pub const CERT_COMPARE_KEY_SPEC: u32 = 9u32;
3414 pub const CERT_COMPARE_MASK: u32 = 65535u32;
3415 pub const CERT_COMPARE_MD5_HASH: u32 = 4u32;
3416 pub const CERT_COMPARE_NAME: u32 = 2u32;
3417 pub const CERT_COMPARE_NAME_STR_A: u32 = 7u32;
3418 pub const CERT_COMPARE_NAME_STR_W: u32 = 8u32;
3419 pub const CERT_COMPARE_PROPERTY: u32 = 5u32;
3420 pub const CERT_COMPARE_PUBKEY_MD5_HASH: u32 = 18u32;
3421 pub const CERT_COMPARE_PUBLIC_KEY: u32 = 6u32;
3422 pub const CERT_COMPARE_SHA1_HASH: u32 = 1u32;
3423 pub const CERT_COMPARE_SHIFT: i32 = 16i32;
3424 pub const CERT_COMPARE_SIGNATURE_HASH: u32 = 14u32;
3425 pub const CERT_COMPARE_SUBJECT_CERT: u32 = 11u32;
3426 pub const CERT_COMPARE_SUBJECT_INFO_ACCESS: u32 = 19u32;
3427 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3428 #[repr(C)]
3429 #[cfg(feature = "Win32_Foundation")]
3430 pub struct CERT_CONTEXT {
3431     pub dwCertEncodingType: u32,
3432     pub pbCertEncoded: *mut u8,
3433     pub cbCertEncoded: u32,
3434     pub pCertInfo: *mut CERT_INFO,
3435     pub hCertStore: *mut ::std::ffi::c_void,
3436 }
3437 #[cfg(feature = "Win32_Foundation")]
3438 impl CERT_CONTEXT {}
3439 #[cfg(feature = "Win32_Foundation")]
3440 impl ::std::default::Default for CERT_CONTEXT {
default() -> Self3441     fn default() -> Self {
3442         unsafe { ::std::mem::zeroed() }
3443     }
3444 }
3445 #[cfg(feature = "Win32_Foundation")]
3446 impl ::std::fmt::Debug for CERT_CONTEXT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3447     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3448         fmt.debug_struct("CERT_CONTEXT").field("dwCertEncodingType", &self.dwCertEncodingType).field("pbCertEncoded", &self.pbCertEncoded).field("cbCertEncoded", &self.cbCertEncoded).field("pCertInfo", &self.pCertInfo).field("hCertStore", &self.hCertStore).finish()
3449     }
3450 }
3451 #[cfg(feature = "Win32_Foundation")]
3452 impl ::std::cmp::PartialEq for CERT_CONTEXT {
eq(&self, other: &Self) -> bool3453     fn eq(&self, other: &Self) -> bool {
3454         self.dwCertEncodingType == other.dwCertEncodingType && self.pbCertEncoded == other.pbCertEncoded && self.cbCertEncoded == other.cbCertEncoded && self.pCertInfo == other.pCertInfo && self.hCertStore == other.hCertStore
3455     }
3456 }
3457 #[cfg(feature = "Win32_Foundation")]
3458 impl ::std::cmp::Eq for CERT_CONTEXT {}
3459 #[cfg(feature = "Win32_Foundation")]
3460 unsafe impl ::windows::runtime::Abi for CERT_CONTEXT {
3461     type Abi = Self;
3462     type DefaultType = Self;
3463 }
3464 pub const CERT_CONTEXT_REVOCATION_TYPE: u32 = 1u32;
3465 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3466 #[repr(transparent)]
3467 pub struct CERT_CONTROL_STORE_FLAGS(pub u32);
3468 pub const CERT_STORE_CTRL_COMMIT_FORCE_FLAG: CERT_CONTROL_STORE_FLAGS = CERT_CONTROL_STORE_FLAGS(1u32);
3469 pub const CERT_STORE_CTRL_COMMIT_CLEAR_FLAG: CERT_CONTROL_STORE_FLAGS = CERT_CONTROL_STORE_FLAGS(2u32);
3470 pub const CERT_STORE_CTRL_INHIBIT_DUPLICATE_HANDLE_FLAG: CERT_CONTROL_STORE_FLAGS = CERT_CONTROL_STORE_FLAGS(1u32);
3471 impl ::std::convert::From<u32> for CERT_CONTROL_STORE_FLAGS {
from(value: u32) -> Self3472     fn from(value: u32) -> Self {
3473         Self(value)
3474     }
3475 }
3476 unsafe impl ::windows::runtime::Abi for CERT_CONTROL_STORE_FLAGS {
3477     type Abi = Self;
3478     type DefaultType = Self;
3479 }
3480 impl ::std::ops::BitOr for CERT_CONTROL_STORE_FLAGS {
3481     type Output = Self;
bitor(self, rhs: Self) -> Self3482     fn bitor(self, rhs: Self) -> Self {
3483         Self(self.0 | rhs.0)
3484     }
3485 }
3486 impl ::std::ops::BitAnd for CERT_CONTROL_STORE_FLAGS {
3487     type Output = Self;
bitand(self, rhs: Self) -> Self3488     fn bitand(self, rhs: Self) -> Self {
3489         Self(self.0 & rhs.0)
3490     }
3491 }
3492 impl ::std::ops::BitOrAssign for CERT_CONTROL_STORE_FLAGS {
bitor_assign(&mut self, rhs: Self)3493     fn bitor_assign(&mut self, rhs: Self) {
3494         self.0.bitor_assign(rhs.0)
3495     }
3496 }
3497 impl ::std::ops::BitAndAssign for CERT_CONTROL_STORE_FLAGS {
bitand_assign(&mut self, rhs: Self)3498     fn bitand_assign(&mut self, rhs: Self) {
3499         self.0.bitand_assign(rhs.0)
3500     }
3501 }
3502 impl ::std::ops::Not for CERT_CONTROL_STORE_FLAGS {
3503     type Output = Self;
not(self) -> Self3504     fn not(self) -> Self {
3505         Self(self.0.not())
3506     }
3507 }
3508 pub const CERT_CREATE_CONTEXT_NOCOPY_FLAG: u32 = 1u32;
3509 pub const CERT_CREATE_CONTEXT_NO_ENTRY_FLAG: u32 = 8u32;
3510 pub const CERT_CREATE_CONTEXT_NO_HCRYPTMSG_FLAG: u32 = 4u32;
3511 #[derive(:: std :: clone :: Clone)]
3512 #[repr(C)]
3513 #[cfg(feature = "Win32_Foundation")]
3514 pub struct CERT_CREATE_CONTEXT_PARA {
3515     pub cbSize: u32,
3516     pub pfnFree: ::std::option::Option<PFN_CRYPT_FREE>,
3517     pub pvFree: *mut ::std::ffi::c_void,
3518     pub pfnSort: ::std::option::Option<PFN_CERT_CREATE_CONTEXT_SORT_FUNC>,
3519     pub pvSort: *mut ::std::ffi::c_void,
3520 }
3521 #[cfg(feature = "Win32_Foundation")]
3522 impl CERT_CREATE_CONTEXT_PARA {}
3523 #[cfg(feature = "Win32_Foundation")]
3524 impl ::std::default::Default for CERT_CREATE_CONTEXT_PARA {
default() -> Self3525     fn default() -> Self {
3526         unsafe { ::std::mem::zeroed() }
3527     }
3528 }
3529 #[cfg(feature = "Win32_Foundation")]
3530 impl ::std::fmt::Debug for CERT_CREATE_CONTEXT_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3531     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3532         fmt.debug_struct("CERT_CREATE_CONTEXT_PARA").field("cbSize", &self.cbSize).field("pvFree", &self.pvFree).field("pvSort", &self.pvSort).finish()
3533     }
3534 }
3535 #[cfg(feature = "Win32_Foundation")]
3536 impl ::std::cmp::PartialEq for CERT_CREATE_CONTEXT_PARA {
eq(&self, other: &Self) -> bool3537     fn eq(&self, other: &Self) -> bool {
3538         self.cbSize == other.cbSize && self.pfnFree.map(|f| f as usize) == other.pfnFree.map(|f| f as usize) && self.pvFree == other.pvFree && self.pfnSort.map(|f| f as usize) == other.pfnSort.map(|f| f as usize) && self.pvSort == other.pvSort
3539     }
3540 }
3541 #[cfg(feature = "Win32_Foundation")]
3542 impl ::std::cmp::Eq for CERT_CREATE_CONTEXT_PARA {}
3543 #[cfg(feature = "Win32_Foundation")]
3544 unsafe impl ::windows::runtime::Abi for CERT_CREATE_CONTEXT_PARA {
3545     type Abi = ::std::mem::ManuallyDrop<Self>;
3546     type DefaultType = Self;
3547 }
3548 pub const CERT_CREATE_CONTEXT_SORTED_FLAG: u32 = 2u32;
3549 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3550 #[repr(transparent)]
3551 pub struct CERT_CREATE_SELFSIGN_FLAGS(pub u32);
3552 pub const CERT_CREATE_SELFSIGN_NO_KEY_INFO: CERT_CREATE_SELFSIGN_FLAGS = CERT_CREATE_SELFSIGN_FLAGS(2u32);
3553 pub const CERT_CREATE_SELFSIGN_NO_SIGN: CERT_CREATE_SELFSIGN_FLAGS = CERT_CREATE_SELFSIGN_FLAGS(1u32);
3554 impl ::std::convert::From<u32> for CERT_CREATE_SELFSIGN_FLAGS {
from(value: u32) -> Self3555     fn from(value: u32) -> Self {
3556         Self(value)
3557     }
3558 }
3559 unsafe impl ::windows::runtime::Abi for CERT_CREATE_SELFSIGN_FLAGS {
3560     type Abi = Self;
3561     type DefaultType = Self;
3562 }
3563 impl ::std::ops::BitOr for CERT_CREATE_SELFSIGN_FLAGS {
3564     type Output = Self;
bitor(self, rhs: Self) -> Self3565     fn bitor(self, rhs: Self) -> Self {
3566         Self(self.0 | rhs.0)
3567     }
3568 }
3569 impl ::std::ops::BitAnd for CERT_CREATE_SELFSIGN_FLAGS {
3570     type Output = Self;
bitand(self, rhs: Self) -> Self3571     fn bitand(self, rhs: Self) -> Self {
3572         Self(self.0 & rhs.0)
3573     }
3574 }
3575 impl ::std::ops::BitOrAssign for CERT_CREATE_SELFSIGN_FLAGS {
bitor_assign(&mut self, rhs: Self)3576     fn bitor_assign(&mut self, rhs: Self) {
3577         self.0.bitor_assign(rhs.0)
3578     }
3579 }
3580 impl ::std::ops::BitAndAssign for CERT_CREATE_SELFSIGN_FLAGS {
bitand_assign(&mut self, rhs: Self)3581     fn bitand_assign(&mut self, rhs: Self) {
3582         self.0.bitand_assign(rhs.0)
3583     }
3584 }
3585 impl ::std::ops::Not for CERT_CREATE_SELFSIGN_FLAGS {
3586     type Output = Self;
not(self) -> Self3587     fn not(self) -> Self {
3588         Self(self.0.not())
3589     }
3590 }
3591 pub const CERT_CREDENTIAL_PROVIDER_ID: i32 = -509i32;
3592 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3593 #[repr(C)]
3594 #[cfg(feature = "Win32_Foundation")]
3595 pub struct CERT_CRL_CONTEXT_PAIR {
3596     pub pCertContext: *mut CERT_CONTEXT,
3597     pub pCrlContext: *mut CRL_CONTEXT,
3598 }
3599 #[cfg(feature = "Win32_Foundation")]
3600 impl CERT_CRL_CONTEXT_PAIR {}
3601 #[cfg(feature = "Win32_Foundation")]
3602 impl ::std::default::Default for CERT_CRL_CONTEXT_PAIR {
default() -> Self3603     fn default() -> Self {
3604         unsafe { ::std::mem::zeroed() }
3605     }
3606 }
3607 #[cfg(feature = "Win32_Foundation")]
3608 impl ::std::fmt::Debug for CERT_CRL_CONTEXT_PAIR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3609     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3610         fmt.debug_struct("CERT_CRL_CONTEXT_PAIR").field("pCertContext", &self.pCertContext).field("pCrlContext", &self.pCrlContext).finish()
3611     }
3612 }
3613 #[cfg(feature = "Win32_Foundation")]
3614 impl ::std::cmp::PartialEq for CERT_CRL_CONTEXT_PAIR {
eq(&self, other: &Self) -> bool3615     fn eq(&self, other: &Self) -> bool {
3616         self.pCertContext == other.pCertContext && self.pCrlContext == other.pCrlContext
3617     }
3618 }
3619 #[cfg(feature = "Win32_Foundation")]
3620 impl ::std::cmp::Eq for CERT_CRL_CONTEXT_PAIR {}
3621 #[cfg(feature = "Win32_Foundation")]
3622 unsafe impl ::windows::runtime::Abi for CERT_CRL_CONTEXT_PAIR {
3623     type Abi = Self;
3624     type DefaultType = Self;
3625 }
3626 pub const CERT_CRL_SIGN_KEY_USAGE: u32 = 2u32;
3627 pub const CERT_CROSS_CERT_DIST_POINTS_PROP_ID: u32 = 23u32;
3628 pub const CERT_CTL_USAGE_PROP_ID: u32 = 9u32;
3629 pub const CERT_DATA_ENCIPHERMENT_KEY_USAGE: u32 = 16u32;
3630 pub const CERT_DATE_STAMP_PROP_ID: u32 = 27u32;
3631 pub const CERT_DECIPHER_ONLY_KEY_USAGE: u32 = 128u32;
3632 pub const CERT_DESCRIPTION_PROP_ID: u32 = 13u32;
3633 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3634 #[repr(C)]
3635 pub struct CERT_DH_PARAMETERS {
3636     pub p: CRYPTOAPI_BLOB,
3637     pub g: CRYPTOAPI_BLOB,
3638 }
3639 impl CERT_DH_PARAMETERS {}
3640 impl ::std::default::Default for CERT_DH_PARAMETERS {
default() -> Self3641     fn default() -> Self {
3642         unsafe { ::std::mem::zeroed() }
3643     }
3644 }
3645 impl ::std::fmt::Debug for CERT_DH_PARAMETERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3646     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3647         fmt.debug_struct("CERT_DH_PARAMETERS").field("p", &self.p).field("g", &self.g).finish()
3648     }
3649 }
3650 impl ::std::cmp::PartialEq for CERT_DH_PARAMETERS {
eq(&self, other: &Self) -> bool3651     fn eq(&self, other: &Self) -> bool {
3652         self.p == other.p && self.g == other.g
3653     }
3654 }
3655 impl ::std::cmp::Eq for CERT_DH_PARAMETERS {}
3656 unsafe impl ::windows::runtime::Abi for CERT_DH_PARAMETERS {
3657     type Abi = Self;
3658     type DefaultType = Self;
3659 }
3660 pub const CERT_DIGITAL_SIGNATURE_KEY_USAGE: u32 = 128u32;
3661 pub const CERT_DISALLOWED_ENHKEY_USAGE_PROP_ID: u32 = 122u32;
3662 pub const CERT_DISALLOWED_FILETIME_PROP_ID: u32 = 104u32;
3663 pub const CERT_DISPWELL_DISTRUST_ADD_CA_CERT: u32 = 8u32;
3664 pub const CERT_DISPWELL_DISTRUST_ADD_LEAF_CERT: u32 = 9u32;
3665 pub const CERT_DISPWELL_DISTRUST_CA_CERT: u32 = 6u32;
3666 pub const CERT_DISPWELL_DISTRUST_LEAF_CERT: u32 = 7u32;
3667 pub const CERT_DISPWELL_SELECT: u32 = 1u32;
3668 pub const CERT_DISPWELL_TRUST_ADD_CA_CERT: u32 = 4u32;
3669 pub const CERT_DISPWELL_TRUST_ADD_LEAF_CERT: u32 = 5u32;
3670 pub const CERT_DISPWELL_TRUST_CA_CERT: u32 = 2u32;
3671 pub const CERT_DISPWELL_TRUST_LEAF_CERT: u32 = 3u32;
3672 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3673 #[repr(C)]
3674 pub struct CERT_DSS_PARAMETERS {
3675     pub p: CRYPTOAPI_BLOB,
3676     pub q: CRYPTOAPI_BLOB,
3677     pub g: CRYPTOAPI_BLOB,
3678 }
3679 impl CERT_DSS_PARAMETERS {}
3680 impl ::std::default::Default for CERT_DSS_PARAMETERS {
default() -> Self3681     fn default() -> Self {
3682         unsafe { ::std::mem::zeroed() }
3683     }
3684 }
3685 impl ::std::fmt::Debug for CERT_DSS_PARAMETERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3686     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3687         fmt.debug_struct("CERT_DSS_PARAMETERS").field("p", &self.p).field("q", &self.q).field("g", &self.g).finish()
3688     }
3689 }
3690 impl ::std::cmp::PartialEq for CERT_DSS_PARAMETERS {
eq(&self, other: &Self) -> bool3691     fn eq(&self, other: &Self) -> bool {
3692         self.p == other.p && self.q == other.q && self.g == other.g
3693     }
3694 }
3695 impl ::std::cmp::Eq for CERT_DSS_PARAMETERS {}
3696 unsafe impl ::windows::runtime::Abi for CERT_DSS_PARAMETERS {
3697     type Abi = Self;
3698     type DefaultType = Self;
3699 }
3700 pub const CERT_DSS_R_LEN: u32 = 20u32;
3701 pub const CERT_DSS_S_LEN: u32 = 20u32;
3702 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3703 #[repr(C)]
3704 pub struct CERT_ECC_SIGNATURE {
3705     pub r: CRYPTOAPI_BLOB,
3706     pub s: CRYPTOAPI_BLOB,
3707 }
3708 impl CERT_ECC_SIGNATURE {}
3709 impl ::std::default::Default for CERT_ECC_SIGNATURE {
default() -> Self3710     fn default() -> Self {
3711         unsafe { ::std::mem::zeroed() }
3712     }
3713 }
3714 impl ::std::fmt::Debug for CERT_ECC_SIGNATURE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3715     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3716         fmt.debug_struct("CERT_ECC_SIGNATURE").field("r", &self.r).field("s", &self.s).finish()
3717     }
3718 }
3719 impl ::std::cmp::PartialEq for CERT_ECC_SIGNATURE {
eq(&self, other: &Self) -> bool3720     fn eq(&self, other: &Self) -> bool {
3721         self.r == other.r && self.s == other.s
3722     }
3723 }
3724 impl ::std::cmp::Eq for CERT_ECC_SIGNATURE {}
3725 unsafe impl ::windows::runtime::Abi for CERT_ECC_SIGNATURE {
3726     type Abi = Self;
3727     type DefaultType = Self;
3728 }
3729 pub const CERT_EFS_PROP_ID: u32 = 17u32;
3730 pub const CERT_ENCIPHER_ONLY_KEY_USAGE: u32 = 1u32;
3731 pub const CERT_ENCODING_TYPE_MASK: u32 = 65535u32;
3732 pub const CERT_END_ENTITY_SUBJECT_FLAG: u32 = 64u32;
3733 pub const CERT_ENHKEY_USAGE_PROP_ID: u32 = 9u32;
3734 pub const CERT_ENROLLMENT_PROP_ID: u32 = 26u32;
3735 pub const CERT_EXCLUDED_SUBTREE_BIT: i32 = -2147483648i32;
3736 pub const CERT_EXTENDED_ERROR_INFO_PROP_ID: u32 = 30u32;
3737 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3738 #[repr(C)]
3739 #[cfg(feature = "Win32_Foundation")]
3740 pub struct CERT_EXTENSION {
3741     pub pszObjId: super::super::Foundation::PSTR,
3742     pub fCritical: super::super::Foundation::BOOL,
3743     pub Value: CRYPTOAPI_BLOB,
3744 }
3745 #[cfg(feature = "Win32_Foundation")]
3746 impl CERT_EXTENSION {}
3747 #[cfg(feature = "Win32_Foundation")]
3748 impl ::std::default::Default for CERT_EXTENSION {
default() -> Self3749     fn default() -> Self {
3750         unsafe { ::std::mem::zeroed() }
3751     }
3752 }
3753 #[cfg(feature = "Win32_Foundation")]
3754 impl ::std::fmt::Debug for CERT_EXTENSION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3755     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3756         fmt.debug_struct("CERT_EXTENSION").field("pszObjId", &self.pszObjId).field("fCritical", &self.fCritical).field("Value", &self.Value).finish()
3757     }
3758 }
3759 #[cfg(feature = "Win32_Foundation")]
3760 impl ::std::cmp::PartialEq for CERT_EXTENSION {
eq(&self, other: &Self) -> bool3761     fn eq(&self, other: &Self) -> bool {
3762         self.pszObjId == other.pszObjId && self.fCritical == other.fCritical && self.Value == other.Value
3763     }
3764 }
3765 #[cfg(feature = "Win32_Foundation")]
3766 impl ::std::cmp::Eq for CERT_EXTENSION {}
3767 #[cfg(feature = "Win32_Foundation")]
3768 unsafe impl ::windows::runtime::Abi for CERT_EXTENSION {
3769     type Abi = Self;
3770     type DefaultType = Self;
3771 }
3772 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3773 #[repr(C)]
3774 #[cfg(feature = "Win32_Foundation")]
3775 pub struct CERT_EXTENSIONS {
3776     pub cExtension: u32,
3777     pub rgExtension: *mut CERT_EXTENSION,
3778 }
3779 #[cfg(feature = "Win32_Foundation")]
3780 impl CERT_EXTENSIONS {}
3781 #[cfg(feature = "Win32_Foundation")]
3782 impl ::std::default::Default for CERT_EXTENSIONS {
default() -> Self3783     fn default() -> Self {
3784         unsafe { ::std::mem::zeroed() }
3785     }
3786 }
3787 #[cfg(feature = "Win32_Foundation")]
3788 impl ::std::fmt::Debug for CERT_EXTENSIONS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3789     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3790         fmt.debug_struct("CERT_EXTENSIONS").field("cExtension", &self.cExtension).field("rgExtension", &self.rgExtension).finish()
3791     }
3792 }
3793 #[cfg(feature = "Win32_Foundation")]
3794 impl ::std::cmp::PartialEq for CERT_EXTENSIONS {
eq(&self, other: &Self) -> bool3795     fn eq(&self, other: &Self) -> bool {
3796         self.cExtension == other.cExtension && self.rgExtension == other.rgExtension
3797     }
3798 }
3799 #[cfg(feature = "Win32_Foundation")]
3800 impl ::std::cmp::Eq for CERT_EXTENSIONS {}
3801 #[cfg(feature = "Win32_Foundation")]
3802 unsafe impl ::windows::runtime::Abi for CERT_EXTENSIONS {
3803     type Abi = Self;
3804     type DefaultType = Self;
3805 }
3806 pub const CERT_FILE_HASH_USE_TYPE: u32 = 1u32;
3807 pub const CERT_FILE_STORE_COMMIT_ENABLE_FLAG: u32 = 65536u32;
3808 pub const CERT_FILTER_INCLUDE_V1_CERTS: u32 = 1u32;
3809 pub const CERT_FILTER_ISSUER_CERTS_ONLY: u32 = 16u32;
3810 pub const CERT_FILTER_KEY_EXISTS: u32 = 32u32;
3811 pub const CERT_FILTER_LEAF_CERTS_ONLY: u32 = 8u32;
3812 pub const CERT_FILTER_OP_EQUALITY: u32 = 3u32;
3813 pub const CERT_FILTER_OP_EXISTS: u32 = 1u32;
3814 pub const CERT_FILTER_OP_NOT_EXISTS: u32 = 2u32;
3815 pub const CERT_FILTER_VALID_SIGNATURE: u32 = 4u32;
3816 pub const CERT_FILTER_VALID_TIME_RANGE: u32 = 2u32;
3817 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3818 #[repr(transparent)]
3819 pub struct CERT_FIND_CHAIN_IN_STORE_FLAGS(pub u32);
3820 pub const CERT_CHAIN_FIND_BY_ISSUER_COMPARE_KEY_FLAG: CERT_FIND_CHAIN_IN_STORE_FLAGS = CERT_FIND_CHAIN_IN_STORE_FLAGS(1u32);
3821 pub const CERT_CHAIN_FIND_BY_ISSUER_COMPLEX_CHAIN_FLAG: CERT_FIND_CHAIN_IN_STORE_FLAGS = CERT_FIND_CHAIN_IN_STORE_FLAGS(2u32);
3822 pub const CERT_CHAIN_FIND_BY_ISSUER_CACHE_ONLY_FLAG: CERT_FIND_CHAIN_IN_STORE_FLAGS = CERT_FIND_CHAIN_IN_STORE_FLAGS(32768u32);
3823 pub const CERT_CHAIN_FIND_BY_ISSUER_CACHE_ONLY_URL_FLAG: CERT_FIND_CHAIN_IN_STORE_FLAGS = CERT_FIND_CHAIN_IN_STORE_FLAGS(4u32);
3824 pub const CERT_CHAIN_FIND_BY_ISSUER_LOCAL_MACHINE_FLAG: CERT_FIND_CHAIN_IN_STORE_FLAGS = CERT_FIND_CHAIN_IN_STORE_FLAGS(8u32);
3825 pub const CERT_CHAIN_FIND_BY_ISSUER_NO_KEY_FLAG: CERT_FIND_CHAIN_IN_STORE_FLAGS = CERT_FIND_CHAIN_IN_STORE_FLAGS(16384u32);
3826 impl ::std::convert::From<u32> for CERT_FIND_CHAIN_IN_STORE_FLAGS {
from(value: u32) -> Self3827     fn from(value: u32) -> Self {
3828         Self(value)
3829     }
3830 }
3831 unsafe impl ::windows::runtime::Abi for CERT_FIND_CHAIN_IN_STORE_FLAGS {
3832     type Abi = Self;
3833     type DefaultType = Self;
3834 }
3835 impl ::std::ops::BitOr for CERT_FIND_CHAIN_IN_STORE_FLAGS {
3836     type Output = Self;
bitor(self, rhs: Self) -> Self3837     fn bitor(self, rhs: Self) -> Self {
3838         Self(self.0 | rhs.0)
3839     }
3840 }
3841 impl ::std::ops::BitAnd for CERT_FIND_CHAIN_IN_STORE_FLAGS {
3842     type Output = Self;
bitand(self, rhs: Self) -> Self3843     fn bitand(self, rhs: Self) -> Self {
3844         Self(self.0 & rhs.0)
3845     }
3846 }
3847 impl ::std::ops::BitOrAssign for CERT_FIND_CHAIN_IN_STORE_FLAGS {
bitor_assign(&mut self, rhs: Self)3848     fn bitor_assign(&mut self, rhs: Self) {
3849         self.0.bitor_assign(rhs.0)
3850     }
3851 }
3852 impl ::std::ops::BitAndAssign for CERT_FIND_CHAIN_IN_STORE_FLAGS {
bitand_assign(&mut self, rhs: Self)3853     fn bitand_assign(&mut self, rhs: Self) {
3854         self.0.bitand_assign(rhs.0)
3855     }
3856 }
3857 impl ::std::ops::Not for CERT_FIND_CHAIN_IN_STORE_FLAGS {
3858     type Output = Self;
not(self) -> Self3859     fn not(self) -> Self {
3860         Self(self.0.not())
3861     }
3862 }
3863 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3864 #[repr(transparent)]
3865 pub struct CERT_FIND_FLAGS(pub u32);
3866 pub const CERT_FIND_ANY: CERT_FIND_FLAGS = CERT_FIND_FLAGS(0u32);
3867 pub const CERT_FIND_CERT_ID: CERT_FIND_FLAGS = CERT_FIND_FLAGS(1048576u32);
3868 pub const CERT_FIND_CTL_USAGE: CERT_FIND_FLAGS = CERT_FIND_FLAGS(655360u32);
3869 pub const CERT_FIND_ENHKEY_USAGE: CERT_FIND_FLAGS = CERT_FIND_FLAGS(655360u32);
3870 pub const CERT_FIND_EXISTING: CERT_FIND_FLAGS = CERT_FIND_FLAGS(851968u32);
3871 pub const CERT_FIND_HASH: CERT_FIND_FLAGS = CERT_FIND_FLAGS(65536u32);
3872 pub const CERT_FIND_HAS_PRIVATE_KEY: CERT_FIND_FLAGS = CERT_FIND_FLAGS(1376256u32);
3873 pub const CERT_FIND_ISSUER_ATTR: CERT_FIND_FLAGS = CERT_FIND_FLAGS(196612u32);
3874 pub const CERT_FIND_ISSUER_NAME: CERT_FIND_FLAGS = CERT_FIND_FLAGS(131076u32);
3875 pub const CERT_FIND_ISSUER_OF: CERT_FIND_FLAGS = CERT_FIND_FLAGS(786432u32);
3876 pub const CERT_FIND_ISSUER_STR: CERT_FIND_FLAGS = CERT_FIND_FLAGS(524292u32);
3877 pub const CERT_FIND_KEY_IDENTIFIER: CERT_FIND_FLAGS = CERT_FIND_FLAGS(983040u32);
3878 pub const CERT_FIND_KEY_SPEC: CERT_FIND_FLAGS = CERT_FIND_FLAGS(589824u32);
3879 pub const CERT_FIND_MD5_HASH: CERT_FIND_FLAGS = CERT_FIND_FLAGS(262144u32);
3880 pub const CERT_FIND_PROPERTY: CERT_FIND_FLAGS = CERT_FIND_FLAGS(327680u32);
3881 pub const CERT_FIND_PUBLIC_KEY: CERT_FIND_FLAGS = CERT_FIND_FLAGS(393216u32);
3882 pub const CERT_FIND_SHA1_HASH: CERT_FIND_FLAGS = CERT_FIND_FLAGS(65536u32);
3883 pub const CERT_FIND_SIGNATURE_HASH: CERT_FIND_FLAGS = CERT_FIND_FLAGS(917504u32);
3884 pub const CERT_FIND_SUBJECT_ATTR: CERT_FIND_FLAGS = CERT_FIND_FLAGS(196615u32);
3885 pub const CERT_FIND_SUBJECT_CERT: CERT_FIND_FLAGS = CERT_FIND_FLAGS(720896u32);
3886 pub const CERT_FIND_SUBJECT_NAME: CERT_FIND_FLAGS = CERT_FIND_FLAGS(131079u32);
3887 pub const CERT_FIND_SUBJECT_STR: CERT_FIND_FLAGS = CERT_FIND_FLAGS(524295u32);
3888 pub const CERT_FIND_CROSS_CERT_DIST_POINTS: CERT_FIND_FLAGS = CERT_FIND_FLAGS(1114112u32);
3889 pub const CERT_FIND_PUBKEY_MD5_HASH: CERT_FIND_FLAGS = CERT_FIND_FLAGS(1179648u32);
3890 pub const CERT_FIND_SUBJECT_STR_A: CERT_FIND_FLAGS = CERT_FIND_FLAGS(458759u32);
3891 pub const CERT_FIND_SUBJECT_STR_W: CERT_FIND_FLAGS = CERT_FIND_FLAGS(524295u32);
3892 pub const CERT_FIND_ISSUER_STR_A: CERT_FIND_FLAGS = CERT_FIND_FLAGS(458756u32);
3893 pub const CERT_FIND_ISSUER_STR_W: CERT_FIND_FLAGS = CERT_FIND_FLAGS(524292u32);
3894 pub const CERT_FIND_SUBJECT_INFO_ACCESS: CERT_FIND_FLAGS = CERT_FIND_FLAGS(1245184u32);
3895 pub const CERT_FIND_HASH_STR: CERT_FIND_FLAGS = CERT_FIND_FLAGS(1310720u32);
3896 pub const CERT_FIND_OPTIONAL_ENHKEY_USAGE_FLAG: CERT_FIND_FLAGS = CERT_FIND_FLAGS(1u32);
3897 pub const CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG: CERT_FIND_FLAGS = CERT_FIND_FLAGS(2u32);
3898 pub const CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG: CERT_FIND_FLAGS = CERT_FIND_FLAGS(4u32);
3899 pub const CERT_FIND_NO_ENHKEY_USAGE_FLAG: CERT_FIND_FLAGS = CERT_FIND_FLAGS(8u32);
3900 pub const CERT_FIND_OR_ENHKEY_USAGE_FLAG: CERT_FIND_FLAGS = CERT_FIND_FLAGS(16u32);
3901 pub const CERT_FIND_VALID_ENHKEY_USAGE_FLAG: CERT_FIND_FLAGS = CERT_FIND_FLAGS(32u32);
3902 pub const CERT_FIND_OPTIONAL_CTL_USAGE_FLAG: CERT_FIND_FLAGS = CERT_FIND_FLAGS(1u32);
3903 pub const CERT_FIND_EXT_ONLY_CTL_USAGE_FLAG: CERT_FIND_FLAGS = CERT_FIND_FLAGS(2u32);
3904 pub const CERT_FIND_PROP_ONLY_CTL_USAGE_FLAG: CERT_FIND_FLAGS = CERT_FIND_FLAGS(4u32);
3905 pub const CERT_FIND_NO_CTL_USAGE_FLAG: CERT_FIND_FLAGS = CERT_FIND_FLAGS(8u32);
3906 pub const CERT_FIND_OR_CTL_USAGE_FLAG: CERT_FIND_FLAGS = CERT_FIND_FLAGS(16u32);
3907 pub const CERT_FIND_VALID_CTL_USAGE_FLAG: CERT_FIND_FLAGS = CERT_FIND_FLAGS(32u32);
3908 impl ::std::convert::From<u32> for CERT_FIND_FLAGS {
from(value: u32) -> Self3909     fn from(value: u32) -> Self {
3910         Self(value)
3911     }
3912 }
3913 unsafe impl ::windows::runtime::Abi for CERT_FIND_FLAGS {
3914     type Abi = Self;
3915     type DefaultType = Self;
3916 }
3917 impl ::std::ops::BitOr for CERT_FIND_FLAGS {
3918     type Output = Self;
bitor(self, rhs: Self) -> Self3919     fn bitor(self, rhs: Self) -> Self {
3920         Self(self.0 | rhs.0)
3921     }
3922 }
3923 impl ::std::ops::BitAnd for CERT_FIND_FLAGS {
3924     type Output = Self;
bitand(self, rhs: Self) -> Self3925     fn bitand(self, rhs: Self) -> Self {
3926         Self(self.0 & rhs.0)
3927     }
3928 }
3929 impl ::std::ops::BitOrAssign for CERT_FIND_FLAGS {
bitor_assign(&mut self, rhs: Self)3930     fn bitor_assign(&mut self, rhs: Self) {
3931         self.0.bitor_assign(rhs.0)
3932     }
3933 }
3934 impl ::std::ops::BitAndAssign for CERT_FIND_FLAGS {
bitand_assign(&mut self, rhs: Self)3935     fn bitand_assign(&mut self, rhs: Self) {
3936         self.0.bitand_assign(rhs.0)
3937     }
3938 }
3939 impl ::std::ops::Not for CERT_FIND_FLAGS {
3940     type Output = Self;
not(self) -> Self3941     fn not(self) -> Self {
3942         Self(self.0.not())
3943     }
3944 }
3945 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3946 #[repr(transparent)]
3947 pub struct CERT_FIND_TYPE(pub u32);
3948 pub const CTL_FIND_ANY: CERT_FIND_TYPE = CERT_FIND_TYPE(0u32);
3949 pub const CTL_FIND_SHA1_HASH: CERT_FIND_TYPE = CERT_FIND_TYPE(1u32);
3950 pub const CTL_FIND_MD5_HASH: CERT_FIND_TYPE = CERT_FIND_TYPE(2u32);
3951 pub const CTL_FIND_USAGE: CERT_FIND_TYPE = CERT_FIND_TYPE(3u32);
3952 pub const CTL_FIND_SAME_USAGE_FLAG: CERT_FIND_TYPE = CERT_FIND_TYPE(1u32);
3953 pub const CTL_FIND_EXISTING: CERT_FIND_TYPE = CERT_FIND_TYPE(5u32);
3954 pub const CTL_FIND_SUBJECT: CERT_FIND_TYPE = CERT_FIND_TYPE(4u32);
3955 impl ::std::convert::From<u32> for CERT_FIND_TYPE {
from(value: u32) -> Self3956     fn from(value: u32) -> Self {
3957         Self(value)
3958     }
3959 }
3960 unsafe impl ::windows::runtime::Abi for CERT_FIND_TYPE {
3961     type Abi = Self;
3962     type DefaultType = Self;
3963 }
3964 impl ::std::ops::BitOr for CERT_FIND_TYPE {
3965     type Output = Self;
bitor(self, rhs: Self) -> Self3966     fn bitor(self, rhs: Self) -> Self {
3967         Self(self.0 | rhs.0)
3968     }
3969 }
3970 impl ::std::ops::BitAnd for CERT_FIND_TYPE {
3971     type Output = Self;
bitand(self, rhs: Self) -> Self3972     fn bitand(self, rhs: Self) -> Self {
3973         Self(self.0 & rhs.0)
3974     }
3975 }
3976 impl ::std::ops::BitOrAssign for CERT_FIND_TYPE {
bitor_assign(&mut self, rhs: Self)3977     fn bitor_assign(&mut self, rhs: Self) {
3978         self.0.bitor_assign(rhs.0)
3979     }
3980 }
3981 impl ::std::ops::BitAndAssign for CERT_FIND_TYPE {
bitand_assign(&mut self, rhs: Self)3982     fn bitand_assign(&mut self, rhs: Self) {
3983         self.0.bitand_assign(rhs.0)
3984     }
3985 }
3986 impl ::std::ops::Not for CERT_FIND_TYPE {
3987     type Output = Self;
not(self) -> Self3988     fn not(self) -> Self {
3989         Self(self.0.not())
3990     }
3991 }
3992 pub const CERT_FIRST_RESERVED_PROP_ID: u32 = 128u32;
3993 pub const CERT_FIRST_USER_PROP_ID: u32 = 32768u32;
3994 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3995 #[repr(C)]
3996 pub struct CERT_FORTEZZA_DATA_PROP {
3997     pub SerialNumber: [u8; 8],
3998     pub CertIndex: i32,
3999     pub CertLabel: [u8; 36],
4000 }
4001 impl CERT_FORTEZZA_DATA_PROP {}
4002 impl ::std::default::Default for CERT_FORTEZZA_DATA_PROP {
default() -> Self4003     fn default() -> Self {
4004         unsafe { ::std::mem::zeroed() }
4005     }
4006 }
4007 impl ::std::fmt::Debug for CERT_FORTEZZA_DATA_PROP {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4008     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4009         fmt.debug_struct("CERT_FORTEZZA_DATA_PROP").field("SerialNumber", &self.SerialNumber).field("CertIndex", &self.CertIndex).field("CertLabel", &self.CertLabel).finish()
4010     }
4011 }
4012 impl ::std::cmp::PartialEq for CERT_FORTEZZA_DATA_PROP {
eq(&self, other: &Self) -> bool4013     fn eq(&self, other: &Self) -> bool {
4014         self.SerialNumber == other.SerialNumber && self.CertIndex == other.CertIndex && self.CertLabel == other.CertLabel
4015     }
4016 }
4017 impl ::std::cmp::Eq for CERT_FORTEZZA_DATA_PROP {}
4018 unsafe impl ::windows::runtime::Abi for CERT_FORTEZZA_DATA_PROP {
4019     type Abi = Self;
4020     type DefaultType = Self;
4021 }
4022 pub const CERT_FORTEZZA_DATA_PROP_ID: u32 = 18u32;
4023 pub const CERT_FRIENDLY_NAME_PROP_ID: u32 = 11u32;
4024 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4025 #[repr(C)]
4026 #[cfg(feature = "Win32_Foundation")]
4027 pub struct CERT_GENERAL_SUBTREE {
4028     pub Base: CERT_ALT_NAME_ENTRY,
4029     pub dwMinimum: u32,
4030     pub fMaximum: super::super::Foundation::BOOL,
4031     pub dwMaximum: u32,
4032 }
4033 #[cfg(feature = "Win32_Foundation")]
4034 impl CERT_GENERAL_SUBTREE {}
4035 #[cfg(feature = "Win32_Foundation")]
4036 impl ::std::default::Default for CERT_GENERAL_SUBTREE {
default() -> Self4037     fn default() -> Self {
4038         unsafe { ::std::mem::zeroed() }
4039     }
4040 }
4041 #[cfg(feature = "Win32_Foundation")]
4042 impl ::std::cmp::PartialEq for CERT_GENERAL_SUBTREE {
eq(&self, _other: &Self) -> bool4043     fn eq(&self, _other: &Self) -> bool {
4044         unimplemented!()
4045     }
4046 }
4047 #[cfg(feature = "Win32_Foundation")]
4048 impl ::std::cmp::Eq for CERT_GENERAL_SUBTREE {}
4049 #[cfg(feature = "Win32_Foundation")]
4050 unsafe impl ::windows::runtime::Abi for CERT_GENERAL_SUBTREE {
4051     type Abi = Self;
4052     type DefaultType = Self;
4053 }
4054 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4055 #[repr(C)]
4056 #[cfg(feature = "Win32_Foundation")]
4057 pub struct CERT_HASHED_URL {
4058     pub HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
4059     pub Hash: CRYPTOAPI_BLOB,
4060     pub pwszUrl: super::super::Foundation::PWSTR,
4061 }
4062 #[cfg(feature = "Win32_Foundation")]
4063 impl CERT_HASHED_URL {}
4064 #[cfg(feature = "Win32_Foundation")]
4065 impl ::std::default::Default for CERT_HASHED_URL {
default() -> Self4066     fn default() -> Self {
4067         unsafe { ::std::mem::zeroed() }
4068     }
4069 }
4070 #[cfg(feature = "Win32_Foundation")]
4071 impl ::std::fmt::Debug for CERT_HASHED_URL {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4072     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4073         fmt.debug_struct("CERT_HASHED_URL").field("HashAlgorithm", &self.HashAlgorithm).field("Hash", &self.Hash).field("pwszUrl", &self.pwszUrl).finish()
4074     }
4075 }
4076 #[cfg(feature = "Win32_Foundation")]
4077 impl ::std::cmp::PartialEq for CERT_HASHED_URL {
eq(&self, other: &Self) -> bool4078     fn eq(&self, other: &Self) -> bool {
4079         self.HashAlgorithm == other.HashAlgorithm && self.Hash == other.Hash && self.pwszUrl == other.pwszUrl
4080     }
4081 }
4082 #[cfg(feature = "Win32_Foundation")]
4083 impl ::std::cmp::Eq for CERT_HASHED_URL {}
4084 #[cfg(feature = "Win32_Foundation")]
4085 unsafe impl ::windows::runtime::Abi for CERT_HASHED_URL {
4086     type Abi = Self;
4087     type DefaultType = Self;
4088 }
4089 pub const CERT_HASH_PROP_ID: u32 = 3u32;
4090 pub const CERT_HCRYPTPROV_OR_NCRYPT_KEY_HANDLE_PROP_ID: u32 = 79u32;
4091 pub const CERT_HCRYPTPROV_TRANSFER_PROP_ID: u32 = 100u32;
4092 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4093 #[repr(C)]
4094 pub struct CERT_ID {
4095     pub dwIdChoice: CERT_ID_OPTION,
4096     pub Anonymous: CERT_ID_0,
4097 }
4098 impl CERT_ID {}
4099 impl ::std::default::Default for CERT_ID {
default() -> Self4100     fn default() -> Self {
4101         unsafe { ::std::mem::zeroed() }
4102     }
4103 }
4104 impl ::std::cmp::PartialEq for CERT_ID {
eq(&self, _other: &Self) -> bool4105     fn eq(&self, _other: &Self) -> bool {
4106         unimplemented!()
4107     }
4108 }
4109 impl ::std::cmp::Eq for CERT_ID {}
4110 unsafe impl ::windows::runtime::Abi for CERT_ID {
4111     type Abi = Self;
4112     type DefaultType = Self;
4113 }
4114 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4115 #[repr(C)]
4116 pub union CERT_ID_0 {
4117     pub IssuerSerialNumber: CERT_ISSUER_SERIAL_NUMBER,
4118     pub KeyId: CRYPTOAPI_BLOB,
4119     pub HashId: CRYPTOAPI_BLOB,
4120 }
4121 impl CERT_ID_0 {}
4122 impl ::std::default::Default for CERT_ID_0 {
default() -> Self4123     fn default() -> Self {
4124         unsafe { ::std::mem::zeroed() }
4125     }
4126 }
4127 impl ::std::cmp::PartialEq for CERT_ID_0 {
eq(&self, _other: &Self) -> bool4128     fn eq(&self, _other: &Self) -> bool {
4129         unimplemented!()
4130     }
4131 }
4132 impl ::std::cmp::Eq for CERT_ID_0 {}
4133 unsafe impl ::windows::runtime::Abi for CERT_ID_0 {
4134     type Abi = Self;
4135     type DefaultType = Self;
4136 }
4137 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4138 #[repr(transparent)]
4139 pub struct CERT_ID_OPTION(pub u32);
4140 pub const CERT_ID_ISSUER_SERIAL_NUMBER: CERT_ID_OPTION = CERT_ID_OPTION(1u32);
4141 pub const CERT_ID_KEY_IDENTIFIER: CERT_ID_OPTION = CERT_ID_OPTION(2u32);
4142 pub const CERT_ID_SHA1_HASH: CERT_ID_OPTION = CERT_ID_OPTION(3u32);
4143 impl ::std::convert::From<u32> for CERT_ID_OPTION {
from(value: u32) -> Self4144     fn from(value: u32) -> Self {
4145         Self(value)
4146     }
4147 }
4148 unsafe impl ::windows::runtime::Abi for CERT_ID_OPTION {
4149     type Abi = Self;
4150     type DefaultType = Self;
4151 }
4152 impl ::std::ops::BitOr for CERT_ID_OPTION {
4153     type Output = Self;
bitor(self, rhs: Self) -> Self4154     fn bitor(self, rhs: Self) -> Self {
4155         Self(self.0 | rhs.0)
4156     }
4157 }
4158 impl ::std::ops::BitAnd for CERT_ID_OPTION {
4159     type Output = Self;
bitand(self, rhs: Self) -> Self4160     fn bitand(self, rhs: Self) -> Self {
4161         Self(self.0 & rhs.0)
4162     }
4163 }
4164 impl ::std::ops::BitOrAssign for CERT_ID_OPTION {
bitor_assign(&mut self, rhs: Self)4165     fn bitor_assign(&mut self, rhs: Self) {
4166         self.0.bitor_assign(rhs.0)
4167     }
4168 }
4169 impl ::std::ops::BitAndAssign for CERT_ID_OPTION {
bitand_assign(&mut self, rhs: Self)4170     fn bitand_assign(&mut self, rhs: Self) {
4171         self.0.bitand_assign(rhs.0)
4172     }
4173 }
4174 impl ::std::ops::Not for CERT_ID_OPTION {
4175     type Output = Self;
not(self) -> Self4176     fn not(self) -> Self {
4177         Self(self.0.not())
4178     }
4179 }
4180 pub const CERT_IE30_RESERVED_PROP_ID: u32 = 7u32;
4181 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4182 #[repr(C)]
4183 #[cfg(feature = "Win32_Foundation")]
4184 pub struct CERT_INFO {
4185     pub dwVersion: u32,
4186     pub SerialNumber: CRYPTOAPI_BLOB,
4187     pub SignatureAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
4188     pub Issuer: CRYPTOAPI_BLOB,
4189     pub NotBefore: super::super::Foundation::FILETIME,
4190     pub NotAfter: super::super::Foundation::FILETIME,
4191     pub Subject: CRYPTOAPI_BLOB,
4192     pub SubjectPublicKeyInfo: CERT_PUBLIC_KEY_INFO,
4193     pub IssuerUniqueId: CRYPT_BIT_BLOB,
4194     pub SubjectUniqueId: CRYPT_BIT_BLOB,
4195     pub cExtension: u32,
4196     pub rgExtension: *mut CERT_EXTENSION,
4197 }
4198 #[cfg(feature = "Win32_Foundation")]
4199 impl CERT_INFO {}
4200 #[cfg(feature = "Win32_Foundation")]
4201 impl ::std::default::Default for CERT_INFO {
default() -> Self4202     fn default() -> Self {
4203         unsafe { ::std::mem::zeroed() }
4204     }
4205 }
4206 #[cfg(feature = "Win32_Foundation")]
4207 impl ::std::fmt::Debug for CERT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4208     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4209         fmt.debug_struct("CERT_INFO")
4210             .field("dwVersion", &self.dwVersion)
4211             .field("SerialNumber", &self.SerialNumber)
4212             .field("SignatureAlgorithm", &self.SignatureAlgorithm)
4213             .field("Issuer", &self.Issuer)
4214             .field("NotBefore", &self.NotBefore)
4215             .field("NotAfter", &self.NotAfter)
4216             .field("Subject", &self.Subject)
4217             .field("SubjectPublicKeyInfo", &self.SubjectPublicKeyInfo)
4218             .field("IssuerUniqueId", &self.IssuerUniqueId)
4219             .field("SubjectUniqueId", &self.SubjectUniqueId)
4220             .field("cExtension", &self.cExtension)
4221             .field("rgExtension", &self.rgExtension)
4222             .finish()
4223     }
4224 }
4225 #[cfg(feature = "Win32_Foundation")]
4226 impl ::std::cmp::PartialEq for CERT_INFO {
eq(&self, other: &Self) -> bool4227     fn eq(&self, other: &Self) -> bool {
4228         self.dwVersion == other.dwVersion
4229             && self.SerialNumber == other.SerialNumber
4230             && self.SignatureAlgorithm == other.SignatureAlgorithm
4231             && self.Issuer == other.Issuer
4232             && self.NotBefore == other.NotBefore
4233             && self.NotAfter == other.NotAfter
4234             && self.Subject == other.Subject
4235             && self.SubjectPublicKeyInfo == other.SubjectPublicKeyInfo
4236             && self.IssuerUniqueId == other.IssuerUniqueId
4237             && self.SubjectUniqueId == other.SubjectUniqueId
4238             && self.cExtension == other.cExtension
4239             && self.rgExtension == other.rgExtension
4240     }
4241 }
4242 #[cfg(feature = "Win32_Foundation")]
4243 impl ::std::cmp::Eq for CERT_INFO {}
4244 #[cfg(feature = "Win32_Foundation")]
4245 unsafe impl ::windows::runtime::Abi for CERT_INFO {
4246     type Abi = Self;
4247     type DefaultType = Self;
4248 }
4249 pub const CERT_INFO_EXTENSION_FLAG: u32 = 11u32;
4250 pub const CERT_INFO_ISSUER_FLAG: u32 = 4u32;
4251 pub const CERT_INFO_ISSUER_UNIQUE_ID_FLAG: u32 = 9u32;
4252 pub const CERT_INFO_NOT_AFTER_FLAG: u32 = 6u32;
4253 pub const CERT_INFO_NOT_BEFORE_FLAG: u32 = 5u32;
4254 pub const CERT_INFO_SERIAL_NUMBER_FLAG: u32 = 2u32;
4255 pub const CERT_INFO_SIGNATURE_ALGORITHM_FLAG: u32 = 3u32;
4256 pub const CERT_INFO_SUBJECT_FLAG: u32 = 7u32;
4257 pub const CERT_INFO_SUBJECT_PUBLIC_KEY_INFO_FLAG: u32 = 8u32;
4258 pub const CERT_INFO_SUBJECT_UNIQUE_ID_FLAG: u32 = 10u32;
4259 pub const CERT_INFO_VERSION_FLAG: u32 = 1u32;
4260 pub const CERT_ISOLATED_KEY_PROP_ID: u32 = 118u32;
4261 pub const CERT_ISSUER_CHAIN_PUB_KEY_CNG_ALG_BIT_LENGTH_PROP_ID: u32 = 96u32;
4262 pub const CERT_ISSUER_CHAIN_SIGN_HASH_CNG_ALG_PROP_ID: u32 = 95u32;
4263 pub const CERT_ISSUER_PUBLIC_KEY_MD5_HASH_PROP_ID: u32 = 24u32;
4264 pub const CERT_ISSUER_PUB_KEY_BIT_LENGTH_PROP_ID: u32 = 94u32;
4265 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4266 #[repr(C)]
4267 pub struct CERT_ISSUER_SERIAL_NUMBER {
4268     pub Issuer: CRYPTOAPI_BLOB,
4269     pub SerialNumber: CRYPTOAPI_BLOB,
4270 }
4271 impl CERT_ISSUER_SERIAL_NUMBER {}
4272 impl ::std::default::Default for CERT_ISSUER_SERIAL_NUMBER {
default() -> Self4273     fn default() -> Self {
4274         unsafe { ::std::mem::zeroed() }
4275     }
4276 }
4277 impl ::std::fmt::Debug for CERT_ISSUER_SERIAL_NUMBER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4278     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4279         fmt.debug_struct("CERT_ISSUER_SERIAL_NUMBER").field("Issuer", &self.Issuer).field("SerialNumber", &self.SerialNumber).finish()
4280     }
4281 }
4282 impl ::std::cmp::PartialEq for CERT_ISSUER_SERIAL_NUMBER {
eq(&self, other: &Self) -> bool4283     fn eq(&self, other: &Self) -> bool {
4284         self.Issuer == other.Issuer && self.SerialNumber == other.SerialNumber
4285     }
4286 }
4287 impl ::std::cmp::Eq for CERT_ISSUER_SERIAL_NUMBER {}
4288 unsafe impl ::windows::runtime::Abi for CERT_ISSUER_SERIAL_NUMBER {
4289     type Abi = Self;
4290     type DefaultType = Self;
4291 }
4292 pub const CERT_ISSUER_SERIAL_NUMBER_MD5_HASH_PROP_ID: u32 = 28u32;
4293 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4294 #[repr(C)]
4295 #[cfg(feature = "Win32_Foundation")]
4296 pub struct CERT_KEYGEN_REQUEST_INFO {
4297     pub dwVersion: u32,
4298     pub SubjectPublicKeyInfo: CERT_PUBLIC_KEY_INFO,
4299     pub pwszChallengeString: super::super::Foundation::PWSTR,
4300 }
4301 #[cfg(feature = "Win32_Foundation")]
4302 impl CERT_KEYGEN_REQUEST_INFO {}
4303 #[cfg(feature = "Win32_Foundation")]
4304 impl ::std::default::Default for CERT_KEYGEN_REQUEST_INFO {
default() -> Self4305     fn default() -> Self {
4306         unsafe { ::std::mem::zeroed() }
4307     }
4308 }
4309 #[cfg(feature = "Win32_Foundation")]
4310 impl ::std::fmt::Debug for CERT_KEYGEN_REQUEST_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4311     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4312         fmt.debug_struct("CERT_KEYGEN_REQUEST_INFO").field("dwVersion", &self.dwVersion).field("SubjectPublicKeyInfo", &self.SubjectPublicKeyInfo).field("pwszChallengeString", &self.pwszChallengeString).finish()
4313     }
4314 }
4315 #[cfg(feature = "Win32_Foundation")]
4316 impl ::std::cmp::PartialEq for CERT_KEYGEN_REQUEST_INFO {
eq(&self, other: &Self) -> bool4317     fn eq(&self, other: &Self) -> bool {
4318         self.dwVersion == other.dwVersion && self.SubjectPublicKeyInfo == other.SubjectPublicKeyInfo && self.pwszChallengeString == other.pwszChallengeString
4319     }
4320 }
4321 #[cfg(feature = "Win32_Foundation")]
4322 impl ::std::cmp::Eq for CERT_KEYGEN_REQUEST_INFO {}
4323 #[cfg(feature = "Win32_Foundation")]
4324 unsafe impl ::windows::runtime::Abi for CERT_KEYGEN_REQUEST_INFO {
4325     type Abi = Self;
4326     type DefaultType = Self;
4327 }
4328 pub const CERT_KEYGEN_REQUEST_V1: u32 = 0u32;
4329 pub const CERT_KEY_AGREEMENT_KEY_USAGE: u32 = 8u32;
4330 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4331 #[repr(C)]
4332 #[cfg(feature = "Win32_Foundation")]
4333 pub struct CERT_KEY_ATTRIBUTES_INFO {
4334     pub KeyId: CRYPTOAPI_BLOB,
4335     pub IntendedKeyUsage: CRYPT_BIT_BLOB,
4336     pub pPrivateKeyUsagePeriod: *mut CERT_PRIVATE_KEY_VALIDITY,
4337 }
4338 #[cfg(feature = "Win32_Foundation")]
4339 impl CERT_KEY_ATTRIBUTES_INFO {}
4340 #[cfg(feature = "Win32_Foundation")]
4341 impl ::std::default::Default for CERT_KEY_ATTRIBUTES_INFO {
default() -> Self4342     fn default() -> Self {
4343         unsafe { ::std::mem::zeroed() }
4344     }
4345 }
4346 #[cfg(feature = "Win32_Foundation")]
4347 impl ::std::fmt::Debug for CERT_KEY_ATTRIBUTES_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4348     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4349         fmt.debug_struct("CERT_KEY_ATTRIBUTES_INFO").field("KeyId", &self.KeyId).field("IntendedKeyUsage", &self.IntendedKeyUsage).field("pPrivateKeyUsagePeriod", &self.pPrivateKeyUsagePeriod).finish()
4350     }
4351 }
4352 #[cfg(feature = "Win32_Foundation")]
4353 impl ::std::cmp::PartialEq for CERT_KEY_ATTRIBUTES_INFO {
eq(&self, other: &Self) -> bool4354     fn eq(&self, other: &Self) -> bool {
4355         self.KeyId == other.KeyId && self.IntendedKeyUsage == other.IntendedKeyUsage && self.pPrivateKeyUsagePeriod == other.pPrivateKeyUsagePeriod
4356     }
4357 }
4358 #[cfg(feature = "Win32_Foundation")]
4359 impl ::std::cmp::Eq for CERT_KEY_ATTRIBUTES_INFO {}
4360 #[cfg(feature = "Win32_Foundation")]
4361 unsafe impl ::windows::runtime::Abi for CERT_KEY_ATTRIBUTES_INFO {
4362     type Abi = Self;
4363     type DefaultType = Self;
4364 }
4365 pub const CERT_KEY_CERT_SIGN_KEY_USAGE: u32 = 4u32;
4366 pub const CERT_KEY_CLASSIFICATION_PROP_ID: u32 = 120u32;
4367 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4368 #[repr(C)]
4369 pub struct CERT_KEY_CONTEXT {
4370     pub cbSize: u32,
4371     pub Anonymous: CERT_KEY_CONTEXT_0,
4372     pub dwKeySpec: u32,
4373 }
4374 impl CERT_KEY_CONTEXT {}
4375 impl ::std::default::Default for CERT_KEY_CONTEXT {
default() -> Self4376     fn default() -> Self {
4377         unsafe { ::std::mem::zeroed() }
4378     }
4379 }
4380 impl ::std::cmp::PartialEq for CERT_KEY_CONTEXT {
eq(&self, _other: &Self) -> bool4381     fn eq(&self, _other: &Self) -> bool {
4382         unimplemented!()
4383     }
4384 }
4385 impl ::std::cmp::Eq for CERT_KEY_CONTEXT {}
4386 unsafe impl ::windows::runtime::Abi for CERT_KEY_CONTEXT {
4387     type Abi = Self;
4388     type DefaultType = Self;
4389 }
4390 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4391 #[repr(C)]
4392 pub union CERT_KEY_CONTEXT_0 {
4393     pub hCryptProv: usize,
4394     pub hNCryptKey: usize,
4395 }
4396 impl CERT_KEY_CONTEXT_0 {}
4397 impl ::std::default::Default for CERT_KEY_CONTEXT_0 {
default() -> Self4398     fn default() -> Self {
4399         unsafe { ::std::mem::zeroed() }
4400     }
4401 }
4402 impl ::std::cmp::PartialEq for CERT_KEY_CONTEXT_0 {
eq(&self, _other: &Self) -> bool4403     fn eq(&self, _other: &Self) -> bool {
4404         unimplemented!()
4405     }
4406 }
4407 impl ::std::cmp::Eq for CERT_KEY_CONTEXT_0 {}
4408 unsafe impl ::windows::runtime::Abi for CERT_KEY_CONTEXT_0 {
4409     type Abi = Self;
4410     type DefaultType = Self;
4411 }
4412 pub const CERT_KEY_CONTEXT_PROP_ID: u32 = 5u32;
4413 pub const CERT_KEY_ENCIPHERMENT_KEY_USAGE: u32 = 32u32;
4414 pub const CERT_KEY_IDENTIFIER_PROP_ID: u32 = 20u32;
4415 pub const CERT_KEY_PROV_HANDLE_PROP_ID: u32 = 1u32;
4416 pub const CERT_KEY_PROV_INFO_PROP_ID: u32 = 2u32;
4417 pub const CERT_KEY_REPAIR_ATTEMPTED_PROP_ID: u32 = 103u32;
4418 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4419 #[repr(transparent)]
4420 pub struct CERT_KEY_SPEC(pub u32);
4421 pub const AT_KEYEXCHANGE: CERT_KEY_SPEC = CERT_KEY_SPEC(1u32);
4422 pub const AT_SIGNATURE: CERT_KEY_SPEC = CERT_KEY_SPEC(2u32);
4423 pub const CERT_NCRYPT_KEY_SPEC: CERT_KEY_SPEC = CERT_KEY_SPEC(4294967295u32);
4424 impl ::std::convert::From<u32> for CERT_KEY_SPEC {
from(value: u32) -> Self4425     fn from(value: u32) -> Self {
4426         Self(value)
4427     }
4428 }
4429 unsafe impl ::windows::runtime::Abi for CERT_KEY_SPEC {
4430     type Abi = Self;
4431     type DefaultType = Self;
4432 }
4433 impl ::std::ops::BitOr for CERT_KEY_SPEC {
4434     type Output = Self;
bitor(self, rhs: Self) -> Self4435     fn bitor(self, rhs: Self) -> Self {
4436         Self(self.0 | rhs.0)
4437     }
4438 }
4439 impl ::std::ops::BitAnd for CERT_KEY_SPEC {
4440     type Output = Self;
bitand(self, rhs: Self) -> Self4441     fn bitand(self, rhs: Self) -> Self {
4442         Self(self.0 & rhs.0)
4443     }
4444 }
4445 impl ::std::ops::BitOrAssign for CERT_KEY_SPEC {
bitor_assign(&mut self, rhs: Self)4446     fn bitor_assign(&mut self, rhs: Self) {
4447         self.0.bitor_assign(rhs.0)
4448     }
4449 }
4450 impl ::std::ops::BitAndAssign for CERT_KEY_SPEC {
bitand_assign(&mut self, rhs: Self)4451     fn bitand_assign(&mut self, rhs: Self) {
4452         self.0.bitand_assign(rhs.0)
4453     }
4454 }
4455 impl ::std::ops::Not for CERT_KEY_SPEC {
4456     type Output = Self;
not(self) -> Self4457     fn not(self) -> Self {
4458         Self(self.0.not())
4459     }
4460 }
4461 pub const CERT_KEY_SPEC_PROP_ID: u32 = 6u32;
4462 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4463 #[repr(C)]
4464 #[cfg(feature = "Win32_Foundation")]
4465 pub struct CERT_KEY_USAGE_RESTRICTION_INFO {
4466     pub cCertPolicyId: u32,
4467     pub rgCertPolicyId: *mut CERT_POLICY_ID,
4468     pub RestrictedKeyUsage: CRYPT_BIT_BLOB,
4469 }
4470 #[cfg(feature = "Win32_Foundation")]
4471 impl CERT_KEY_USAGE_RESTRICTION_INFO {}
4472 #[cfg(feature = "Win32_Foundation")]
4473 impl ::std::default::Default for CERT_KEY_USAGE_RESTRICTION_INFO {
default() -> Self4474     fn default() -> Self {
4475         unsafe { ::std::mem::zeroed() }
4476     }
4477 }
4478 #[cfg(feature = "Win32_Foundation")]
4479 impl ::std::fmt::Debug for CERT_KEY_USAGE_RESTRICTION_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4480     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4481         fmt.debug_struct("CERT_KEY_USAGE_RESTRICTION_INFO").field("cCertPolicyId", &self.cCertPolicyId).field("rgCertPolicyId", &self.rgCertPolicyId).field("RestrictedKeyUsage", &self.RestrictedKeyUsage).finish()
4482     }
4483 }
4484 #[cfg(feature = "Win32_Foundation")]
4485 impl ::std::cmp::PartialEq for CERT_KEY_USAGE_RESTRICTION_INFO {
eq(&self, other: &Self) -> bool4486     fn eq(&self, other: &Self) -> bool {
4487         self.cCertPolicyId == other.cCertPolicyId && self.rgCertPolicyId == other.rgCertPolicyId && self.RestrictedKeyUsage == other.RestrictedKeyUsage
4488     }
4489 }
4490 #[cfg(feature = "Win32_Foundation")]
4491 impl ::std::cmp::Eq for CERT_KEY_USAGE_RESTRICTION_INFO {}
4492 #[cfg(feature = "Win32_Foundation")]
4493 unsafe impl ::windows::runtime::Abi for CERT_KEY_USAGE_RESTRICTION_INFO {
4494     type Abi = Self;
4495     type DefaultType = Self;
4496 }
4497 pub const CERT_LAST_RESERVED_PROP_ID: u32 = 32767u32;
4498 pub const CERT_LAST_USER_PROP_ID: u32 = 65535u32;
4499 pub const CERT_LDAP_STORE_AREC_EXCLUSIVE_FLAG: u32 = 131072u32;
4500 pub const CERT_LDAP_STORE_OPENED_FLAG: u32 = 262144u32;
4501 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4502 #[repr(C)]
4503 #[cfg(feature = "Win32_Foundation")]
4504 pub struct CERT_LDAP_STORE_OPENED_PARA {
4505     pub pvLdapSessionHandle: *mut ::std::ffi::c_void,
4506     pub pwszLdapUrl: super::super::Foundation::PWSTR,
4507 }
4508 #[cfg(feature = "Win32_Foundation")]
4509 impl CERT_LDAP_STORE_OPENED_PARA {}
4510 #[cfg(feature = "Win32_Foundation")]
4511 impl ::std::default::Default for CERT_LDAP_STORE_OPENED_PARA {
default() -> Self4512     fn default() -> Self {
4513         unsafe { ::std::mem::zeroed() }
4514     }
4515 }
4516 #[cfg(feature = "Win32_Foundation")]
4517 impl ::std::fmt::Debug for CERT_LDAP_STORE_OPENED_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4518     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4519         fmt.debug_struct("CERT_LDAP_STORE_OPENED_PARA").field("pvLdapSessionHandle", &self.pvLdapSessionHandle).field("pwszLdapUrl", &self.pwszLdapUrl).finish()
4520     }
4521 }
4522 #[cfg(feature = "Win32_Foundation")]
4523 impl ::std::cmp::PartialEq for CERT_LDAP_STORE_OPENED_PARA {
eq(&self, other: &Self) -> bool4524     fn eq(&self, other: &Self) -> bool {
4525         self.pvLdapSessionHandle == other.pvLdapSessionHandle && self.pwszLdapUrl == other.pwszLdapUrl
4526     }
4527 }
4528 #[cfg(feature = "Win32_Foundation")]
4529 impl ::std::cmp::Eq for CERT_LDAP_STORE_OPENED_PARA {}
4530 #[cfg(feature = "Win32_Foundation")]
4531 unsafe impl ::windows::runtime::Abi for CERT_LDAP_STORE_OPENED_PARA {
4532     type Abi = Self;
4533     type DefaultType = Self;
4534 }
4535 pub const CERT_LDAP_STORE_SIGN_FLAG: u32 = 65536u32;
4536 pub const CERT_LDAP_STORE_UNBIND_FLAG: u32 = 524288u32;
4537 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4538 #[repr(C)]
4539 #[cfg(feature = "Win32_Foundation")]
4540 pub struct CERT_LOGOTYPE_AUDIO {
4541     pub LogotypeDetails: CERT_LOGOTYPE_DETAILS,
4542     pub pLogotypeAudioInfo: *mut CERT_LOGOTYPE_AUDIO_INFO,
4543 }
4544 #[cfg(feature = "Win32_Foundation")]
4545 impl CERT_LOGOTYPE_AUDIO {}
4546 #[cfg(feature = "Win32_Foundation")]
4547 impl ::std::default::Default for CERT_LOGOTYPE_AUDIO {
default() -> Self4548     fn default() -> Self {
4549         unsafe { ::std::mem::zeroed() }
4550     }
4551 }
4552 #[cfg(feature = "Win32_Foundation")]
4553 impl ::std::fmt::Debug for CERT_LOGOTYPE_AUDIO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4554     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4555         fmt.debug_struct("CERT_LOGOTYPE_AUDIO").field("LogotypeDetails", &self.LogotypeDetails).field("pLogotypeAudioInfo", &self.pLogotypeAudioInfo).finish()
4556     }
4557 }
4558 #[cfg(feature = "Win32_Foundation")]
4559 impl ::std::cmp::PartialEq for CERT_LOGOTYPE_AUDIO {
eq(&self, other: &Self) -> bool4560     fn eq(&self, other: &Self) -> bool {
4561         self.LogotypeDetails == other.LogotypeDetails && self.pLogotypeAudioInfo == other.pLogotypeAudioInfo
4562     }
4563 }
4564 #[cfg(feature = "Win32_Foundation")]
4565 impl ::std::cmp::Eq for CERT_LOGOTYPE_AUDIO {}
4566 #[cfg(feature = "Win32_Foundation")]
4567 unsafe impl ::windows::runtime::Abi for CERT_LOGOTYPE_AUDIO {
4568     type Abi = Self;
4569     type DefaultType = Self;
4570 }
4571 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4572 #[repr(C)]
4573 #[cfg(feature = "Win32_Foundation")]
4574 pub struct CERT_LOGOTYPE_AUDIO_INFO {
4575     pub dwFileSize: u32,
4576     pub dwPlayTime: u32,
4577     pub dwChannels: u32,
4578     pub dwSampleRate: u32,
4579     pub pwszLanguage: super::super::Foundation::PWSTR,
4580 }
4581 #[cfg(feature = "Win32_Foundation")]
4582 impl CERT_LOGOTYPE_AUDIO_INFO {}
4583 #[cfg(feature = "Win32_Foundation")]
4584 impl ::std::default::Default for CERT_LOGOTYPE_AUDIO_INFO {
default() -> Self4585     fn default() -> Self {
4586         unsafe { ::std::mem::zeroed() }
4587     }
4588 }
4589 #[cfg(feature = "Win32_Foundation")]
4590 impl ::std::fmt::Debug for CERT_LOGOTYPE_AUDIO_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4591     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4592         fmt.debug_struct("CERT_LOGOTYPE_AUDIO_INFO").field("dwFileSize", &self.dwFileSize).field("dwPlayTime", &self.dwPlayTime).field("dwChannels", &self.dwChannels).field("dwSampleRate", &self.dwSampleRate).field("pwszLanguage", &self.pwszLanguage).finish()
4593     }
4594 }
4595 #[cfg(feature = "Win32_Foundation")]
4596 impl ::std::cmp::PartialEq for CERT_LOGOTYPE_AUDIO_INFO {
eq(&self, other: &Self) -> bool4597     fn eq(&self, other: &Self) -> bool {
4598         self.dwFileSize == other.dwFileSize && self.dwPlayTime == other.dwPlayTime && self.dwChannels == other.dwChannels && self.dwSampleRate == other.dwSampleRate && self.pwszLanguage == other.pwszLanguage
4599     }
4600 }
4601 #[cfg(feature = "Win32_Foundation")]
4602 impl ::std::cmp::Eq for CERT_LOGOTYPE_AUDIO_INFO {}
4603 #[cfg(feature = "Win32_Foundation")]
4604 unsafe impl ::windows::runtime::Abi for CERT_LOGOTYPE_AUDIO_INFO {
4605     type Abi = Self;
4606     type DefaultType = Self;
4607 }
4608 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4609 #[repr(transparent)]
4610 pub struct CERT_LOGOTYPE_CHOICE(pub u32);
4611 pub const CERT_LOGOTYPE_NO_IMAGE_RESOLUTION_CHOICE: CERT_LOGOTYPE_CHOICE = CERT_LOGOTYPE_CHOICE(0u32);
4612 pub const CERT_LOGOTYPE_BITS_IMAGE_RESOLUTION_CHOICE: CERT_LOGOTYPE_CHOICE = CERT_LOGOTYPE_CHOICE(1u32);
4613 pub const CERT_LOGOTYPE_TABLE_SIZE_IMAGE_RESOLUTION_CHOICE: CERT_LOGOTYPE_CHOICE = CERT_LOGOTYPE_CHOICE(2u32);
4614 impl ::std::convert::From<u32> for CERT_LOGOTYPE_CHOICE {
from(value: u32) -> Self4615     fn from(value: u32) -> Self {
4616         Self(value)
4617     }
4618 }
4619 unsafe impl ::windows::runtime::Abi for CERT_LOGOTYPE_CHOICE {
4620     type Abi = Self;
4621     type DefaultType = Self;
4622 }
4623 impl ::std::ops::BitOr for CERT_LOGOTYPE_CHOICE {
4624     type Output = Self;
bitor(self, rhs: Self) -> Self4625     fn bitor(self, rhs: Self) -> Self {
4626         Self(self.0 | rhs.0)
4627     }
4628 }
4629 impl ::std::ops::BitAnd for CERT_LOGOTYPE_CHOICE {
4630     type Output = Self;
bitand(self, rhs: Self) -> Self4631     fn bitand(self, rhs: Self) -> Self {
4632         Self(self.0 & rhs.0)
4633     }
4634 }
4635 impl ::std::ops::BitOrAssign for CERT_LOGOTYPE_CHOICE {
bitor_assign(&mut self, rhs: Self)4636     fn bitor_assign(&mut self, rhs: Self) {
4637         self.0.bitor_assign(rhs.0)
4638     }
4639 }
4640 impl ::std::ops::BitAndAssign for CERT_LOGOTYPE_CHOICE {
bitand_assign(&mut self, rhs: Self)4641     fn bitand_assign(&mut self, rhs: Self) {
4642         self.0.bitand_assign(rhs.0)
4643     }
4644 }
4645 impl ::std::ops::Not for CERT_LOGOTYPE_CHOICE {
4646     type Output = Self;
not(self) -> Self4647     fn not(self) -> Self {
4648         Self(self.0.not())
4649     }
4650 }
4651 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4652 #[repr(C)]
4653 #[cfg(feature = "Win32_Foundation")]
4654 pub struct CERT_LOGOTYPE_DATA {
4655     pub cLogotypeImage: u32,
4656     pub rgLogotypeImage: *mut CERT_LOGOTYPE_IMAGE,
4657     pub cLogotypeAudio: u32,
4658     pub rgLogotypeAudio: *mut CERT_LOGOTYPE_AUDIO,
4659 }
4660 #[cfg(feature = "Win32_Foundation")]
4661 impl CERT_LOGOTYPE_DATA {}
4662 #[cfg(feature = "Win32_Foundation")]
4663 impl ::std::default::Default for CERT_LOGOTYPE_DATA {
default() -> Self4664     fn default() -> Self {
4665         unsafe { ::std::mem::zeroed() }
4666     }
4667 }
4668 #[cfg(feature = "Win32_Foundation")]
4669 impl ::std::fmt::Debug for CERT_LOGOTYPE_DATA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4670     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4671         fmt.debug_struct("CERT_LOGOTYPE_DATA").field("cLogotypeImage", &self.cLogotypeImage).field("rgLogotypeImage", &self.rgLogotypeImage).field("cLogotypeAudio", &self.cLogotypeAudio).field("rgLogotypeAudio", &self.rgLogotypeAudio).finish()
4672     }
4673 }
4674 #[cfg(feature = "Win32_Foundation")]
4675 impl ::std::cmp::PartialEq for CERT_LOGOTYPE_DATA {
eq(&self, other: &Self) -> bool4676     fn eq(&self, other: &Self) -> bool {
4677         self.cLogotypeImage == other.cLogotypeImage && self.rgLogotypeImage == other.rgLogotypeImage && self.cLogotypeAudio == other.cLogotypeAudio && self.rgLogotypeAudio == other.rgLogotypeAudio
4678     }
4679 }
4680 #[cfg(feature = "Win32_Foundation")]
4681 impl ::std::cmp::Eq for CERT_LOGOTYPE_DATA {}
4682 #[cfg(feature = "Win32_Foundation")]
4683 unsafe impl ::windows::runtime::Abi for CERT_LOGOTYPE_DATA {
4684     type Abi = Self;
4685     type DefaultType = Self;
4686 }
4687 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4688 #[repr(C)]
4689 #[cfg(feature = "Win32_Foundation")]
4690 pub struct CERT_LOGOTYPE_DETAILS {
4691     pub pwszMimeType: super::super::Foundation::PWSTR,
4692     pub cHashedUrl: u32,
4693     pub rgHashedUrl: *mut CERT_HASHED_URL,
4694 }
4695 #[cfg(feature = "Win32_Foundation")]
4696 impl CERT_LOGOTYPE_DETAILS {}
4697 #[cfg(feature = "Win32_Foundation")]
4698 impl ::std::default::Default for CERT_LOGOTYPE_DETAILS {
default() -> Self4699     fn default() -> Self {
4700         unsafe { ::std::mem::zeroed() }
4701     }
4702 }
4703 #[cfg(feature = "Win32_Foundation")]
4704 impl ::std::fmt::Debug for CERT_LOGOTYPE_DETAILS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4705     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4706         fmt.debug_struct("CERT_LOGOTYPE_DETAILS").field("pwszMimeType", &self.pwszMimeType).field("cHashedUrl", &self.cHashedUrl).field("rgHashedUrl", &self.rgHashedUrl).finish()
4707     }
4708 }
4709 #[cfg(feature = "Win32_Foundation")]
4710 impl ::std::cmp::PartialEq for CERT_LOGOTYPE_DETAILS {
eq(&self, other: &Self) -> bool4711     fn eq(&self, other: &Self) -> bool {
4712         self.pwszMimeType == other.pwszMimeType && self.cHashedUrl == other.cHashedUrl && self.rgHashedUrl == other.rgHashedUrl
4713     }
4714 }
4715 #[cfg(feature = "Win32_Foundation")]
4716 impl ::std::cmp::Eq for CERT_LOGOTYPE_DETAILS {}
4717 #[cfg(feature = "Win32_Foundation")]
4718 unsafe impl ::windows::runtime::Abi for CERT_LOGOTYPE_DETAILS {
4719     type Abi = Self;
4720     type DefaultType = Self;
4721 }
4722 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4723 #[repr(C)]
4724 #[cfg(feature = "Win32_Foundation")]
4725 pub struct CERT_LOGOTYPE_EXT_INFO {
4726     pub cCommunityLogo: u32,
4727     pub rgCommunityLogo: *mut CERT_LOGOTYPE_INFO,
4728     pub pIssuerLogo: *mut CERT_LOGOTYPE_INFO,
4729     pub pSubjectLogo: *mut CERT_LOGOTYPE_INFO,
4730     pub cOtherLogo: u32,
4731     pub rgOtherLogo: *mut CERT_OTHER_LOGOTYPE_INFO,
4732 }
4733 #[cfg(feature = "Win32_Foundation")]
4734 impl CERT_LOGOTYPE_EXT_INFO {}
4735 #[cfg(feature = "Win32_Foundation")]
4736 impl ::std::default::Default for CERT_LOGOTYPE_EXT_INFO {
default() -> Self4737     fn default() -> Self {
4738         unsafe { ::std::mem::zeroed() }
4739     }
4740 }
4741 #[cfg(feature = "Win32_Foundation")]
4742 impl ::std::fmt::Debug for CERT_LOGOTYPE_EXT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4743     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4744         fmt.debug_struct("CERT_LOGOTYPE_EXT_INFO")
4745             .field("cCommunityLogo", &self.cCommunityLogo)
4746             .field("rgCommunityLogo", &self.rgCommunityLogo)
4747             .field("pIssuerLogo", &self.pIssuerLogo)
4748             .field("pSubjectLogo", &self.pSubjectLogo)
4749             .field("cOtherLogo", &self.cOtherLogo)
4750             .field("rgOtherLogo", &self.rgOtherLogo)
4751             .finish()
4752     }
4753 }
4754 #[cfg(feature = "Win32_Foundation")]
4755 impl ::std::cmp::PartialEq for CERT_LOGOTYPE_EXT_INFO {
eq(&self, other: &Self) -> bool4756     fn eq(&self, other: &Self) -> bool {
4757         self.cCommunityLogo == other.cCommunityLogo && self.rgCommunityLogo == other.rgCommunityLogo && self.pIssuerLogo == other.pIssuerLogo && self.pSubjectLogo == other.pSubjectLogo && self.cOtherLogo == other.cOtherLogo && self.rgOtherLogo == other.rgOtherLogo
4758     }
4759 }
4760 #[cfg(feature = "Win32_Foundation")]
4761 impl ::std::cmp::Eq for CERT_LOGOTYPE_EXT_INFO {}
4762 #[cfg(feature = "Win32_Foundation")]
4763 unsafe impl ::windows::runtime::Abi for CERT_LOGOTYPE_EXT_INFO {
4764     type Abi = Self;
4765     type DefaultType = Self;
4766 }
4767 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4768 #[repr(C)]
4769 #[cfg(feature = "Win32_Foundation")]
4770 pub struct CERT_LOGOTYPE_IMAGE {
4771     pub LogotypeDetails: CERT_LOGOTYPE_DETAILS,
4772     pub pLogotypeImageInfo: *mut CERT_LOGOTYPE_IMAGE_INFO,
4773 }
4774 #[cfg(feature = "Win32_Foundation")]
4775 impl CERT_LOGOTYPE_IMAGE {}
4776 #[cfg(feature = "Win32_Foundation")]
4777 impl ::std::default::Default for CERT_LOGOTYPE_IMAGE {
default() -> Self4778     fn default() -> Self {
4779         unsafe { ::std::mem::zeroed() }
4780     }
4781 }
4782 #[cfg(feature = "Win32_Foundation")]
4783 impl ::std::fmt::Debug for CERT_LOGOTYPE_IMAGE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4784     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4785         fmt.debug_struct("CERT_LOGOTYPE_IMAGE").field("LogotypeDetails", &self.LogotypeDetails).field("pLogotypeImageInfo", &self.pLogotypeImageInfo).finish()
4786     }
4787 }
4788 #[cfg(feature = "Win32_Foundation")]
4789 impl ::std::cmp::PartialEq for CERT_LOGOTYPE_IMAGE {
eq(&self, other: &Self) -> bool4790     fn eq(&self, other: &Self) -> bool {
4791         self.LogotypeDetails == other.LogotypeDetails && self.pLogotypeImageInfo == other.pLogotypeImageInfo
4792     }
4793 }
4794 #[cfg(feature = "Win32_Foundation")]
4795 impl ::std::cmp::Eq for CERT_LOGOTYPE_IMAGE {}
4796 #[cfg(feature = "Win32_Foundation")]
4797 unsafe impl ::windows::runtime::Abi for CERT_LOGOTYPE_IMAGE {
4798     type Abi = Self;
4799     type DefaultType = Self;
4800 }
4801 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4802 #[repr(C)]
4803 #[cfg(feature = "Win32_Foundation")]
4804 pub struct CERT_LOGOTYPE_IMAGE_INFO {
4805     pub dwLogotypeImageInfoChoice: CERT_LOGOTYPE_IMAGE_INFO_TYPE,
4806     pub dwFileSize: u32,
4807     pub dwXSize: u32,
4808     pub dwYSize: u32,
4809     pub dwLogotypeImageResolutionChoice: CERT_LOGOTYPE_CHOICE,
4810     pub Anonymous: CERT_LOGOTYPE_IMAGE_INFO_0,
4811     pub pwszLanguage: super::super::Foundation::PWSTR,
4812 }
4813 #[cfg(feature = "Win32_Foundation")]
4814 impl CERT_LOGOTYPE_IMAGE_INFO {}
4815 #[cfg(feature = "Win32_Foundation")]
4816 impl ::std::default::Default for CERT_LOGOTYPE_IMAGE_INFO {
default() -> Self4817     fn default() -> Self {
4818         unsafe { ::std::mem::zeroed() }
4819     }
4820 }
4821 #[cfg(feature = "Win32_Foundation")]
4822 impl ::std::cmp::PartialEq for CERT_LOGOTYPE_IMAGE_INFO {
eq(&self, _other: &Self) -> bool4823     fn eq(&self, _other: &Self) -> bool {
4824         unimplemented!()
4825     }
4826 }
4827 #[cfg(feature = "Win32_Foundation")]
4828 impl ::std::cmp::Eq for CERT_LOGOTYPE_IMAGE_INFO {}
4829 #[cfg(feature = "Win32_Foundation")]
4830 unsafe impl ::windows::runtime::Abi for CERT_LOGOTYPE_IMAGE_INFO {
4831     type Abi = Self;
4832     type DefaultType = Self;
4833 }
4834 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4835 #[repr(C)]
4836 pub union CERT_LOGOTYPE_IMAGE_INFO_0 {
4837     pub dwNumBits: u32,
4838     pub dwTableSize: u32,
4839 }
4840 impl CERT_LOGOTYPE_IMAGE_INFO_0 {}
4841 impl ::std::default::Default for CERT_LOGOTYPE_IMAGE_INFO_0 {
default() -> Self4842     fn default() -> Self {
4843         unsafe { ::std::mem::zeroed() }
4844     }
4845 }
4846 impl ::std::cmp::PartialEq for CERT_LOGOTYPE_IMAGE_INFO_0 {
eq(&self, _other: &Self) -> bool4847     fn eq(&self, _other: &Self) -> bool {
4848         unimplemented!()
4849     }
4850 }
4851 impl ::std::cmp::Eq for CERT_LOGOTYPE_IMAGE_INFO_0 {}
4852 unsafe impl ::windows::runtime::Abi for CERT_LOGOTYPE_IMAGE_INFO_0 {
4853     type Abi = Self;
4854     type DefaultType = Self;
4855 }
4856 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4857 #[repr(transparent)]
4858 pub struct CERT_LOGOTYPE_IMAGE_INFO_TYPE(pub u32);
4859 pub const CERT_LOGOTYPE_GRAY_SCALE_IMAGE_INFO_CHOICE: CERT_LOGOTYPE_IMAGE_INFO_TYPE = CERT_LOGOTYPE_IMAGE_INFO_TYPE(1u32);
4860 pub const CERT_LOGOTYPE_COLOR_IMAGE_INFO_CHOICE: CERT_LOGOTYPE_IMAGE_INFO_TYPE = CERT_LOGOTYPE_IMAGE_INFO_TYPE(2u32);
4861 impl ::std::convert::From<u32> for CERT_LOGOTYPE_IMAGE_INFO_TYPE {
from(value: u32) -> Self4862     fn from(value: u32) -> Self {
4863         Self(value)
4864     }
4865 }
4866 unsafe impl ::windows::runtime::Abi for CERT_LOGOTYPE_IMAGE_INFO_TYPE {
4867     type Abi = Self;
4868     type DefaultType = Self;
4869 }
4870 impl ::std::ops::BitOr for CERT_LOGOTYPE_IMAGE_INFO_TYPE {
4871     type Output = Self;
bitor(self, rhs: Self) -> Self4872     fn bitor(self, rhs: Self) -> Self {
4873         Self(self.0 | rhs.0)
4874     }
4875 }
4876 impl ::std::ops::BitAnd for CERT_LOGOTYPE_IMAGE_INFO_TYPE {
4877     type Output = Self;
bitand(self, rhs: Self) -> Self4878     fn bitand(self, rhs: Self) -> Self {
4879         Self(self.0 & rhs.0)
4880     }
4881 }
4882 impl ::std::ops::BitOrAssign for CERT_LOGOTYPE_IMAGE_INFO_TYPE {
bitor_assign(&mut self, rhs: Self)4883     fn bitor_assign(&mut self, rhs: Self) {
4884         self.0.bitor_assign(rhs.0)
4885     }
4886 }
4887 impl ::std::ops::BitAndAssign for CERT_LOGOTYPE_IMAGE_INFO_TYPE {
bitand_assign(&mut self, rhs: Self)4888     fn bitand_assign(&mut self, rhs: Self) {
4889         self.0.bitand_assign(rhs.0)
4890     }
4891 }
4892 impl ::std::ops::Not for CERT_LOGOTYPE_IMAGE_INFO_TYPE {
4893     type Output = Self;
not(self) -> Self4894     fn not(self) -> Self {
4895         Self(self.0.not())
4896     }
4897 }
4898 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4899 #[repr(C)]
4900 #[cfg(feature = "Win32_Foundation")]
4901 pub struct CERT_LOGOTYPE_INFO {
4902     pub dwLogotypeInfoChoice: CERT_LOGOTYPE_OPTION,
4903     pub Anonymous: CERT_LOGOTYPE_INFO_0,
4904 }
4905 #[cfg(feature = "Win32_Foundation")]
4906 impl CERT_LOGOTYPE_INFO {}
4907 #[cfg(feature = "Win32_Foundation")]
4908 impl ::std::default::Default for CERT_LOGOTYPE_INFO {
default() -> Self4909     fn default() -> Self {
4910         unsafe { ::std::mem::zeroed() }
4911     }
4912 }
4913 #[cfg(feature = "Win32_Foundation")]
4914 impl ::std::cmp::PartialEq for CERT_LOGOTYPE_INFO {
eq(&self, _other: &Self) -> bool4915     fn eq(&self, _other: &Self) -> bool {
4916         unimplemented!()
4917     }
4918 }
4919 #[cfg(feature = "Win32_Foundation")]
4920 impl ::std::cmp::Eq for CERT_LOGOTYPE_INFO {}
4921 #[cfg(feature = "Win32_Foundation")]
4922 unsafe impl ::windows::runtime::Abi for CERT_LOGOTYPE_INFO {
4923     type Abi = Self;
4924     type DefaultType = Self;
4925 }
4926 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4927 #[repr(C)]
4928 #[cfg(feature = "Win32_Foundation")]
4929 pub union CERT_LOGOTYPE_INFO_0 {
4930     pub pLogotypeDirectInfo: *mut CERT_LOGOTYPE_DATA,
4931     pub pLogotypeIndirectInfo: *mut CERT_LOGOTYPE_REFERENCE,
4932 }
4933 #[cfg(feature = "Win32_Foundation")]
4934 impl CERT_LOGOTYPE_INFO_0 {}
4935 #[cfg(feature = "Win32_Foundation")]
4936 impl ::std::default::Default for CERT_LOGOTYPE_INFO_0 {
default() -> Self4937     fn default() -> Self {
4938         unsafe { ::std::mem::zeroed() }
4939     }
4940 }
4941 #[cfg(feature = "Win32_Foundation")]
4942 impl ::std::cmp::PartialEq for CERT_LOGOTYPE_INFO_0 {
eq(&self, _other: &Self) -> bool4943     fn eq(&self, _other: &Self) -> bool {
4944         unimplemented!()
4945     }
4946 }
4947 #[cfg(feature = "Win32_Foundation")]
4948 impl ::std::cmp::Eq for CERT_LOGOTYPE_INFO_0 {}
4949 #[cfg(feature = "Win32_Foundation")]
4950 unsafe impl ::windows::runtime::Abi for CERT_LOGOTYPE_INFO_0 {
4951     type Abi = Self;
4952     type DefaultType = Self;
4953 }
4954 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4955 #[repr(transparent)]
4956 pub struct CERT_LOGOTYPE_OPTION(pub u32);
4957 pub const CERT_LOGOTYPE_DIRECT_INFO_CHOICE: CERT_LOGOTYPE_OPTION = CERT_LOGOTYPE_OPTION(1u32);
4958 pub const CERT_LOGOTYPE_INDIRECT_INFO_CHOICE: CERT_LOGOTYPE_OPTION = CERT_LOGOTYPE_OPTION(2u32);
4959 impl ::std::convert::From<u32> for CERT_LOGOTYPE_OPTION {
from(value: u32) -> Self4960     fn from(value: u32) -> Self {
4961         Self(value)
4962     }
4963 }
4964 unsafe impl ::windows::runtime::Abi for CERT_LOGOTYPE_OPTION {
4965     type Abi = Self;
4966     type DefaultType = Self;
4967 }
4968 impl ::std::ops::BitOr for CERT_LOGOTYPE_OPTION {
4969     type Output = Self;
bitor(self, rhs: Self) -> Self4970     fn bitor(self, rhs: Self) -> Self {
4971         Self(self.0 | rhs.0)
4972     }
4973 }
4974 impl ::std::ops::BitAnd for CERT_LOGOTYPE_OPTION {
4975     type Output = Self;
bitand(self, rhs: Self) -> Self4976     fn bitand(self, rhs: Self) -> Self {
4977         Self(self.0 & rhs.0)
4978     }
4979 }
4980 impl ::std::ops::BitOrAssign for CERT_LOGOTYPE_OPTION {
bitor_assign(&mut self, rhs: Self)4981     fn bitor_assign(&mut self, rhs: Self) {
4982         self.0.bitor_assign(rhs.0)
4983     }
4984 }
4985 impl ::std::ops::BitAndAssign for CERT_LOGOTYPE_OPTION {
bitand_assign(&mut self, rhs: Self)4986     fn bitand_assign(&mut self, rhs: Self) {
4987         self.0.bitand_assign(rhs.0)
4988     }
4989 }
4990 impl ::std::ops::Not for CERT_LOGOTYPE_OPTION {
4991     type Output = Self;
not(self) -> Self4992     fn not(self) -> Self {
4993         Self(self.0.not())
4994     }
4995 }
4996 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4997 #[repr(C)]
4998 #[cfg(feature = "Win32_Foundation")]
4999 pub struct CERT_LOGOTYPE_REFERENCE {
5000     pub cHashedUrl: u32,
5001     pub rgHashedUrl: *mut CERT_HASHED_URL,
5002 }
5003 #[cfg(feature = "Win32_Foundation")]
5004 impl CERT_LOGOTYPE_REFERENCE {}
5005 #[cfg(feature = "Win32_Foundation")]
5006 impl ::std::default::Default for CERT_LOGOTYPE_REFERENCE {
default() -> Self5007     fn default() -> Self {
5008         unsafe { ::std::mem::zeroed() }
5009     }
5010 }
5011 #[cfg(feature = "Win32_Foundation")]
5012 impl ::std::fmt::Debug for CERT_LOGOTYPE_REFERENCE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5013     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5014         fmt.debug_struct("CERT_LOGOTYPE_REFERENCE").field("cHashedUrl", &self.cHashedUrl).field("rgHashedUrl", &self.rgHashedUrl).finish()
5015     }
5016 }
5017 #[cfg(feature = "Win32_Foundation")]
5018 impl ::std::cmp::PartialEq for CERT_LOGOTYPE_REFERENCE {
eq(&self, other: &Self) -> bool5019     fn eq(&self, other: &Self) -> bool {
5020         self.cHashedUrl == other.cHashedUrl && self.rgHashedUrl == other.rgHashedUrl
5021     }
5022 }
5023 #[cfg(feature = "Win32_Foundation")]
5024 impl ::std::cmp::Eq for CERT_LOGOTYPE_REFERENCE {}
5025 #[cfg(feature = "Win32_Foundation")]
5026 unsafe impl ::windows::runtime::Abi for CERT_LOGOTYPE_REFERENCE {
5027     type Abi = Self;
5028     type DefaultType = Self;
5029 }
5030 pub const CERT_MD5_HASH_PROP_ID: u32 = 4u32;
5031 pub const CERT_NAME_ATTR_TYPE: u32 = 3u32;
5032 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5033 #[repr(C)]
5034 #[cfg(feature = "Win32_Foundation")]
5035 pub struct CERT_NAME_CONSTRAINTS_INFO {
5036     pub cPermittedSubtree: u32,
5037     pub rgPermittedSubtree: *mut CERT_GENERAL_SUBTREE,
5038     pub cExcludedSubtree: u32,
5039     pub rgExcludedSubtree: *mut CERT_GENERAL_SUBTREE,
5040 }
5041 #[cfg(feature = "Win32_Foundation")]
5042 impl CERT_NAME_CONSTRAINTS_INFO {}
5043 #[cfg(feature = "Win32_Foundation")]
5044 impl ::std::default::Default for CERT_NAME_CONSTRAINTS_INFO {
default() -> Self5045     fn default() -> Self {
5046         unsafe { ::std::mem::zeroed() }
5047     }
5048 }
5049 #[cfg(feature = "Win32_Foundation")]
5050 impl ::std::fmt::Debug for CERT_NAME_CONSTRAINTS_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5051     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5052         fmt.debug_struct("CERT_NAME_CONSTRAINTS_INFO").field("cPermittedSubtree", &self.cPermittedSubtree).field("rgPermittedSubtree", &self.rgPermittedSubtree).field("cExcludedSubtree", &self.cExcludedSubtree).field("rgExcludedSubtree", &self.rgExcludedSubtree).finish()
5053     }
5054 }
5055 #[cfg(feature = "Win32_Foundation")]
5056 impl ::std::cmp::PartialEq for CERT_NAME_CONSTRAINTS_INFO {
eq(&self, other: &Self) -> bool5057     fn eq(&self, other: &Self) -> bool {
5058         self.cPermittedSubtree == other.cPermittedSubtree && self.rgPermittedSubtree == other.rgPermittedSubtree && self.cExcludedSubtree == other.cExcludedSubtree && self.rgExcludedSubtree == other.rgExcludedSubtree
5059     }
5060 }
5061 #[cfg(feature = "Win32_Foundation")]
5062 impl ::std::cmp::Eq for CERT_NAME_CONSTRAINTS_INFO {}
5063 #[cfg(feature = "Win32_Foundation")]
5064 unsafe impl ::windows::runtime::Abi for CERT_NAME_CONSTRAINTS_INFO {
5065     type Abi = Self;
5066     type DefaultType = Self;
5067 }
5068 pub const CERT_NAME_DISABLE_IE4_UTF8_FLAG: u32 = 65536u32;
5069 pub const CERT_NAME_DNS_TYPE: u32 = 6u32;
5070 pub const CERT_NAME_EMAIL_TYPE: u32 = 1u32;
5071 pub const CERT_NAME_FRIENDLY_DISPLAY_TYPE: u32 = 5u32;
5072 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5073 #[repr(C)]
5074 #[cfg(feature = "Win32_Foundation")]
5075 pub struct CERT_NAME_INFO {
5076     pub cRDN: u32,
5077     pub rgRDN: *mut CERT_RDN,
5078 }
5079 #[cfg(feature = "Win32_Foundation")]
5080 impl CERT_NAME_INFO {}
5081 #[cfg(feature = "Win32_Foundation")]
5082 impl ::std::default::Default for CERT_NAME_INFO {
default() -> Self5083     fn default() -> Self {
5084         unsafe { ::std::mem::zeroed() }
5085     }
5086 }
5087 #[cfg(feature = "Win32_Foundation")]
5088 impl ::std::fmt::Debug for CERT_NAME_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5089     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5090         fmt.debug_struct("CERT_NAME_INFO").field("cRDN", &self.cRDN).field("rgRDN", &self.rgRDN).finish()
5091     }
5092 }
5093 #[cfg(feature = "Win32_Foundation")]
5094 impl ::std::cmp::PartialEq for CERT_NAME_INFO {
eq(&self, other: &Self) -> bool5095     fn eq(&self, other: &Self) -> bool {
5096         self.cRDN == other.cRDN && self.rgRDN == other.rgRDN
5097     }
5098 }
5099 #[cfg(feature = "Win32_Foundation")]
5100 impl ::std::cmp::Eq for CERT_NAME_INFO {}
5101 #[cfg(feature = "Win32_Foundation")]
5102 unsafe impl ::windows::runtime::Abi for CERT_NAME_INFO {
5103     type Abi = Self;
5104     type DefaultType = Self;
5105 }
5106 pub const CERT_NAME_ISSUER_FLAG: u32 = 1u32;
5107 pub const CERT_NAME_RDN_TYPE: u32 = 2u32;
5108 pub const CERT_NAME_SEARCH_ALL_NAMES_FLAG: u32 = 2u32;
5109 pub const CERT_NAME_SIMPLE_DISPLAY_TYPE: u32 = 4u32;
5110 pub const CERT_NAME_STR_COMMA_FLAG: u32 = 67108864u32;
5111 pub const CERT_NAME_STR_CRLF_FLAG: u32 = 134217728u32;
5112 pub const CERT_NAME_STR_DISABLE_IE4_UTF8_FLAG: u32 = 65536u32;
5113 pub const CERT_NAME_STR_DISABLE_UTF8_DIR_STR_FLAG: u32 = 1048576u32;
5114 pub const CERT_NAME_STR_ENABLE_PUNYCODE_FLAG: u32 = 2097152u32;
5115 pub const CERT_NAME_STR_ENABLE_T61_UNICODE_FLAG: u32 = 131072u32;
5116 pub const CERT_NAME_STR_ENABLE_UTF8_UNICODE_FLAG: u32 = 262144u32;
5117 pub const CERT_NAME_STR_FORCE_UTF8_DIR_STR_FLAG: u32 = 524288u32;
5118 pub const CERT_NAME_STR_FORWARD_FLAG: u32 = 16777216u32;
5119 pub const CERT_NAME_STR_NO_PLUS_FLAG: u32 = 536870912u32;
5120 pub const CERT_NAME_STR_NO_QUOTING_FLAG: u32 = 268435456u32;
5121 pub const CERT_NAME_STR_REVERSE_FLAG: u32 = 33554432u32;
5122 pub const CERT_NAME_STR_SEMICOLON_FLAG: u32 = 1073741824u32;
5123 pub const CERT_NAME_UPN_TYPE: u32 = 8u32;
5124 pub const CERT_NAME_URL_TYPE: u32 = 7u32;
5125 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5126 #[repr(C)]
5127 pub struct CERT_NAME_VALUE {
5128     pub dwValueType: u32,
5129     pub Value: CRYPTOAPI_BLOB,
5130 }
5131 impl CERT_NAME_VALUE {}
5132 impl ::std::default::Default for CERT_NAME_VALUE {
default() -> Self5133     fn default() -> Self {
5134         unsafe { ::std::mem::zeroed() }
5135     }
5136 }
5137 impl ::std::fmt::Debug for CERT_NAME_VALUE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5138     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5139         fmt.debug_struct("CERT_NAME_VALUE").field("dwValueType", &self.dwValueType).field("Value", &self.Value).finish()
5140     }
5141 }
5142 impl ::std::cmp::PartialEq for CERT_NAME_VALUE {
eq(&self, other: &Self) -> bool5143     fn eq(&self, other: &Self) -> bool {
5144         self.dwValueType == other.dwValueType && self.Value == other.Value
5145     }
5146 }
5147 impl ::std::cmp::Eq for CERT_NAME_VALUE {}
5148 unsafe impl ::windows::runtime::Abi for CERT_NAME_VALUE {
5149     type Abi = Self;
5150     type DefaultType = Self;
5151 }
5152 pub const CERT_NCRYPT_KEY_HANDLE_PROP_ID: u32 = 78u32;
5153 pub const CERT_NCRYPT_KEY_HANDLE_TRANSFER_PROP_ID: u32 = 99u32;
5154 pub const CERT_NEW_KEY_PROP_ID: u32 = 74u32;
5155 pub const CERT_NEXT_UPDATE_LOCATION_PROP_ID: u32 = 10u32;
5156 pub const CERT_NONCOMPLIANT_ROOT_URL_PROP_ID: u32 = 123u32;
5157 pub const CERT_NON_REPUDIATION_KEY_USAGE: u32 = 64u32;
5158 pub const CERT_NOT_BEFORE_ENHKEY_USAGE_PROP_ID: u32 = 127u32;
5159 pub const CERT_NOT_BEFORE_FILETIME_PROP_ID: u32 = 126u32;
5160 pub const CERT_NO_AUTO_EXPIRE_CHECK_PROP_ID: u32 = 77u32;
5161 pub const CERT_NO_EXPIRE_NOTIFICATION_PROP_ID: u32 = 97u32;
5162 pub const CERT_OCSP_CACHE_PREFIX_PROP_ID: u32 = 75u32;
5163 pub const CERT_OCSP_MUST_STAPLE_PROP_ID: u32 = 121u32;
5164 pub const CERT_OCSP_RESPONSE_PROP_ID: u32 = 70u32;
5165 pub const CERT_OFFLINE_CRL_SIGN_KEY_USAGE: u32 = 2u32;
5166 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5167 #[repr(transparent)]
5168 pub struct CERT_OPEN_STORE_FLAGS(pub u32);
5169 pub const CERT_STORE_BACKUP_RESTORE_FLAG: CERT_OPEN_STORE_FLAGS = CERT_OPEN_STORE_FLAGS(2048u32);
5170 pub const CERT_STORE_CREATE_NEW_FLAG: CERT_OPEN_STORE_FLAGS = CERT_OPEN_STORE_FLAGS(8192u32);
5171 pub const CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG: CERT_OPEN_STORE_FLAGS = CERT_OPEN_STORE_FLAGS(4u32);
5172 pub const CERT_STORE_DELETE_FLAG: CERT_OPEN_STORE_FLAGS = CERT_OPEN_STORE_FLAGS(16u32);
5173 pub const CERT_STORE_ENUM_ARCHIVED_FLAG: CERT_OPEN_STORE_FLAGS = CERT_OPEN_STORE_FLAGS(512u32);
5174 pub const CERT_STORE_MAXIMUM_ALLOWED_FLAG: CERT_OPEN_STORE_FLAGS = CERT_OPEN_STORE_FLAGS(4096u32);
5175 pub const CERT_STORE_NO_CRYPT_RELEASE_FLAG: CERT_OPEN_STORE_FLAGS = CERT_OPEN_STORE_FLAGS(1u32);
5176 pub const CERT_STORE_OPEN_EXISTING_FLAG: CERT_OPEN_STORE_FLAGS = CERT_OPEN_STORE_FLAGS(16384u32);
5177 pub const CERT_STORE_READONLY_FLAG: CERT_OPEN_STORE_FLAGS = CERT_OPEN_STORE_FLAGS(32768u32);
5178 pub const CERT_STORE_SET_LOCALIZED_NAME_FLAG: CERT_OPEN_STORE_FLAGS = CERT_OPEN_STORE_FLAGS(2u32);
5179 pub const CERT_STORE_SHARE_CONTEXT_FLAG: CERT_OPEN_STORE_FLAGS = CERT_OPEN_STORE_FLAGS(128u32);
5180 pub const CERT_STORE_UPDATE_KEYID_FLAG: CERT_OPEN_STORE_FLAGS = CERT_OPEN_STORE_FLAGS(1024u32);
5181 impl ::std::convert::From<u32> for CERT_OPEN_STORE_FLAGS {
from(value: u32) -> Self5182     fn from(value: u32) -> Self {
5183         Self(value)
5184     }
5185 }
5186 unsafe impl ::windows::runtime::Abi for CERT_OPEN_STORE_FLAGS {
5187     type Abi = Self;
5188     type DefaultType = Self;
5189 }
5190 impl ::std::ops::BitOr for CERT_OPEN_STORE_FLAGS {
5191     type Output = Self;
bitor(self, rhs: Self) -> Self5192     fn bitor(self, rhs: Self) -> Self {
5193         Self(self.0 | rhs.0)
5194     }
5195 }
5196 impl ::std::ops::BitAnd for CERT_OPEN_STORE_FLAGS {
5197     type Output = Self;
bitand(self, rhs: Self) -> Self5198     fn bitand(self, rhs: Self) -> Self {
5199         Self(self.0 & rhs.0)
5200     }
5201 }
5202 impl ::std::ops::BitOrAssign for CERT_OPEN_STORE_FLAGS {
bitor_assign(&mut self, rhs: Self)5203     fn bitor_assign(&mut self, rhs: Self) {
5204         self.0.bitor_assign(rhs.0)
5205     }
5206 }
5207 impl ::std::ops::BitAndAssign for CERT_OPEN_STORE_FLAGS {
bitand_assign(&mut self, rhs: Self)5208     fn bitand_assign(&mut self, rhs: Self) {
5209         self.0.bitand_assign(rhs.0)
5210     }
5211 }
5212 impl ::std::ops::Not for CERT_OPEN_STORE_FLAGS {
5213     type Output = Self;
not(self) -> Self5214     fn not(self) -> Self {
5215         Self(self.0.not())
5216     }
5217 }
5218 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5219 #[repr(C)]
5220 pub struct CERT_OR_CRL_BLOB {
5221     pub dwChoice: u32,
5222     pub cbEncoded: u32,
5223     pub pbEncoded: *mut u8,
5224 }
5225 impl CERT_OR_CRL_BLOB {}
5226 impl ::std::default::Default for CERT_OR_CRL_BLOB {
default() -> Self5227     fn default() -> Self {
5228         unsafe { ::std::mem::zeroed() }
5229     }
5230 }
5231 impl ::std::fmt::Debug for CERT_OR_CRL_BLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5232     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5233         fmt.debug_struct("CERT_OR_CRL_BLOB").field("dwChoice", &self.dwChoice).field("cbEncoded", &self.cbEncoded).field("pbEncoded", &self.pbEncoded).finish()
5234     }
5235 }
5236 impl ::std::cmp::PartialEq for CERT_OR_CRL_BLOB {
eq(&self, other: &Self) -> bool5237     fn eq(&self, other: &Self) -> bool {
5238         self.dwChoice == other.dwChoice && self.cbEncoded == other.cbEncoded && self.pbEncoded == other.pbEncoded
5239     }
5240 }
5241 impl ::std::cmp::Eq for CERT_OR_CRL_BLOB {}
5242 unsafe impl ::windows::runtime::Abi for CERT_OR_CRL_BLOB {
5243     type Abi = Self;
5244     type DefaultType = Self;
5245 }
5246 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5247 #[repr(C)]
5248 pub struct CERT_OR_CRL_BUNDLE {
5249     pub cItem: u32,
5250     pub rgItem: *mut CERT_OR_CRL_BLOB,
5251 }
5252 impl CERT_OR_CRL_BUNDLE {}
5253 impl ::std::default::Default for CERT_OR_CRL_BUNDLE {
default() -> Self5254     fn default() -> Self {
5255         unsafe { ::std::mem::zeroed() }
5256     }
5257 }
5258 impl ::std::fmt::Debug for CERT_OR_CRL_BUNDLE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5259     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5260         fmt.debug_struct("CERT_OR_CRL_BUNDLE").field("cItem", &self.cItem).field("rgItem", &self.rgItem).finish()
5261     }
5262 }
5263 impl ::std::cmp::PartialEq for CERT_OR_CRL_BUNDLE {
eq(&self, other: &Self) -> bool5264     fn eq(&self, other: &Self) -> bool {
5265         self.cItem == other.cItem && self.rgItem == other.rgItem
5266     }
5267 }
5268 impl ::std::cmp::Eq for CERT_OR_CRL_BUNDLE {}
5269 unsafe impl ::windows::runtime::Abi for CERT_OR_CRL_BUNDLE {
5270     type Abi = Self;
5271     type DefaultType = Self;
5272 }
5273 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5274 #[repr(C)]
5275 #[cfg(feature = "Win32_Foundation")]
5276 pub struct CERT_OTHER_LOGOTYPE_INFO {
5277     pub pszObjId: super::super::Foundation::PSTR,
5278     pub LogotypeInfo: CERT_LOGOTYPE_INFO,
5279 }
5280 #[cfg(feature = "Win32_Foundation")]
5281 impl CERT_OTHER_LOGOTYPE_INFO {}
5282 #[cfg(feature = "Win32_Foundation")]
5283 impl ::std::default::Default for CERT_OTHER_LOGOTYPE_INFO {
default() -> Self5284     fn default() -> Self {
5285         unsafe { ::std::mem::zeroed() }
5286     }
5287 }
5288 #[cfg(feature = "Win32_Foundation")]
5289 impl ::std::cmp::PartialEq for CERT_OTHER_LOGOTYPE_INFO {
eq(&self, _other: &Self) -> bool5290     fn eq(&self, _other: &Self) -> bool {
5291         unimplemented!()
5292     }
5293 }
5294 #[cfg(feature = "Win32_Foundation")]
5295 impl ::std::cmp::Eq for CERT_OTHER_LOGOTYPE_INFO {}
5296 #[cfg(feature = "Win32_Foundation")]
5297 unsafe impl ::windows::runtime::Abi for CERT_OTHER_LOGOTYPE_INFO {
5298     type Abi = Self;
5299     type DefaultType = Self;
5300 }
5301 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5302 #[repr(C)]
5303 #[cfg(feature = "Win32_Foundation")]
5304 pub struct CERT_OTHER_NAME {
5305     pub pszObjId: super::super::Foundation::PSTR,
5306     pub Value: CRYPTOAPI_BLOB,
5307 }
5308 #[cfg(feature = "Win32_Foundation")]
5309 impl CERT_OTHER_NAME {}
5310 #[cfg(feature = "Win32_Foundation")]
5311 impl ::std::default::Default for CERT_OTHER_NAME {
default() -> Self5312     fn default() -> Self {
5313         unsafe { ::std::mem::zeroed() }
5314     }
5315 }
5316 #[cfg(feature = "Win32_Foundation")]
5317 impl ::std::fmt::Debug for CERT_OTHER_NAME {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5318     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5319         fmt.debug_struct("CERT_OTHER_NAME").field("pszObjId", &self.pszObjId).field("Value", &self.Value).finish()
5320     }
5321 }
5322 #[cfg(feature = "Win32_Foundation")]
5323 impl ::std::cmp::PartialEq for CERT_OTHER_NAME {
eq(&self, other: &Self) -> bool5324     fn eq(&self, other: &Self) -> bool {
5325         self.pszObjId == other.pszObjId && self.Value == other.Value
5326     }
5327 }
5328 #[cfg(feature = "Win32_Foundation")]
5329 impl ::std::cmp::Eq for CERT_OTHER_NAME {}
5330 #[cfg(feature = "Win32_Foundation")]
5331 unsafe impl ::windows::runtime::Abi for CERT_OTHER_NAME {
5332     type Abi = Self;
5333     type DefaultType = Self;
5334 }
5335 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5336 #[repr(C)]
5337 pub struct CERT_PAIR {
5338     pub Forward: CRYPTOAPI_BLOB,
5339     pub Reverse: CRYPTOAPI_BLOB,
5340 }
5341 impl CERT_PAIR {}
5342 impl ::std::default::Default for CERT_PAIR {
default() -> Self5343     fn default() -> Self {
5344         unsafe { ::std::mem::zeroed() }
5345     }
5346 }
5347 impl ::std::fmt::Debug for CERT_PAIR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5348     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5349         fmt.debug_struct("CERT_PAIR").field("Forward", &self.Forward).field("Reverse", &self.Reverse).finish()
5350     }
5351 }
5352 impl ::std::cmp::PartialEq for CERT_PAIR {
eq(&self, other: &Self) -> bool5353     fn eq(&self, other: &Self) -> bool {
5354         self.Forward == other.Forward && self.Reverse == other.Reverse
5355     }
5356 }
5357 impl ::std::cmp::Eq for CERT_PAIR {}
5358 unsafe impl ::windows::runtime::Abi for CERT_PAIR {
5359     type Abi = Self;
5360     type DefaultType = Self;
5361 }
5362 pub const CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG: u32 = 1u32;
5363 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5364 #[repr(C)]
5365 #[cfg(feature = "Win32_Foundation")]
5366 pub struct CERT_PHYSICAL_STORE_INFO {
5367     pub cbSize: u32,
5368     pub pszOpenStoreProvider: super::super::Foundation::PSTR,
5369     pub dwOpenEncodingType: u32,
5370     pub dwOpenFlags: u32,
5371     pub OpenParameters: CRYPTOAPI_BLOB,
5372     pub dwFlags: u32,
5373     pub dwPriority: u32,
5374 }
5375 #[cfg(feature = "Win32_Foundation")]
5376 impl CERT_PHYSICAL_STORE_INFO {}
5377 #[cfg(feature = "Win32_Foundation")]
5378 impl ::std::default::Default for CERT_PHYSICAL_STORE_INFO {
default() -> Self5379     fn default() -> Self {
5380         unsafe { ::std::mem::zeroed() }
5381     }
5382 }
5383 #[cfg(feature = "Win32_Foundation")]
5384 impl ::std::fmt::Debug for CERT_PHYSICAL_STORE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5385     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5386         fmt.debug_struct("CERT_PHYSICAL_STORE_INFO")
5387             .field("cbSize", &self.cbSize)
5388             .field("pszOpenStoreProvider", &self.pszOpenStoreProvider)
5389             .field("dwOpenEncodingType", &self.dwOpenEncodingType)
5390             .field("dwOpenFlags", &self.dwOpenFlags)
5391             .field("OpenParameters", &self.OpenParameters)
5392             .field("dwFlags", &self.dwFlags)
5393             .field("dwPriority", &self.dwPriority)
5394             .finish()
5395     }
5396 }
5397 #[cfg(feature = "Win32_Foundation")]
5398 impl ::std::cmp::PartialEq for CERT_PHYSICAL_STORE_INFO {
eq(&self, other: &Self) -> bool5399     fn eq(&self, other: &Self) -> bool {
5400         self.cbSize == other.cbSize && self.pszOpenStoreProvider == other.pszOpenStoreProvider && self.dwOpenEncodingType == other.dwOpenEncodingType && self.dwOpenFlags == other.dwOpenFlags && self.OpenParameters == other.OpenParameters && self.dwFlags == other.dwFlags && self.dwPriority == other.dwPriority
5401     }
5402 }
5403 #[cfg(feature = "Win32_Foundation")]
5404 impl ::std::cmp::Eq for CERT_PHYSICAL_STORE_INFO {}
5405 #[cfg(feature = "Win32_Foundation")]
5406 unsafe impl ::windows::runtime::Abi for CERT_PHYSICAL_STORE_INFO {
5407     type Abi = Self;
5408     type DefaultType = Self;
5409 }
5410 pub const CERT_PHYSICAL_STORE_INSERT_COMPUTER_NAME_ENABLE_FLAG: u32 = 8u32;
5411 pub const CERT_PHYSICAL_STORE_OPEN_DISABLE_FLAG: u32 = 2u32;
5412 pub const CERT_PHYSICAL_STORE_PREDEFINED_ENUM_FLAG: u32 = 1u32;
5413 pub const CERT_PHYSICAL_STORE_REMOTE_OPEN_DISABLE_FLAG: u32 = 4u32;
5414 pub const CERT_PIN_SHA256_HASH_PROP_ID: u32 = 124u32;
5415 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5416 #[repr(C)]
5417 #[cfg(feature = "Win32_Foundation")]
5418 pub struct CERT_POLICIES_INFO {
5419     pub cPolicyInfo: u32,
5420     pub rgPolicyInfo: *mut CERT_POLICY_INFO,
5421 }
5422 #[cfg(feature = "Win32_Foundation")]
5423 impl CERT_POLICIES_INFO {}
5424 #[cfg(feature = "Win32_Foundation")]
5425 impl ::std::default::Default for CERT_POLICIES_INFO {
default() -> Self5426     fn default() -> Self {
5427         unsafe { ::std::mem::zeroed() }
5428     }
5429 }
5430 #[cfg(feature = "Win32_Foundation")]
5431 impl ::std::fmt::Debug for CERT_POLICIES_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5432     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5433         fmt.debug_struct("CERT_POLICIES_INFO").field("cPolicyInfo", &self.cPolicyInfo).field("rgPolicyInfo", &self.rgPolicyInfo).finish()
5434     }
5435 }
5436 #[cfg(feature = "Win32_Foundation")]
5437 impl ::std::cmp::PartialEq for CERT_POLICIES_INFO {
eq(&self, other: &Self) -> bool5438     fn eq(&self, other: &Self) -> bool {
5439         self.cPolicyInfo == other.cPolicyInfo && self.rgPolicyInfo == other.rgPolicyInfo
5440     }
5441 }
5442 #[cfg(feature = "Win32_Foundation")]
5443 impl ::std::cmp::Eq for CERT_POLICIES_INFO {}
5444 #[cfg(feature = "Win32_Foundation")]
5445 unsafe impl ::windows::runtime::Abi for CERT_POLICIES_INFO {
5446     type Abi = Self;
5447     type DefaultType = Self;
5448 }
5449 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5450 #[repr(C)]
5451 #[cfg(feature = "Win32_Foundation")]
5452 pub struct CERT_POLICY95_QUALIFIER1 {
5453     pub pszPracticesReference: super::super::Foundation::PWSTR,
5454     pub pszNoticeIdentifier: super::super::Foundation::PSTR,
5455     pub pszNSINoticeIdentifier: super::super::Foundation::PSTR,
5456     pub cCPSURLs: u32,
5457     pub rgCPSURLs: *mut CPS_URLS,
5458 }
5459 #[cfg(feature = "Win32_Foundation")]
5460 impl CERT_POLICY95_QUALIFIER1 {}
5461 #[cfg(feature = "Win32_Foundation")]
5462 impl ::std::default::Default for CERT_POLICY95_QUALIFIER1 {
default() -> Self5463     fn default() -> Self {
5464         unsafe { ::std::mem::zeroed() }
5465     }
5466 }
5467 #[cfg(feature = "Win32_Foundation")]
5468 impl ::std::fmt::Debug for CERT_POLICY95_QUALIFIER1 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5469     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5470         fmt.debug_struct("CERT_POLICY95_QUALIFIER1")
5471             .field("pszPracticesReference", &self.pszPracticesReference)
5472             .field("pszNoticeIdentifier", &self.pszNoticeIdentifier)
5473             .field("pszNSINoticeIdentifier", &self.pszNSINoticeIdentifier)
5474             .field("cCPSURLs", &self.cCPSURLs)
5475             .field("rgCPSURLs", &self.rgCPSURLs)
5476             .finish()
5477     }
5478 }
5479 #[cfg(feature = "Win32_Foundation")]
5480 impl ::std::cmp::PartialEq for CERT_POLICY95_QUALIFIER1 {
eq(&self, other: &Self) -> bool5481     fn eq(&self, other: &Self) -> bool {
5482         self.pszPracticesReference == other.pszPracticesReference && self.pszNoticeIdentifier == other.pszNoticeIdentifier && self.pszNSINoticeIdentifier == other.pszNSINoticeIdentifier && self.cCPSURLs == other.cCPSURLs && self.rgCPSURLs == other.rgCPSURLs
5483     }
5484 }
5485 #[cfg(feature = "Win32_Foundation")]
5486 impl ::std::cmp::Eq for CERT_POLICY95_QUALIFIER1 {}
5487 #[cfg(feature = "Win32_Foundation")]
5488 unsafe impl ::windows::runtime::Abi for CERT_POLICY95_QUALIFIER1 {
5489     type Abi = Self;
5490     type DefaultType = Self;
5491 }
5492 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5493 #[repr(C)]
5494 #[cfg(feature = "Win32_Foundation")]
5495 pub struct CERT_POLICY_CONSTRAINTS_INFO {
5496     pub fRequireExplicitPolicy: super::super::Foundation::BOOL,
5497     pub dwRequireExplicitPolicySkipCerts: u32,
5498     pub fInhibitPolicyMapping: super::super::Foundation::BOOL,
5499     pub dwInhibitPolicyMappingSkipCerts: u32,
5500 }
5501 #[cfg(feature = "Win32_Foundation")]
5502 impl CERT_POLICY_CONSTRAINTS_INFO {}
5503 #[cfg(feature = "Win32_Foundation")]
5504 impl ::std::default::Default for CERT_POLICY_CONSTRAINTS_INFO {
default() -> Self5505     fn default() -> Self {
5506         unsafe { ::std::mem::zeroed() }
5507     }
5508 }
5509 #[cfg(feature = "Win32_Foundation")]
5510 impl ::std::fmt::Debug for CERT_POLICY_CONSTRAINTS_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5511     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5512         fmt.debug_struct("CERT_POLICY_CONSTRAINTS_INFO")
5513             .field("fRequireExplicitPolicy", &self.fRequireExplicitPolicy)
5514             .field("dwRequireExplicitPolicySkipCerts", &self.dwRequireExplicitPolicySkipCerts)
5515             .field("fInhibitPolicyMapping", &self.fInhibitPolicyMapping)
5516             .field("dwInhibitPolicyMappingSkipCerts", &self.dwInhibitPolicyMappingSkipCerts)
5517             .finish()
5518     }
5519 }
5520 #[cfg(feature = "Win32_Foundation")]
5521 impl ::std::cmp::PartialEq for CERT_POLICY_CONSTRAINTS_INFO {
eq(&self, other: &Self) -> bool5522     fn eq(&self, other: &Self) -> bool {
5523         self.fRequireExplicitPolicy == other.fRequireExplicitPolicy && self.dwRequireExplicitPolicySkipCerts == other.dwRequireExplicitPolicySkipCerts && self.fInhibitPolicyMapping == other.fInhibitPolicyMapping && self.dwInhibitPolicyMappingSkipCerts == other.dwInhibitPolicyMappingSkipCerts
5524     }
5525 }
5526 #[cfg(feature = "Win32_Foundation")]
5527 impl ::std::cmp::Eq for CERT_POLICY_CONSTRAINTS_INFO {}
5528 #[cfg(feature = "Win32_Foundation")]
5529 unsafe impl ::windows::runtime::Abi for CERT_POLICY_CONSTRAINTS_INFO {
5530     type Abi = Self;
5531     type DefaultType = Self;
5532 }
5533 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5534 #[repr(C)]
5535 #[cfg(feature = "Win32_Foundation")]
5536 pub struct CERT_POLICY_ID {
5537     pub cCertPolicyElementId: u32,
5538     pub rgpszCertPolicyElementId: *mut super::super::Foundation::PSTR,
5539 }
5540 #[cfg(feature = "Win32_Foundation")]
5541 impl CERT_POLICY_ID {}
5542 #[cfg(feature = "Win32_Foundation")]
5543 impl ::std::default::Default for CERT_POLICY_ID {
default() -> Self5544     fn default() -> Self {
5545         unsafe { ::std::mem::zeroed() }
5546     }
5547 }
5548 #[cfg(feature = "Win32_Foundation")]
5549 impl ::std::fmt::Debug for CERT_POLICY_ID {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5550     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5551         fmt.debug_struct("CERT_POLICY_ID").field("cCertPolicyElementId", &self.cCertPolicyElementId).field("rgpszCertPolicyElementId", &self.rgpszCertPolicyElementId).finish()
5552     }
5553 }
5554 #[cfg(feature = "Win32_Foundation")]
5555 impl ::std::cmp::PartialEq for CERT_POLICY_ID {
eq(&self, other: &Self) -> bool5556     fn eq(&self, other: &Self) -> bool {
5557         self.cCertPolicyElementId == other.cCertPolicyElementId && self.rgpszCertPolicyElementId == other.rgpszCertPolicyElementId
5558     }
5559 }
5560 #[cfg(feature = "Win32_Foundation")]
5561 impl ::std::cmp::Eq for CERT_POLICY_ID {}
5562 #[cfg(feature = "Win32_Foundation")]
5563 unsafe impl ::windows::runtime::Abi for CERT_POLICY_ID {
5564     type Abi = Self;
5565     type DefaultType = Self;
5566 }
5567 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5568 #[repr(C)]
5569 #[cfg(feature = "Win32_Foundation")]
5570 pub struct CERT_POLICY_INFO {
5571     pub pszPolicyIdentifier: super::super::Foundation::PSTR,
5572     pub cPolicyQualifier: u32,
5573     pub rgPolicyQualifier: *mut CERT_POLICY_QUALIFIER_INFO,
5574 }
5575 #[cfg(feature = "Win32_Foundation")]
5576 impl CERT_POLICY_INFO {}
5577 #[cfg(feature = "Win32_Foundation")]
5578 impl ::std::default::Default for CERT_POLICY_INFO {
default() -> Self5579     fn default() -> Self {
5580         unsafe { ::std::mem::zeroed() }
5581     }
5582 }
5583 #[cfg(feature = "Win32_Foundation")]
5584 impl ::std::fmt::Debug for CERT_POLICY_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5585     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5586         fmt.debug_struct("CERT_POLICY_INFO").field("pszPolicyIdentifier", &self.pszPolicyIdentifier).field("cPolicyQualifier", &self.cPolicyQualifier).field("rgPolicyQualifier", &self.rgPolicyQualifier).finish()
5587     }
5588 }
5589 #[cfg(feature = "Win32_Foundation")]
5590 impl ::std::cmp::PartialEq for CERT_POLICY_INFO {
eq(&self, other: &Self) -> bool5591     fn eq(&self, other: &Self) -> bool {
5592         self.pszPolicyIdentifier == other.pszPolicyIdentifier && self.cPolicyQualifier == other.cPolicyQualifier && self.rgPolicyQualifier == other.rgPolicyQualifier
5593     }
5594 }
5595 #[cfg(feature = "Win32_Foundation")]
5596 impl ::std::cmp::Eq for CERT_POLICY_INFO {}
5597 #[cfg(feature = "Win32_Foundation")]
5598 unsafe impl ::windows::runtime::Abi for CERT_POLICY_INFO {
5599     type Abi = Self;
5600     type DefaultType = Self;
5601 }
5602 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5603 #[repr(C)]
5604 #[cfg(feature = "Win32_Foundation")]
5605 pub struct CERT_POLICY_MAPPING {
5606     pub pszIssuerDomainPolicy: super::super::Foundation::PSTR,
5607     pub pszSubjectDomainPolicy: super::super::Foundation::PSTR,
5608 }
5609 #[cfg(feature = "Win32_Foundation")]
5610 impl CERT_POLICY_MAPPING {}
5611 #[cfg(feature = "Win32_Foundation")]
5612 impl ::std::default::Default for CERT_POLICY_MAPPING {
default() -> Self5613     fn default() -> Self {
5614         unsafe { ::std::mem::zeroed() }
5615     }
5616 }
5617 #[cfg(feature = "Win32_Foundation")]
5618 impl ::std::fmt::Debug for CERT_POLICY_MAPPING {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5619     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5620         fmt.debug_struct("CERT_POLICY_MAPPING").field("pszIssuerDomainPolicy", &self.pszIssuerDomainPolicy).field("pszSubjectDomainPolicy", &self.pszSubjectDomainPolicy).finish()
5621     }
5622 }
5623 #[cfg(feature = "Win32_Foundation")]
5624 impl ::std::cmp::PartialEq for CERT_POLICY_MAPPING {
eq(&self, other: &Self) -> bool5625     fn eq(&self, other: &Self) -> bool {
5626         self.pszIssuerDomainPolicy == other.pszIssuerDomainPolicy && self.pszSubjectDomainPolicy == other.pszSubjectDomainPolicy
5627     }
5628 }
5629 #[cfg(feature = "Win32_Foundation")]
5630 impl ::std::cmp::Eq for CERT_POLICY_MAPPING {}
5631 #[cfg(feature = "Win32_Foundation")]
5632 unsafe impl ::windows::runtime::Abi for CERT_POLICY_MAPPING {
5633     type Abi = Self;
5634     type DefaultType = Self;
5635 }
5636 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5637 #[repr(C)]
5638 #[cfg(feature = "Win32_Foundation")]
5639 pub struct CERT_POLICY_MAPPINGS_INFO {
5640     pub cPolicyMapping: u32,
5641     pub rgPolicyMapping: *mut CERT_POLICY_MAPPING,
5642 }
5643 #[cfg(feature = "Win32_Foundation")]
5644 impl CERT_POLICY_MAPPINGS_INFO {}
5645 #[cfg(feature = "Win32_Foundation")]
5646 impl ::std::default::Default for CERT_POLICY_MAPPINGS_INFO {
default() -> Self5647     fn default() -> Self {
5648         unsafe { ::std::mem::zeroed() }
5649     }
5650 }
5651 #[cfg(feature = "Win32_Foundation")]
5652 impl ::std::fmt::Debug for CERT_POLICY_MAPPINGS_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5653     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5654         fmt.debug_struct("CERT_POLICY_MAPPINGS_INFO").field("cPolicyMapping", &self.cPolicyMapping).field("rgPolicyMapping", &self.rgPolicyMapping).finish()
5655     }
5656 }
5657 #[cfg(feature = "Win32_Foundation")]
5658 impl ::std::cmp::PartialEq for CERT_POLICY_MAPPINGS_INFO {
eq(&self, other: &Self) -> bool5659     fn eq(&self, other: &Self) -> bool {
5660         self.cPolicyMapping == other.cPolicyMapping && self.rgPolicyMapping == other.rgPolicyMapping
5661     }
5662 }
5663 #[cfg(feature = "Win32_Foundation")]
5664 impl ::std::cmp::Eq for CERT_POLICY_MAPPINGS_INFO {}
5665 #[cfg(feature = "Win32_Foundation")]
5666 unsafe impl ::windows::runtime::Abi for CERT_POLICY_MAPPINGS_INFO {
5667     type Abi = Self;
5668     type DefaultType = Self;
5669 }
5670 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5671 #[repr(C)]
5672 #[cfg(feature = "Win32_Foundation")]
5673 pub struct CERT_POLICY_QUALIFIER_INFO {
5674     pub pszPolicyQualifierId: super::super::Foundation::PSTR,
5675     pub Qualifier: CRYPTOAPI_BLOB,
5676 }
5677 #[cfg(feature = "Win32_Foundation")]
5678 impl CERT_POLICY_QUALIFIER_INFO {}
5679 #[cfg(feature = "Win32_Foundation")]
5680 impl ::std::default::Default for CERT_POLICY_QUALIFIER_INFO {
default() -> Self5681     fn default() -> Self {
5682         unsafe { ::std::mem::zeroed() }
5683     }
5684 }
5685 #[cfg(feature = "Win32_Foundation")]
5686 impl ::std::fmt::Debug for CERT_POLICY_QUALIFIER_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5687     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5688         fmt.debug_struct("CERT_POLICY_QUALIFIER_INFO").field("pszPolicyQualifierId", &self.pszPolicyQualifierId).field("Qualifier", &self.Qualifier).finish()
5689     }
5690 }
5691 #[cfg(feature = "Win32_Foundation")]
5692 impl ::std::cmp::PartialEq for CERT_POLICY_QUALIFIER_INFO {
eq(&self, other: &Self) -> bool5693     fn eq(&self, other: &Self) -> bool {
5694         self.pszPolicyQualifierId == other.pszPolicyQualifierId && self.Qualifier == other.Qualifier
5695     }
5696 }
5697 #[cfg(feature = "Win32_Foundation")]
5698 impl ::std::cmp::Eq for CERT_POLICY_QUALIFIER_INFO {}
5699 #[cfg(feature = "Win32_Foundation")]
5700 unsafe impl ::windows::runtime::Abi for CERT_POLICY_QUALIFIER_INFO {
5701     type Abi = Self;
5702     type DefaultType = Self;
5703 }
5704 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5705 #[repr(C)]
5706 #[cfg(feature = "Win32_Foundation")]
5707 pub struct CERT_POLICY_QUALIFIER_NOTICE_REFERENCE {
5708     pub pszOrganization: super::super::Foundation::PSTR,
5709     pub cNoticeNumbers: u32,
5710     pub rgNoticeNumbers: *mut i32,
5711 }
5712 #[cfg(feature = "Win32_Foundation")]
5713 impl CERT_POLICY_QUALIFIER_NOTICE_REFERENCE {}
5714 #[cfg(feature = "Win32_Foundation")]
5715 impl ::std::default::Default for CERT_POLICY_QUALIFIER_NOTICE_REFERENCE {
default() -> Self5716     fn default() -> Self {
5717         unsafe { ::std::mem::zeroed() }
5718     }
5719 }
5720 #[cfg(feature = "Win32_Foundation")]
5721 impl ::std::fmt::Debug for CERT_POLICY_QUALIFIER_NOTICE_REFERENCE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5722     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5723         fmt.debug_struct("CERT_POLICY_QUALIFIER_NOTICE_REFERENCE").field("pszOrganization", &self.pszOrganization).field("cNoticeNumbers", &self.cNoticeNumbers).field("rgNoticeNumbers", &self.rgNoticeNumbers).finish()
5724     }
5725 }
5726 #[cfg(feature = "Win32_Foundation")]
5727 impl ::std::cmp::PartialEq for CERT_POLICY_QUALIFIER_NOTICE_REFERENCE {
eq(&self, other: &Self) -> bool5728     fn eq(&self, other: &Self) -> bool {
5729         self.pszOrganization == other.pszOrganization && self.cNoticeNumbers == other.cNoticeNumbers && self.rgNoticeNumbers == other.rgNoticeNumbers
5730     }
5731 }
5732 #[cfg(feature = "Win32_Foundation")]
5733 impl ::std::cmp::Eq for CERT_POLICY_QUALIFIER_NOTICE_REFERENCE {}
5734 #[cfg(feature = "Win32_Foundation")]
5735 unsafe impl ::windows::runtime::Abi for CERT_POLICY_QUALIFIER_NOTICE_REFERENCE {
5736     type Abi = Self;
5737     type DefaultType = Self;
5738 }
5739 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5740 #[repr(C)]
5741 #[cfg(feature = "Win32_Foundation")]
5742 pub struct CERT_POLICY_QUALIFIER_USER_NOTICE {
5743     pub pNoticeReference: *mut CERT_POLICY_QUALIFIER_NOTICE_REFERENCE,
5744     pub pszDisplayText: super::super::Foundation::PWSTR,
5745 }
5746 #[cfg(feature = "Win32_Foundation")]
5747 impl CERT_POLICY_QUALIFIER_USER_NOTICE {}
5748 #[cfg(feature = "Win32_Foundation")]
5749 impl ::std::default::Default for CERT_POLICY_QUALIFIER_USER_NOTICE {
default() -> Self5750     fn default() -> Self {
5751         unsafe { ::std::mem::zeroed() }
5752     }
5753 }
5754 #[cfg(feature = "Win32_Foundation")]
5755 impl ::std::fmt::Debug for CERT_POLICY_QUALIFIER_USER_NOTICE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5756     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5757         fmt.debug_struct("CERT_POLICY_QUALIFIER_USER_NOTICE").field("pNoticeReference", &self.pNoticeReference).field("pszDisplayText", &self.pszDisplayText).finish()
5758     }
5759 }
5760 #[cfg(feature = "Win32_Foundation")]
5761 impl ::std::cmp::PartialEq for CERT_POLICY_QUALIFIER_USER_NOTICE {
eq(&self, other: &Self) -> bool5762     fn eq(&self, other: &Self) -> bool {
5763         self.pNoticeReference == other.pNoticeReference && self.pszDisplayText == other.pszDisplayText
5764     }
5765 }
5766 #[cfg(feature = "Win32_Foundation")]
5767 impl ::std::cmp::Eq for CERT_POLICY_QUALIFIER_USER_NOTICE {}
5768 #[cfg(feature = "Win32_Foundation")]
5769 unsafe impl ::windows::runtime::Abi for CERT_POLICY_QUALIFIER_USER_NOTICE {
5770     type Abi = Self;
5771     type DefaultType = Self;
5772 }
5773 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5774 #[repr(C)]
5775 #[cfg(feature = "Win32_Foundation")]
5776 pub struct CERT_PRIVATE_KEY_VALIDITY {
5777     pub NotBefore: super::super::Foundation::FILETIME,
5778     pub NotAfter: super::super::Foundation::FILETIME,
5779 }
5780 #[cfg(feature = "Win32_Foundation")]
5781 impl CERT_PRIVATE_KEY_VALIDITY {}
5782 #[cfg(feature = "Win32_Foundation")]
5783 impl ::std::default::Default for CERT_PRIVATE_KEY_VALIDITY {
default() -> Self5784     fn default() -> Self {
5785         unsafe { ::std::mem::zeroed() }
5786     }
5787 }
5788 #[cfg(feature = "Win32_Foundation")]
5789 impl ::std::fmt::Debug for CERT_PRIVATE_KEY_VALIDITY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5790     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5791         fmt.debug_struct("CERT_PRIVATE_KEY_VALIDITY").field("NotBefore", &self.NotBefore).field("NotAfter", &self.NotAfter).finish()
5792     }
5793 }
5794 #[cfg(feature = "Win32_Foundation")]
5795 impl ::std::cmp::PartialEq for CERT_PRIVATE_KEY_VALIDITY {
eq(&self, other: &Self) -> bool5796     fn eq(&self, other: &Self) -> bool {
5797         self.NotBefore == other.NotBefore && self.NotAfter == other.NotAfter
5798     }
5799 }
5800 #[cfg(feature = "Win32_Foundation")]
5801 impl ::std::cmp::Eq for CERT_PRIVATE_KEY_VALIDITY {}
5802 #[cfg(feature = "Win32_Foundation")]
5803 unsafe impl ::windows::runtime::Abi for CERT_PRIVATE_KEY_VALIDITY {
5804     type Abi = Self;
5805     type DefaultType = Self;
5806 }
5807 pub const CERT_PROT_ROOT_DISABLE_CURRENT_USER_FLAG: u32 = 1u32;
5808 pub const CERT_PROT_ROOT_DISABLE_LM_AUTH_FLAG: u32 = 8u32;
5809 pub const CERT_PROT_ROOT_DISABLE_NOT_DEFINED_NAME_CONSTRAINT_FLAG: u32 = 32u32;
5810 pub const CERT_PROT_ROOT_DISABLE_NT_AUTH_REQUIRED_FLAG: u32 = 16u32;
5811 pub const CERT_PROT_ROOT_DISABLE_PEER_TRUST: u32 = 65536u32;
5812 pub const CERT_PROT_ROOT_INHIBIT_ADD_AT_INIT_FLAG: u32 = 2u32;
5813 pub const CERT_PROT_ROOT_INHIBIT_PURGE_LM_FLAG: u32 = 4u32;
5814 pub const CERT_PROT_ROOT_ONLY_LM_GPT_FLAG: u32 = 8u32;
5815 pub const CERT_PUBKEY_ALG_PARA_PROP_ID: u32 = 22u32;
5816 pub const CERT_PUBKEY_HASH_RESERVED_PROP_ID: u32 = 8u32;
5817 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5818 #[repr(C)]
5819 #[cfg(feature = "Win32_Foundation")]
5820 pub struct CERT_PUBLIC_KEY_INFO {
5821     pub Algorithm: CRYPT_ALGORITHM_IDENTIFIER,
5822     pub PublicKey: CRYPT_BIT_BLOB,
5823 }
5824 #[cfg(feature = "Win32_Foundation")]
5825 impl CERT_PUBLIC_KEY_INFO {}
5826 #[cfg(feature = "Win32_Foundation")]
5827 impl ::std::default::Default for CERT_PUBLIC_KEY_INFO {
default() -> Self5828     fn default() -> Self {
5829         unsafe { ::std::mem::zeroed() }
5830     }
5831 }
5832 #[cfg(feature = "Win32_Foundation")]
5833 impl ::std::fmt::Debug for CERT_PUBLIC_KEY_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5834     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5835         fmt.debug_struct("CERT_PUBLIC_KEY_INFO").field("Algorithm", &self.Algorithm).field("PublicKey", &self.PublicKey).finish()
5836     }
5837 }
5838 #[cfg(feature = "Win32_Foundation")]
5839 impl ::std::cmp::PartialEq for CERT_PUBLIC_KEY_INFO {
eq(&self, other: &Self) -> bool5840     fn eq(&self, other: &Self) -> bool {
5841         self.Algorithm == other.Algorithm && self.PublicKey == other.PublicKey
5842     }
5843 }
5844 #[cfg(feature = "Win32_Foundation")]
5845 impl ::std::cmp::Eq for CERT_PUBLIC_KEY_INFO {}
5846 #[cfg(feature = "Win32_Foundation")]
5847 unsafe impl ::windows::runtime::Abi for CERT_PUBLIC_KEY_INFO {
5848     type Abi = Self;
5849     type DefaultType = Self;
5850 }
5851 pub const CERT_PUB_KEY_CNG_ALG_BIT_LENGTH_PROP_ID: u32 = 93u32;
5852 pub const CERT_PVK_FILE_PROP_ID: u32 = 12u32;
5853 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5854 #[repr(C)]
5855 #[cfg(feature = "Win32_Foundation")]
5856 pub struct CERT_QC_STATEMENT {
5857     pub pszStatementId: super::super::Foundation::PSTR,
5858     pub StatementInfo: CRYPTOAPI_BLOB,
5859 }
5860 #[cfg(feature = "Win32_Foundation")]
5861 impl CERT_QC_STATEMENT {}
5862 #[cfg(feature = "Win32_Foundation")]
5863 impl ::std::default::Default for CERT_QC_STATEMENT {
default() -> Self5864     fn default() -> Self {
5865         unsafe { ::std::mem::zeroed() }
5866     }
5867 }
5868 #[cfg(feature = "Win32_Foundation")]
5869 impl ::std::fmt::Debug for CERT_QC_STATEMENT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5870     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5871         fmt.debug_struct("CERT_QC_STATEMENT").field("pszStatementId", &self.pszStatementId).field("StatementInfo", &self.StatementInfo).finish()
5872     }
5873 }
5874 #[cfg(feature = "Win32_Foundation")]
5875 impl ::std::cmp::PartialEq for CERT_QC_STATEMENT {
eq(&self, other: &Self) -> bool5876     fn eq(&self, other: &Self) -> bool {
5877         self.pszStatementId == other.pszStatementId && self.StatementInfo == other.StatementInfo
5878     }
5879 }
5880 #[cfg(feature = "Win32_Foundation")]
5881 impl ::std::cmp::Eq for CERT_QC_STATEMENT {}
5882 #[cfg(feature = "Win32_Foundation")]
5883 unsafe impl ::windows::runtime::Abi for CERT_QC_STATEMENT {
5884     type Abi = Self;
5885     type DefaultType = Self;
5886 }
5887 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5888 #[repr(C)]
5889 #[cfg(feature = "Win32_Foundation")]
5890 pub struct CERT_QC_STATEMENTS_EXT_INFO {
5891     pub cStatement: u32,
5892     pub rgStatement: *mut CERT_QC_STATEMENT,
5893 }
5894 #[cfg(feature = "Win32_Foundation")]
5895 impl CERT_QC_STATEMENTS_EXT_INFO {}
5896 #[cfg(feature = "Win32_Foundation")]
5897 impl ::std::default::Default for CERT_QC_STATEMENTS_EXT_INFO {
default() -> Self5898     fn default() -> Self {
5899         unsafe { ::std::mem::zeroed() }
5900     }
5901 }
5902 #[cfg(feature = "Win32_Foundation")]
5903 impl ::std::fmt::Debug for CERT_QC_STATEMENTS_EXT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5904     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5905         fmt.debug_struct("CERT_QC_STATEMENTS_EXT_INFO").field("cStatement", &self.cStatement).field("rgStatement", &self.rgStatement).finish()
5906     }
5907 }
5908 #[cfg(feature = "Win32_Foundation")]
5909 impl ::std::cmp::PartialEq for CERT_QC_STATEMENTS_EXT_INFO {
eq(&self, other: &Self) -> bool5910     fn eq(&self, other: &Self) -> bool {
5911         self.cStatement == other.cStatement && self.rgStatement == other.rgStatement
5912     }
5913 }
5914 #[cfg(feature = "Win32_Foundation")]
5915 impl ::std::cmp::Eq for CERT_QC_STATEMENTS_EXT_INFO {}
5916 #[cfg(feature = "Win32_Foundation")]
5917 unsafe impl ::windows::runtime::Abi for CERT_QC_STATEMENTS_EXT_INFO {
5918     type Abi = Self;
5919     type DefaultType = Self;
5920 }
5921 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5922 #[repr(transparent)]
5923 pub struct CERT_QUERY_CONTENT_TYPE(pub u32);
5924 pub const CERT_QUERY_CONTENT_CERT: CERT_QUERY_CONTENT_TYPE = CERT_QUERY_CONTENT_TYPE(1u32);
5925 pub const CERT_QUERY_CONTENT_CTL: CERT_QUERY_CONTENT_TYPE = CERT_QUERY_CONTENT_TYPE(2u32);
5926 pub const CERT_QUERY_CONTENT_CRL: CERT_QUERY_CONTENT_TYPE = CERT_QUERY_CONTENT_TYPE(3u32);
5927 pub const CERT_QUERY_CONTENT_SERIALIZED_STORE: CERT_QUERY_CONTENT_TYPE = CERT_QUERY_CONTENT_TYPE(4u32);
5928 pub const CERT_QUERY_CONTENT_SERIALIZED_CERT: CERT_QUERY_CONTENT_TYPE = CERT_QUERY_CONTENT_TYPE(5u32);
5929 pub const CERT_QUERY_CONTENT_SERIALIZED_CTL: CERT_QUERY_CONTENT_TYPE = CERT_QUERY_CONTENT_TYPE(6u32);
5930 pub const CERT_QUERY_CONTENT_SERIALIZED_CRL: CERT_QUERY_CONTENT_TYPE = CERT_QUERY_CONTENT_TYPE(7u32);
5931 pub const CERT_QUERY_CONTENT_PKCS7_SIGNED: CERT_QUERY_CONTENT_TYPE = CERT_QUERY_CONTENT_TYPE(8u32);
5932 pub const CERT_QUERY_CONTENT_PKCS7_UNSIGNED: CERT_QUERY_CONTENT_TYPE = CERT_QUERY_CONTENT_TYPE(9u32);
5933 pub const CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED: CERT_QUERY_CONTENT_TYPE = CERT_QUERY_CONTENT_TYPE(10u32);
5934 pub const CERT_QUERY_CONTENT_PKCS10: CERT_QUERY_CONTENT_TYPE = CERT_QUERY_CONTENT_TYPE(11u32);
5935 pub const CERT_QUERY_CONTENT_PFX: CERT_QUERY_CONTENT_TYPE = CERT_QUERY_CONTENT_TYPE(12u32);
5936 pub const CERT_QUERY_CONTENT_CERT_PAIR: CERT_QUERY_CONTENT_TYPE = CERT_QUERY_CONTENT_TYPE(13u32);
5937 pub const CERT_QUERY_CONTENT_PFX_AND_LOAD: CERT_QUERY_CONTENT_TYPE = CERT_QUERY_CONTENT_TYPE(14u32);
5938 impl ::std::convert::From<u32> for CERT_QUERY_CONTENT_TYPE {
from(value: u32) -> Self5939     fn from(value: u32) -> Self {
5940         Self(value)
5941     }
5942 }
5943 unsafe impl ::windows::runtime::Abi for CERT_QUERY_CONTENT_TYPE {
5944     type Abi = Self;
5945     type DefaultType = Self;
5946 }
5947 impl ::std::ops::BitOr for CERT_QUERY_CONTENT_TYPE {
5948     type Output = Self;
bitor(self, rhs: Self) -> Self5949     fn bitor(self, rhs: Self) -> Self {
5950         Self(self.0 | rhs.0)
5951     }
5952 }
5953 impl ::std::ops::BitAnd for CERT_QUERY_CONTENT_TYPE {
5954     type Output = Self;
bitand(self, rhs: Self) -> Self5955     fn bitand(self, rhs: Self) -> Self {
5956         Self(self.0 & rhs.0)
5957     }
5958 }
5959 impl ::std::ops::BitOrAssign for CERT_QUERY_CONTENT_TYPE {
bitor_assign(&mut self, rhs: Self)5960     fn bitor_assign(&mut self, rhs: Self) {
5961         self.0.bitor_assign(rhs.0)
5962     }
5963 }
5964 impl ::std::ops::BitAndAssign for CERT_QUERY_CONTENT_TYPE {
bitand_assign(&mut self, rhs: Self)5965     fn bitand_assign(&mut self, rhs: Self) {
5966         self.0.bitand_assign(rhs.0)
5967     }
5968 }
5969 impl ::std::ops::Not for CERT_QUERY_CONTENT_TYPE {
5970     type Output = Self;
not(self) -> Self5971     fn not(self) -> Self {
5972         Self(self.0.not())
5973     }
5974 }
5975 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5976 #[repr(transparent)]
5977 pub struct CERT_QUERY_CONTENT_TYPE_FLAGS(pub u32);
5978 pub const CERT_QUERY_CONTENT_FLAG_CERT: CERT_QUERY_CONTENT_TYPE_FLAGS = CERT_QUERY_CONTENT_TYPE_FLAGS(2u32);
5979 pub const CERT_QUERY_CONTENT_FLAG_CTL: CERT_QUERY_CONTENT_TYPE_FLAGS = CERT_QUERY_CONTENT_TYPE_FLAGS(4u32);
5980 pub const CERT_QUERY_CONTENT_FLAG_CRL: CERT_QUERY_CONTENT_TYPE_FLAGS = CERT_QUERY_CONTENT_TYPE_FLAGS(8u32);
5981 pub const CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE: CERT_QUERY_CONTENT_TYPE_FLAGS = CERT_QUERY_CONTENT_TYPE_FLAGS(16u32);
5982 pub const CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT: CERT_QUERY_CONTENT_TYPE_FLAGS = CERT_QUERY_CONTENT_TYPE_FLAGS(32u32);
5983 pub const CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL: CERT_QUERY_CONTENT_TYPE_FLAGS = CERT_QUERY_CONTENT_TYPE_FLAGS(64u32);
5984 pub const CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL: CERT_QUERY_CONTENT_TYPE_FLAGS = CERT_QUERY_CONTENT_TYPE_FLAGS(128u32);
5985 pub const CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED: CERT_QUERY_CONTENT_TYPE_FLAGS = CERT_QUERY_CONTENT_TYPE_FLAGS(256u32);
5986 pub const CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED: CERT_QUERY_CONTENT_TYPE_FLAGS = CERT_QUERY_CONTENT_TYPE_FLAGS(512u32);
5987 pub const CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED: CERT_QUERY_CONTENT_TYPE_FLAGS = CERT_QUERY_CONTENT_TYPE_FLAGS(1024u32);
5988 pub const CERT_QUERY_CONTENT_FLAG_PKCS10: CERT_QUERY_CONTENT_TYPE_FLAGS = CERT_QUERY_CONTENT_TYPE_FLAGS(2048u32);
5989 pub const CERT_QUERY_CONTENT_FLAG_PFX: CERT_QUERY_CONTENT_TYPE_FLAGS = CERT_QUERY_CONTENT_TYPE_FLAGS(4096u32);
5990 pub const CERT_QUERY_CONTENT_FLAG_CERT_PAIR: CERT_QUERY_CONTENT_TYPE_FLAGS = CERT_QUERY_CONTENT_TYPE_FLAGS(8192u32);
5991 pub const CERT_QUERY_CONTENT_FLAG_PFX_AND_LOAD: CERT_QUERY_CONTENT_TYPE_FLAGS = CERT_QUERY_CONTENT_TYPE_FLAGS(16384u32);
5992 pub const CERT_QUERY_CONTENT_FLAG_ALL: CERT_QUERY_CONTENT_TYPE_FLAGS = CERT_QUERY_CONTENT_TYPE_FLAGS(16382u32);
5993 pub const CERT_QUERY_CONTENT_FLAG_ALL_ISSUER_CERT: CERT_QUERY_CONTENT_TYPE_FLAGS = CERT_QUERY_CONTENT_TYPE_FLAGS(818u32);
5994 impl ::std::convert::From<u32> for CERT_QUERY_CONTENT_TYPE_FLAGS {
from(value: u32) -> Self5995     fn from(value: u32) -> Self {
5996         Self(value)
5997     }
5998 }
5999 unsafe impl ::windows::runtime::Abi for CERT_QUERY_CONTENT_TYPE_FLAGS {
6000     type Abi = Self;
6001     type DefaultType = Self;
6002 }
6003 impl ::std::ops::BitOr for CERT_QUERY_CONTENT_TYPE_FLAGS {
6004     type Output = Self;
bitor(self, rhs: Self) -> Self6005     fn bitor(self, rhs: Self) -> Self {
6006         Self(self.0 | rhs.0)
6007     }
6008 }
6009 impl ::std::ops::BitAnd for CERT_QUERY_CONTENT_TYPE_FLAGS {
6010     type Output = Self;
bitand(self, rhs: Self) -> Self6011     fn bitand(self, rhs: Self) -> Self {
6012         Self(self.0 & rhs.0)
6013     }
6014 }
6015 impl ::std::ops::BitOrAssign for CERT_QUERY_CONTENT_TYPE_FLAGS {
bitor_assign(&mut self, rhs: Self)6016     fn bitor_assign(&mut self, rhs: Self) {
6017         self.0.bitor_assign(rhs.0)
6018     }
6019 }
6020 impl ::std::ops::BitAndAssign for CERT_QUERY_CONTENT_TYPE_FLAGS {
bitand_assign(&mut self, rhs: Self)6021     fn bitand_assign(&mut self, rhs: Self) {
6022         self.0.bitand_assign(rhs.0)
6023     }
6024 }
6025 impl ::std::ops::Not for CERT_QUERY_CONTENT_TYPE_FLAGS {
6026     type Output = Self;
not(self) -> Self6027     fn not(self) -> Self {
6028         Self(self.0.not())
6029     }
6030 }
6031 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6032 #[repr(transparent)]
6033 pub struct CERT_QUERY_ENCODING_TYPE(pub u32);
6034 pub const X509_ASN_ENCODING: CERT_QUERY_ENCODING_TYPE = CERT_QUERY_ENCODING_TYPE(1u32);
6035 pub const PKCS_7_ASN_ENCODING: CERT_QUERY_ENCODING_TYPE = CERT_QUERY_ENCODING_TYPE(65536u32);
6036 impl ::std::convert::From<u32> for CERT_QUERY_ENCODING_TYPE {
from(value: u32) -> Self6037     fn from(value: u32) -> Self {
6038         Self(value)
6039     }
6040 }
6041 unsafe impl ::windows::runtime::Abi for CERT_QUERY_ENCODING_TYPE {
6042     type Abi = Self;
6043     type DefaultType = Self;
6044 }
6045 impl ::std::ops::BitOr for CERT_QUERY_ENCODING_TYPE {
6046     type Output = Self;
bitor(self, rhs: Self) -> Self6047     fn bitor(self, rhs: Self) -> Self {
6048         Self(self.0 | rhs.0)
6049     }
6050 }
6051 impl ::std::ops::BitAnd for CERT_QUERY_ENCODING_TYPE {
6052     type Output = Self;
bitand(self, rhs: Self) -> Self6053     fn bitand(self, rhs: Self) -> Self {
6054         Self(self.0 & rhs.0)
6055     }
6056 }
6057 impl ::std::ops::BitOrAssign for CERT_QUERY_ENCODING_TYPE {
bitor_assign(&mut self, rhs: Self)6058     fn bitor_assign(&mut self, rhs: Self) {
6059         self.0.bitor_assign(rhs.0)
6060     }
6061 }
6062 impl ::std::ops::BitAndAssign for CERT_QUERY_ENCODING_TYPE {
bitand_assign(&mut self, rhs: Self)6063     fn bitand_assign(&mut self, rhs: Self) {
6064         self.0.bitand_assign(rhs.0)
6065     }
6066 }
6067 impl ::std::ops::Not for CERT_QUERY_ENCODING_TYPE {
6068     type Output = Self;
not(self) -> Self6069     fn not(self) -> Self {
6070         Self(self.0.not())
6071     }
6072 }
6073 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6074 #[repr(transparent)]
6075 pub struct CERT_QUERY_FORMAT_TYPE(pub u32);
6076 pub const CERT_QUERY_FORMAT_BINARY: CERT_QUERY_FORMAT_TYPE = CERT_QUERY_FORMAT_TYPE(1u32);
6077 pub const CERT_QUERY_FORMAT_BASE64_ENCODED: CERT_QUERY_FORMAT_TYPE = CERT_QUERY_FORMAT_TYPE(2u32);
6078 pub const CERT_QUERY_FORMAT_ASN_ASCII_HEX_ENCODED: CERT_QUERY_FORMAT_TYPE = CERT_QUERY_FORMAT_TYPE(3u32);
6079 impl ::std::convert::From<u32> for CERT_QUERY_FORMAT_TYPE {
from(value: u32) -> Self6080     fn from(value: u32) -> Self {
6081         Self(value)
6082     }
6083 }
6084 unsafe impl ::windows::runtime::Abi for CERT_QUERY_FORMAT_TYPE {
6085     type Abi = Self;
6086     type DefaultType = Self;
6087 }
6088 impl ::std::ops::BitOr for CERT_QUERY_FORMAT_TYPE {
6089     type Output = Self;
bitor(self, rhs: Self) -> Self6090     fn bitor(self, rhs: Self) -> Self {
6091         Self(self.0 | rhs.0)
6092     }
6093 }
6094 impl ::std::ops::BitAnd for CERT_QUERY_FORMAT_TYPE {
6095     type Output = Self;
bitand(self, rhs: Self) -> Self6096     fn bitand(self, rhs: Self) -> Self {
6097         Self(self.0 & rhs.0)
6098     }
6099 }
6100 impl ::std::ops::BitOrAssign for CERT_QUERY_FORMAT_TYPE {
bitor_assign(&mut self, rhs: Self)6101     fn bitor_assign(&mut self, rhs: Self) {
6102         self.0.bitor_assign(rhs.0)
6103     }
6104 }
6105 impl ::std::ops::BitAndAssign for CERT_QUERY_FORMAT_TYPE {
bitand_assign(&mut self, rhs: Self)6106     fn bitand_assign(&mut self, rhs: Self) {
6107         self.0.bitand_assign(rhs.0)
6108     }
6109 }
6110 impl ::std::ops::Not for CERT_QUERY_FORMAT_TYPE {
6111     type Output = Self;
not(self) -> Self6112     fn not(self) -> Self {
6113         Self(self.0.not())
6114     }
6115 }
6116 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6117 #[repr(transparent)]
6118 pub struct CERT_QUERY_FORMAT_TYPE_FLAGS(pub u32);
6119 pub const CERT_QUERY_FORMAT_FLAG_BINARY: CERT_QUERY_FORMAT_TYPE_FLAGS = CERT_QUERY_FORMAT_TYPE_FLAGS(2u32);
6120 pub const CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED: CERT_QUERY_FORMAT_TYPE_FLAGS = CERT_QUERY_FORMAT_TYPE_FLAGS(4u32);
6121 pub const CERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODED: CERT_QUERY_FORMAT_TYPE_FLAGS = CERT_QUERY_FORMAT_TYPE_FLAGS(8u32);
6122 pub const CERT_QUERY_FORMAT_FLAG_ALL: CERT_QUERY_FORMAT_TYPE_FLAGS = CERT_QUERY_FORMAT_TYPE_FLAGS(14u32);
6123 impl ::std::convert::From<u32> for CERT_QUERY_FORMAT_TYPE_FLAGS {
from(value: u32) -> Self6124     fn from(value: u32) -> Self {
6125         Self(value)
6126     }
6127 }
6128 unsafe impl ::windows::runtime::Abi for CERT_QUERY_FORMAT_TYPE_FLAGS {
6129     type Abi = Self;
6130     type DefaultType = Self;
6131 }
6132 impl ::std::ops::BitOr for CERT_QUERY_FORMAT_TYPE_FLAGS {
6133     type Output = Self;
bitor(self, rhs: Self) -> Self6134     fn bitor(self, rhs: Self) -> Self {
6135         Self(self.0 | rhs.0)
6136     }
6137 }
6138 impl ::std::ops::BitAnd for CERT_QUERY_FORMAT_TYPE_FLAGS {
6139     type Output = Self;
bitand(self, rhs: Self) -> Self6140     fn bitand(self, rhs: Self) -> Self {
6141         Self(self.0 & rhs.0)
6142     }
6143 }
6144 impl ::std::ops::BitOrAssign for CERT_QUERY_FORMAT_TYPE_FLAGS {
bitor_assign(&mut self, rhs: Self)6145     fn bitor_assign(&mut self, rhs: Self) {
6146         self.0.bitor_assign(rhs.0)
6147     }
6148 }
6149 impl ::std::ops::BitAndAssign for CERT_QUERY_FORMAT_TYPE_FLAGS {
bitand_assign(&mut self, rhs: Self)6150     fn bitand_assign(&mut self, rhs: Self) {
6151         self.0.bitand_assign(rhs.0)
6152     }
6153 }
6154 impl ::std::ops::Not for CERT_QUERY_FORMAT_TYPE_FLAGS {
6155     type Output = Self;
not(self) -> Self6156     fn not(self) -> Self {
6157         Self(self.0.not())
6158     }
6159 }
6160 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6161 #[repr(transparent)]
6162 pub struct CERT_QUERY_OBJECT_TYPE(pub u32);
6163 pub const CERT_QUERY_OBJECT_FILE: CERT_QUERY_OBJECT_TYPE = CERT_QUERY_OBJECT_TYPE(1u32);
6164 pub const CERT_QUERY_OBJECT_BLOB: CERT_QUERY_OBJECT_TYPE = CERT_QUERY_OBJECT_TYPE(2u32);
6165 impl ::std::convert::From<u32> for CERT_QUERY_OBJECT_TYPE {
from(value: u32) -> Self6166     fn from(value: u32) -> Self {
6167         Self(value)
6168     }
6169 }
6170 unsafe impl ::windows::runtime::Abi for CERT_QUERY_OBJECT_TYPE {
6171     type Abi = Self;
6172     type DefaultType = Self;
6173 }
6174 impl ::std::ops::BitOr for CERT_QUERY_OBJECT_TYPE {
6175     type Output = Self;
bitor(self, rhs: Self) -> Self6176     fn bitor(self, rhs: Self) -> Self {
6177         Self(self.0 | rhs.0)
6178     }
6179 }
6180 impl ::std::ops::BitAnd for CERT_QUERY_OBJECT_TYPE {
6181     type Output = Self;
bitand(self, rhs: Self) -> Self6182     fn bitand(self, rhs: Self) -> Self {
6183         Self(self.0 & rhs.0)
6184     }
6185 }
6186 impl ::std::ops::BitOrAssign for CERT_QUERY_OBJECT_TYPE {
bitor_assign(&mut self, rhs: Self)6187     fn bitor_assign(&mut self, rhs: Self) {
6188         self.0.bitor_assign(rhs.0)
6189     }
6190 }
6191 impl ::std::ops::BitAndAssign for CERT_QUERY_OBJECT_TYPE {
bitand_assign(&mut self, rhs: Self)6192     fn bitand_assign(&mut self, rhs: Self) {
6193         self.0.bitand_assign(rhs.0)
6194     }
6195 }
6196 impl ::std::ops::Not for CERT_QUERY_OBJECT_TYPE {
6197     type Output = Self;
not(self) -> Self6198     fn not(self) -> Self {
6199         Self(self.0.not())
6200     }
6201 }
6202 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6203 #[repr(C)]
6204 #[cfg(feature = "Win32_Foundation")]
6205 pub struct CERT_RDN {
6206     pub cRDNAttr: u32,
6207     pub rgRDNAttr: *mut CERT_RDN_ATTR,
6208 }
6209 #[cfg(feature = "Win32_Foundation")]
6210 impl CERT_RDN {}
6211 #[cfg(feature = "Win32_Foundation")]
6212 impl ::std::default::Default for CERT_RDN {
default() -> Self6213     fn default() -> Self {
6214         unsafe { ::std::mem::zeroed() }
6215     }
6216 }
6217 #[cfg(feature = "Win32_Foundation")]
6218 impl ::std::fmt::Debug for CERT_RDN {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6219     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6220         fmt.debug_struct("CERT_RDN").field("cRDNAttr", &self.cRDNAttr).field("rgRDNAttr", &self.rgRDNAttr).finish()
6221     }
6222 }
6223 #[cfg(feature = "Win32_Foundation")]
6224 impl ::std::cmp::PartialEq for CERT_RDN {
eq(&self, other: &Self) -> bool6225     fn eq(&self, other: &Self) -> bool {
6226         self.cRDNAttr == other.cRDNAttr && self.rgRDNAttr == other.rgRDNAttr
6227     }
6228 }
6229 #[cfg(feature = "Win32_Foundation")]
6230 impl ::std::cmp::Eq for CERT_RDN {}
6231 #[cfg(feature = "Win32_Foundation")]
6232 unsafe impl ::windows::runtime::Abi for CERT_RDN {
6233     type Abi = Self;
6234     type DefaultType = Self;
6235 }
6236 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6237 #[repr(C)]
6238 #[cfg(feature = "Win32_Foundation")]
6239 pub struct CERT_RDN_ATTR {
6240     pub pszObjId: super::super::Foundation::PSTR,
6241     pub dwValueType: CERT_RDN_ATTR_VALUE_TYPE,
6242     pub Value: CRYPTOAPI_BLOB,
6243 }
6244 #[cfg(feature = "Win32_Foundation")]
6245 impl CERT_RDN_ATTR {}
6246 #[cfg(feature = "Win32_Foundation")]
6247 impl ::std::default::Default for CERT_RDN_ATTR {
default() -> Self6248     fn default() -> Self {
6249         unsafe { ::std::mem::zeroed() }
6250     }
6251 }
6252 #[cfg(feature = "Win32_Foundation")]
6253 impl ::std::fmt::Debug for CERT_RDN_ATTR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6254     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6255         fmt.debug_struct("CERT_RDN_ATTR").field("pszObjId", &self.pszObjId).field("dwValueType", &self.dwValueType).field("Value", &self.Value).finish()
6256     }
6257 }
6258 #[cfg(feature = "Win32_Foundation")]
6259 impl ::std::cmp::PartialEq for CERT_RDN_ATTR {
eq(&self, other: &Self) -> bool6260     fn eq(&self, other: &Self) -> bool {
6261         self.pszObjId == other.pszObjId && self.dwValueType == other.dwValueType && self.Value == other.Value
6262     }
6263 }
6264 #[cfg(feature = "Win32_Foundation")]
6265 impl ::std::cmp::Eq for CERT_RDN_ATTR {}
6266 #[cfg(feature = "Win32_Foundation")]
6267 unsafe impl ::windows::runtime::Abi for CERT_RDN_ATTR {
6268     type Abi = Self;
6269     type DefaultType = Self;
6270 }
6271 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6272 #[repr(transparent)]
6273 pub struct CERT_RDN_ATTR_VALUE_TYPE(pub u32);
6274 pub const CERT_RDN_ANY_TYPE: CERT_RDN_ATTR_VALUE_TYPE = CERT_RDN_ATTR_VALUE_TYPE(0u32);
6275 pub const CERT_RDN_NUMERIC_STRING: CERT_RDN_ATTR_VALUE_TYPE = CERT_RDN_ATTR_VALUE_TYPE(3u32);
6276 pub const CERT_RDN_PRINTABLE_STRING: CERT_RDN_ATTR_VALUE_TYPE = CERT_RDN_ATTR_VALUE_TYPE(4u32);
6277 pub const CERT_RDN_T61_STRING: CERT_RDN_ATTR_VALUE_TYPE = CERT_RDN_ATTR_VALUE_TYPE(5u32);
6278 pub const CERT_RDN_VIDEOTEX_STRING: CERT_RDN_ATTR_VALUE_TYPE = CERT_RDN_ATTR_VALUE_TYPE(6u32);
6279 pub const CERT_RDN_IA5_STRING: CERT_RDN_ATTR_VALUE_TYPE = CERT_RDN_ATTR_VALUE_TYPE(7u32);
6280 pub const CERT_RDN_GRAPHIC_STRING: CERT_RDN_ATTR_VALUE_TYPE = CERT_RDN_ATTR_VALUE_TYPE(8u32);
6281 pub const CERT_RDN_ISO646_STRING: CERT_RDN_ATTR_VALUE_TYPE = CERT_RDN_ATTR_VALUE_TYPE(9u32);
6282 pub const CERT_RDN_GENERAL_STRING: CERT_RDN_ATTR_VALUE_TYPE = CERT_RDN_ATTR_VALUE_TYPE(10u32);
6283 pub const CERT_RDN_INT4_STRING: CERT_RDN_ATTR_VALUE_TYPE = CERT_RDN_ATTR_VALUE_TYPE(11u32);
6284 pub const CERT_RDN_UNICODE_STRING: CERT_RDN_ATTR_VALUE_TYPE = CERT_RDN_ATTR_VALUE_TYPE(12u32);
6285 pub const CERT_RDN_BMP_STRING: CERT_RDN_ATTR_VALUE_TYPE = CERT_RDN_ATTR_VALUE_TYPE(12u32);
6286 pub const CERT_RDN_ENCODED_BLOB: CERT_RDN_ATTR_VALUE_TYPE = CERT_RDN_ATTR_VALUE_TYPE(1u32);
6287 pub const CERT_RDN_OCTET_STRING: CERT_RDN_ATTR_VALUE_TYPE = CERT_RDN_ATTR_VALUE_TYPE(2u32);
6288 pub const CERT_RDN_TELETEX_STRING: CERT_RDN_ATTR_VALUE_TYPE = CERT_RDN_ATTR_VALUE_TYPE(5u32);
6289 pub const CERT_RDN_UNIVERSAL_STRING: CERT_RDN_ATTR_VALUE_TYPE = CERT_RDN_ATTR_VALUE_TYPE(11u32);
6290 pub const CERT_RDN_UTF8_STRING: CERT_RDN_ATTR_VALUE_TYPE = CERT_RDN_ATTR_VALUE_TYPE(13u32);
6291 pub const CERT_RDN_VISIBLE_STRING: CERT_RDN_ATTR_VALUE_TYPE = CERT_RDN_ATTR_VALUE_TYPE(9u32);
6292 impl ::std::convert::From<u32> for CERT_RDN_ATTR_VALUE_TYPE {
from(value: u32) -> Self6293     fn from(value: u32) -> Self {
6294         Self(value)
6295     }
6296 }
6297 unsafe impl ::windows::runtime::Abi for CERT_RDN_ATTR_VALUE_TYPE {
6298     type Abi = Self;
6299     type DefaultType = Self;
6300 }
6301 impl ::std::ops::BitOr for CERT_RDN_ATTR_VALUE_TYPE {
6302     type Output = Self;
bitor(self, rhs: Self) -> Self6303     fn bitor(self, rhs: Self) -> Self {
6304         Self(self.0 | rhs.0)
6305     }
6306 }
6307 impl ::std::ops::BitAnd for CERT_RDN_ATTR_VALUE_TYPE {
6308     type Output = Self;
bitand(self, rhs: Self) -> Self6309     fn bitand(self, rhs: Self) -> Self {
6310         Self(self.0 & rhs.0)
6311     }
6312 }
6313 impl ::std::ops::BitOrAssign for CERT_RDN_ATTR_VALUE_TYPE {
bitor_assign(&mut self, rhs: Self)6314     fn bitor_assign(&mut self, rhs: Self) {
6315         self.0.bitor_assign(rhs.0)
6316     }
6317 }
6318 impl ::std::ops::BitAndAssign for CERT_RDN_ATTR_VALUE_TYPE {
bitand_assign(&mut self, rhs: Self)6319     fn bitand_assign(&mut self, rhs: Self) {
6320         self.0.bitand_assign(rhs.0)
6321     }
6322 }
6323 impl ::std::ops::Not for CERT_RDN_ATTR_VALUE_TYPE {
6324     type Output = Self;
not(self) -> Self6325     fn not(self) -> Self {
6326         Self(self.0.not())
6327     }
6328 }
6329 pub const CERT_RDN_DISABLE_CHECK_TYPE_FLAG: u32 = 1073741824u32;
6330 pub const CERT_RDN_DISABLE_IE4_UTF8_FLAG: u32 = 16777216u32;
6331 pub const CERT_RDN_ENABLE_PUNYCODE_FLAG: u32 = 33554432u32;
6332 pub const CERT_RDN_ENABLE_T61_UNICODE_FLAG: u32 = 2147483648u32;
6333 pub const CERT_RDN_ENABLE_UTF8_UNICODE_FLAG: u32 = 536870912u32;
6334 pub const CERT_RDN_FLAGS_MASK: u32 = 4278190080u32;
6335 pub const CERT_RDN_FORCE_UTF8_UNICODE_FLAG: u32 = 268435456u32;
6336 pub const CERT_RDN_TYPE_MASK: u32 = 255u32;
6337 pub const CERT_REGISTRY_STORE_CLIENT_GPT_FLAG: u32 = 2147483648u32;
6338 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6339 #[repr(C)]
6340 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
6341 pub struct CERT_REGISTRY_STORE_CLIENT_GPT_PARA {
6342     pub hKeyBase: super::super::System::Registry::HKEY,
6343     pub pwszRegPath: super::super::Foundation::PWSTR,
6344 }
6345 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
6346 impl CERT_REGISTRY_STORE_CLIENT_GPT_PARA {}
6347 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
6348 impl ::std::default::Default for CERT_REGISTRY_STORE_CLIENT_GPT_PARA {
default() -> Self6349     fn default() -> Self {
6350         unsafe { ::std::mem::zeroed() }
6351     }
6352 }
6353 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
6354 impl ::std::fmt::Debug for CERT_REGISTRY_STORE_CLIENT_GPT_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6355     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6356         fmt.debug_struct("CERT_REGISTRY_STORE_CLIENT_GPT_PARA").field("hKeyBase", &self.hKeyBase).field("pwszRegPath", &self.pwszRegPath).finish()
6357     }
6358 }
6359 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
6360 impl ::std::cmp::PartialEq for CERT_REGISTRY_STORE_CLIENT_GPT_PARA {
eq(&self, other: &Self) -> bool6361     fn eq(&self, other: &Self) -> bool {
6362         self.hKeyBase == other.hKeyBase && self.pwszRegPath == other.pwszRegPath
6363     }
6364 }
6365 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
6366 impl ::std::cmp::Eq for CERT_REGISTRY_STORE_CLIENT_GPT_PARA {}
6367 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
6368 unsafe impl ::windows::runtime::Abi for CERT_REGISTRY_STORE_CLIENT_GPT_PARA {
6369     type Abi = Self;
6370     type DefaultType = Self;
6371 }
6372 pub const CERT_REGISTRY_STORE_EXTERNAL_FLAG: u32 = 1048576u32;
6373 pub const CERT_REGISTRY_STORE_LM_GPT_FLAG: u32 = 16777216u32;
6374 pub const CERT_REGISTRY_STORE_MY_IE_DIRTY_FLAG: u32 = 524288u32;
6375 pub const CERT_REGISTRY_STORE_REMOTE_FLAG: u32 = 65536u32;
6376 pub const CERT_REGISTRY_STORE_ROAMING_FLAG: u32 = 262144u32;
6377 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6378 #[repr(C)]
6379 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
6380 pub struct CERT_REGISTRY_STORE_ROAMING_PARA {
6381     pub hKey: super::super::System::Registry::HKEY,
6382     pub pwszStoreDirectory: super::super::Foundation::PWSTR,
6383 }
6384 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
6385 impl CERT_REGISTRY_STORE_ROAMING_PARA {}
6386 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
6387 impl ::std::default::Default for CERT_REGISTRY_STORE_ROAMING_PARA {
default() -> Self6388     fn default() -> Self {
6389         unsafe { ::std::mem::zeroed() }
6390     }
6391 }
6392 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
6393 impl ::std::fmt::Debug for CERT_REGISTRY_STORE_ROAMING_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6394     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6395         fmt.debug_struct("CERT_REGISTRY_STORE_ROAMING_PARA").field("hKey", &self.hKey).field("pwszStoreDirectory", &self.pwszStoreDirectory).finish()
6396     }
6397 }
6398 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
6399 impl ::std::cmp::PartialEq for CERT_REGISTRY_STORE_ROAMING_PARA {
eq(&self, other: &Self) -> bool6400     fn eq(&self, other: &Self) -> bool {
6401         self.hKey == other.hKey && self.pwszStoreDirectory == other.pwszStoreDirectory
6402     }
6403 }
6404 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
6405 impl ::std::cmp::Eq for CERT_REGISTRY_STORE_ROAMING_PARA {}
6406 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
6407 unsafe impl ::windows::runtime::Abi for CERT_REGISTRY_STORE_ROAMING_PARA {
6408     type Abi = Self;
6409     type DefaultType = Self;
6410 }
6411 pub const CERT_REGISTRY_STORE_SERIALIZED_FLAG: u32 = 131072u32;
6412 pub const CERT_RENEWAL_PROP_ID: u32 = 64u32;
6413 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6414 #[repr(C)]
6415 #[cfg(feature = "Win32_Foundation")]
6416 pub struct CERT_REQUEST_INFO {
6417     pub dwVersion: u32,
6418     pub Subject: CRYPTOAPI_BLOB,
6419     pub SubjectPublicKeyInfo: CERT_PUBLIC_KEY_INFO,
6420     pub cAttribute: u32,
6421     pub rgAttribute: *mut CRYPT_ATTRIBUTE,
6422 }
6423 #[cfg(feature = "Win32_Foundation")]
6424 impl CERT_REQUEST_INFO {}
6425 #[cfg(feature = "Win32_Foundation")]
6426 impl ::std::default::Default for CERT_REQUEST_INFO {
default() -> Self6427     fn default() -> Self {
6428         unsafe { ::std::mem::zeroed() }
6429     }
6430 }
6431 #[cfg(feature = "Win32_Foundation")]
6432 impl ::std::fmt::Debug for CERT_REQUEST_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6433     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6434         fmt.debug_struct("CERT_REQUEST_INFO").field("dwVersion", &self.dwVersion).field("Subject", &self.Subject).field("SubjectPublicKeyInfo", &self.SubjectPublicKeyInfo).field("cAttribute", &self.cAttribute).field("rgAttribute", &self.rgAttribute).finish()
6435     }
6436 }
6437 #[cfg(feature = "Win32_Foundation")]
6438 impl ::std::cmp::PartialEq for CERT_REQUEST_INFO {
eq(&self, other: &Self) -> bool6439     fn eq(&self, other: &Self) -> bool {
6440         self.dwVersion == other.dwVersion && self.Subject == other.Subject && self.SubjectPublicKeyInfo == other.SubjectPublicKeyInfo && self.cAttribute == other.cAttribute && self.rgAttribute == other.rgAttribute
6441     }
6442 }
6443 #[cfg(feature = "Win32_Foundation")]
6444 impl ::std::cmp::Eq for CERT_REQUEST_INFO {}
6445 #[cfg(feature = "Win32_Foundation")]
6446 unsafe impl ::windows::runtime::Abi for CERT_REQUEST_INFO {
6447     type Abi = Self;
6448     type DefaultType = Self;
6449 }
6450 pub const CERT_REQUEST_ORIGINATOR_PROP_ID: u32 = 71u32;
6451 pub const CERT_REQUEST_V1: u32 = 0u32;
6452 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6453 #[repr(C)]
6454 #[cfg(feature = "Win32_Foundation")]
6455 pub struct CERT_REVOCATION_CHAIN_PARA {
6456     pub cbSize: u32,
6457     pub hChainEngine: HCERTCHAINENGINE,
6458     pub hAdditionalStore: *mut ::std::ffi::c_void,
6459     pub dwChainFlags: u32,
6460     pub dwUrlRetrievalTimeout: u32,
6461     pub pftCurrentTime: *mut super::super::Foundation::FILETIME,
6462     pub pftCacheResync: *mut super::super::Foundation::FILETIME,
6463     pub cbMaxUrlRetrievalByteCount: u32,
6464 }
6465 #[cfg(feature = "Win32_Foundation")]
6466 impl CERT_REVOCATION_CHAIN_PARA {}
6467 #[cfg(feature = "Win32_Foundation")]
6468 impl ::std::default::Default for CERT_REVOCATION_CHAIN_PARA {
default() -> Self6469     fn default() -> Self {
6470         unsafe { ::std::mem::zeroed() }
6471     }
6472 }
6473 #[cfg(feature = "Win32_Foundation")]
6474 impl ::std::fmt::Debug for CERT_REVOCATION_CHAIN_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6475     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6476         fmt.debug_struct("CERT_REVOCATION_CHAIN_PARA")
6477             .field("cbSize", &self.cbSize)
6478             .field("hChainEngine", &self.hChainEngine)
6479             .field("hAdditionalStore", &self.hAdditionalStore)
6480             .field("dwChainFlags", &self.dwChainFlags)
6481             .field("dwUrlRetrievalTimeout", &self.dwUrlRetrievalTimeout)
6482             .field("pftCurrentTime", &self.pftCurrentTime)
6483             .field("pftCacheResync", &self.pftCacheResync)
6484             .field("cbMaxUrlRetrievalByteCount", &self.cbMaxUrlRetrievalByteCount)
6485             .finish()
6486     }
6487 }
6488 #[cfg(feature = "Win32_Foundation")]
6489 impl ::std::cmp::PartialEq for CERT_REVOCATION_CHAIN_PARA {
eq(&self, other: &Self) -> bool6490     fn eq(&self, other: &Self) -> bool {
6491         self.cbSize == other.cbSize && self.hChainEngine == other.hChainEngine && self.hAdditionalStore == other.hAdditionalStore && self.dwChainFlags == other.dwChainFlags && self.dwUrlRetrievalTimeout == other.dwUrlRetrievalTimeout && self.pftCurrentTime == other.pftCurrentTime && self.pftCacheResync == other.pftCacheResync && self.cbMaxUrlRetrievalByteCount == other.cbMaxUrlRetrievalByteCount
6492     }
6493 }
6494 #[cfg(feature = "Win32_Foundation")]
6495 impl ::std::cmp::Eq for CERT_REVOCATION_CHAIN_PARA {}
6496 #[cfg(feature = "Win32_Foundation")]
6497 unsafe impl ::windows::runtime::Abi for CERT_REVOCATION_CHAIN_PARA {
6498     type Abi = Self;
6499     type DefaultType = Self;
6500 }
6501 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6502 #[repr(C)]
6503 #[cfg(feature = "Win32_Foundation")]
6504 pub struct CERT_REVOCATION_CRL_INFO {
6505     pub cbSize: u32,
6506     pub pBaseCrlContext: *mut CRL_CONTEXT,
6507     pub pDeltaCrlContext: *mut CRL_CONTEXT,
6508     pub pCrlEntry: *mut CRL_ENTRY,
6509     pub fDeltaCrlEntry: super::super::Foundation::BOOL,
6510 }
6511 #[cfg(feature = "Win32_Foundation")]
6512 impl CERT_REVOCATION_CRL_INFO {}
6513 #[cfg(feature = "Win32_Foundation")]
6514 impl ::std::default::Default for CERT_REVOCATION_CRL_INFO {
default() -> Self6515     fn default() -> Self {
6516         unsafe { ::std::mem::zeroed() }
6517     }
6518 }
6519 #[cfg(feature = "Win32_Foundation")]
6520 impl ::std::fmt::Debug for CERT_REVOCATION_CRL_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6521     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6522         fmt.debug_struct("CERT_REVOCATION_CRL_INFO").field("cbSize", &self.cbSize).field("pBaseCrlContext", &self.pBaseCrlContext).field("pDeltaCrlContext", &self.pDeltaCrlContext).field("pCrlEntry", &self.pCrlEntry).field("fDeltaCrlEntry", &self.fDeltaCrlEntry).finish()
6523     }
6524 }
6525 #[cfg(feature = "Win32_Foundation")]
6526 impl ::std::cmp::PartialEq for CERT_REVOCATION_CRL_INFO {
eq(&self, other: &Self) -> bool6527     fn eq(&self, other: &Self) -> bool {
6528         self.cbSize == other.cbSize && self.pBaseCrlContext == other.pBaseCrlContext && self.pDeltaCrlContext == other.pDeltaCrlContext && self.pCrlEntry == other.pCrlEntry && self.fDeltaCrlEntry == other.fDeltaCrlEntry
6529     }
6530 }
6531 #[cfg(feature = "Win32_Foundation")]
6532 impl ::std::cmp::Eq for CERT_REVOCATION_CRL_INFO {}
6533 #[cfg(feature = "Win32_Foundation")]
6534 unsafe impl ::windows::runtime::Abi for CERT_REVOCATION_CRL_INFO {
6535     type Abi = Self;
6536     type DefaultType = Self;
6537 }
6538 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6539 #[repr(C)]
6540 #[cfg(feature = "Win32_Foundation")]
6541 pub struct CERT_REVOCATION_INFO {
6542     pub cbSize: u32,
6543     pub dwRevocationResult: u32,
6544     pub pszRevocationOid: super::super::Foundation::PSTR,
6545     pub pvOidSpecificInfo: *mut ::std::ffi::c_void,
6546     pub fHasFreshnessTime: super::super::Foundation::BOOL,
6547     pub dwFreshnessTime: u32,
6548     pub pCrlInfo: *mut CERT_REVOCATION_CRL_INFO,
6549 }
6550 #[cfg(feature = "Win32_Foundation")]
6551 impl CERT_REVOCATION_INFO {}
6552 #[cfg(feature = "Win32_Foundation")]
6553 impl ::std::default::Default for CERT_REVOCATION_INFO {
default() -> Self6554     fn default() -> Self {
6555         unsafe { ::std::mem::zeroed() }
6556     }
6557 }
6558 #[cfg(feature = "Win32_Foundation")]
6559 impl ::std::fmt::Debug for CERT_REVOCATION_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6560     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6561         fmt.debug_struct("CERT_REVOCATION_INFO")
6562             .field("cbSize", &self.cbSize)
6563             .field("dwRevocationResult", &self.dwRevocationResult)
6564             .field("pszRevocationOid", &self.pszRevocationOid)
6565             .field("pvOidSpecificInfo", &self.pvOidSpecificInfo)
6566             .field("fHasFreshnessTime", &self.fHasFreshnessTime)
6567             .field("dwFreshnessTime", &self.dwFreshnessTime)
6568             .field("pCrlInfo", &self.pCrlInfo)
6569             .finish()
6570     }
6571 }
6572 #[cfg(feature = "Win32_Foundation")]
6573 impl ::std::cmp::PartialEq for CERT_REVOCATION_INFO {
eq(&self, other: &Self) -> bool6574     fn eq(&self, other: &Self) -> bool {
6575         self.cbSize == other.cbSize && self.dwRevocationResult == other.dwRevocationResult && self.pszRevocationOid == other.pszRevocationOid && self.pvOidSpecificInfo == other.pvOidSpecificInfo && self.fHasFreshnessTime == other.fHasFreshnessTime && self.dwFreshnessTime == other.dwFreshnessTime && self.pCrlInfo == other.pCrlInfo
6576     }
6577 }
6578 #[cfg(feature = "Win32_Foundation")]
6579 impl ::std::cmp::Eq for CERT_REVOCATION_INFO {}
6580 #[cfg(feature = "Win32_Foundation")]
6581 unsafe impl ::windows::runtime::Abi for CERT_REVOCATION_INFO {
6582     type Abi = Self;
6583     type DefaultType = Self;
6584 }
6585 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6586 #[repr(C)]
6587 #[cfg(feature = "Win32_Foundation")]
6588 pub struct CERT_REVOCATION_PARA {
6589     pub cbSize: u32,
6590     pub pIssuerCert: *mut CERT_CONTEXT,
6591     pub cCertStore: u32,
6592     pub rgCertStore: *mut *mut ::std::ffi::c_void,
6593     pub hCrlStore: *mut ::std::ffi::c_void,
6594     pub pftTimeToUse: *mut super::super::Foundation::FILETIME,
6595 }
6596 #[cfg(feature = "Win32_Foundation")]
6597 impl CERT_REVOCATION_PARA {}
6598 #[cfg(feature = "Win32_Foundation")]
6599 impl ::std::default::Default for CERT_REVOCATION_PARA {
default() -> Self6600     fn default() -> Self {
6601         unsafe { ::std::mem::zeroed() }
6602     }
6603 }
6604 #[cfg(feature = "Win32_Foundation")]
6605 impl ::std::fmt::Debug for CERT_REVOCATION_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6606     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6607         fmt.debug_struct("CERT_REVOCATION_PARA").field("cbSize", &self.cbSize).field("pIssuerCert", &self.pIssuerCert).field("cCertStore", &self.cCertStore).field("rgCertStore", &self.rgCertStore).field("hCrlStore", &self.hCrlStore).field("pftTimeToUse", &self.pftTimeToUse).finish()
6608     }
6609 }
6610 #[cfg(feature = "Win32_Foundation")]
6611 impl ::std::cmp::PartialEq for CERT_REVOCATION_PARA {
eq(&self, other: &Self) -> bool6612     fn eq(&self, other: &Self) -> bool {
6613         self.cbSize == other.cbSize && self.pIssuerCert == other.pIssuerCert && self.cCertStore == other.cCertStore && self.rgCertStore == other.rgCertStore && self.hCrlStore == other.hCrlStore && self.pftTimeToUse == other.pftTimeToUse
6614     }
6615 }
6616 #[cfg(feature = "Win32_Foundation")]
6617 impl ::std::cmp::Eq for CERT_REVOCATION_PARA {}
6618 #[cfg(feature = "Win32_Foundation")]
6619 unsafe impl ::windows::runtime::Abi for CERT_REVOCATION_PARA {
6620     type Abi = Self;
6621     type DefaultType = Self;
6622 }
6623 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6624 #[repr(C)]
6625 #[cfg(feature = "Win32_Foundation")]
6626 pub struct CERT_REVOCATION_STATUS {
6627     pub cbSize: u32,
6628     pub dwIndex: u32,
6629     pub dwError: u32,
6630     pub dwReason: CERT_REVOCATION_STATUS_REASON,
6631     pub fHasFreshnessTime: super::super::Foundation::BOOL,
6632     pub dwFreshnessTime: u32,
6633 }
6634 #[cfg(feature = "Win32_Foundation")]
6635 impl CERT_REVOCATION_STATUS {}
6636 #[cfg(feature = "Win32_Foundation")]
6637 impl ::std::default::Default for CERT_REVOCATION_STATUS {
default() -> Self6638     fn default() -> Self {
6639         unsafe { ::std::mem::zeroed() }
6640     }
6641 }
6642 #[cfg(feature = "Win32_Foundation")]
6643 impl ::std::fmt::Debug for CERT_REVOCATION_STATUS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6644     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6645         fmt.debug_struct("CERT_REVOCATION_STATUS").field("cbSize", &self.cbSize).field("dwIndex", &self.dwIndex).field("dwError", &self.dwError).field("dwReason", &self.dwReason).field("fHasFreshnessTime", &self.fHasFreshnessTime).field("dwFreshnessTime", &self.dwFreshnessTime).finish()
6646     }
6647 }
6648 #[cfg(feature = "Win32_Foundation")]
6649 impl ::std::cmp::PartialEq for CERT_REVOCATION_STATUS {
eq(&self, other: &Self) -> bool6650     fn eq(&self, other: &Self) -> bool {
6651         self.cbSize == other.cbSize && self.dwIndex == other.dwIndex && self.dwError == other.dwError && self.dwReason == other.dwReason && self.fHasFreshnessTime == other.fHasFreshnessTime && self.dwFreshnessTime == other.dwFreshnessTime
6652     }
6653 }
6654 #[cfg(feature = "Win32_Foundation")]
6655 impl ::std::cmp::Eq for CERT_REVOCATION_STATUS {}
6656 #[cfg(feature = "Win32_Foundation")]
6657 unsafe impl ::windows::runtime::Abi for CERT_REVOCATION_STATUS {
6658     type Abi = Self;
6659     type DefaultType = Self;
6660 }
6661 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6662 #[repr(transparent)]
6663 pub struct CERT_REVOCATION_STATUS_REASON(pub u32);
6664 pub const CRL_REASON_UNSPECIFIED: CERT_REVOCATION_STATUS_REASON = CERT_REVOCATION_STATUS_REASON(0u32);
6665 pub const CRL_REASON_KEY_COMPROMISE: CERT_REVOCATION_STATUS_REASON = CERT_REVOCATION_STATUS_REASON(1u32);
6666 pub const CRL_REASON_CA_COMPROMISE: CERT_REVOCATION_STATUS_REASON = CERT_REVOCATION_STATUS_REASON(2u32);
6667 pub const CRL_REASON_AFFILIATION_CHANGED: CERT_REVOCATION_STATUS_REASON = CERT_REVOCATION_STATUS_REASON(3u32);
6668 pub const CRL_REASON_SUPERSEDED: CERT_REVOCATION_STATUS_REASON = CERT_REVOCATION_STATUS_REASON(4u32);
6669 pub const CRL_REASON_CESSATION_OF_OPERATION: CERT_REVOCATION_STATUS_REASON = CERT_REVOCATION_STATUS_REASON(5u32);
6670 pub const CRL_REASON_CERTIFICATE_HOLD: CERT_REVOCATION_STATUS_REASON = CERT_REVOCATION_STATUS_REASON(6u32);
6671 pub const CRL_REASON_REMOVE_FROM_CRL: CERT_REVOCATION_STATUS_REASON = CERT_REVOCATION_STATUS_REASON(8u32);
6672 impl ::std::convert::From<u32> for CERT_REVOCATION_STATUS_REASON {
from(value: u32) -> Self6673     fn from(value: u32) -> Self {
6674         Self(value)
6675     }
6676 }
6677 unsafe impl ::windows::runtime::Abi for CERT_REVOCATION_STATUS_REASON {
6678     type Abi = Self;
6679     type DefaultType = Self;
6680 }
6681 impl ::std::ops::BitOr for CERT_REVOCATION_STATUS_REASON {
6682     type Output = Self;
bitor(self, rhs: Self) -> Self6683     fn bitor(self, rhs: Self) -> Self {
6684         Self(self.0 | rhs.0)
6685     }
6686 }
6687 impl ::std::ops::BitAnd for CERT_REVOCATION_STATUS_REASON {
6688     type Output = Self;
bitand(self, rhs: Self) -> Self6689     fn bitand(self, rhs: Self) -> Self {
6690         Self(self.0 & rhs.0)
6691     }
6692 }
6693 impl ::std::ops::BitOrAssign for CERT_REVOCATION_STATUS_REASON {
bitor_assign(&mut self, rhs: Self)6694     fn bitor_assign(&mut self, rhs: Self) {
6695         self.0.bitor_assign(rhs.0)
6696     }
6697 }
6698 impl ::std::ops::BitAndAssign for CERT_REVOCATION_STATUS_REASON {
bitand_assign(&mut self, rhs: Self)6699     fn bitand_assign(&mut self, rhs: Self) {
6700         self.0.bitand_assign(rhs.0)
6701     }
6702 }
6703 impl ::std::ops::Not for CERT_REVOCATION_STATUS_REASON {
6704     type Output = Self;
not(self) -> Self6705     fn not(self) -> Self {
6706         Self(self.0.not())
6707     }
6708 }
6709 pub const CERT_ROOT_PROGRAM_CERT_POLICIES_PROP_ID: u32 = 83u32;
6710 pub const CERT_ROOT_PROGRAM_CHAIN_POLICIES_PROP_ID: u32 = 105u32;
6711 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6712 #[repr(transparent)]
6713 pub struct CERT_ROOT_PROGRAM_FLAGS(pub u32);
6714 pub const CERT_ROOT_PROGRAM_FLAG_LSC: CERT_ROOT_PROGRAM_FLAGS = CERT_ROOT_PROGRAM_FLAGS(64u32);
6715 pub const CERT_ROOT_PROGRAM_FLAG_ORG: CERT_ROOT_PROGRAM_FLAGS = CERT_ROOT_PROGRAM_FLAGS(128u32);
6716 pub const CERT_ROOT_PROGRAM_FLAG_SUBJECT_LOGO: CERT_ROOT_PROGRAM_FLAGS = CERT_ROOT_PROGRAM_FLAGS(32u32);
6717 impl ::std::convert::From<u32> for CERT_ROOT_PROGRAM_FLAGS {
from(value: u32) -> Self6718     fn from(value: u32) -> Self {
6719         Self(value)
6720     }
6721 }
6722 unsafe impl ::windows::runtime::Abi for CERT_ROOT_PROGRAM_FLAGS {
6723     type Abi = Self;
6724     type DefaultType = Self;
6725 }
6726 impl ::std::ops::BitOr for CERT_ROOT_PROGRAM_FLAGS {
6727     type Output = Self;
bitor(self, rhs: Self) -> Self6728     fn bitor(self, rhs: Self) -> Self {
6729         Self(self.0 | rhs.0)
6730     }
6731 }
6732 impl ::std::ops::BitAnd for CERT_ROOT_PROGRAM_FLAGS {
6733     type Output = Self;
bitand(self, rhs: Self) -> Self6734     fn bitand(self, rhs: Self) -> Self {
6735         Self(self.0 & rhs.0)
6736     }
6737 }
6738 impl ::std::ops::BitOrAssign for CERT_ROOT_PROGRAM_FLAGS {
bitor_assign(&mut self, rhs: Self)6739     fn bitor_assign(&mut self, rhs: Self) {
6740         self.0.bitor_assign(rhs.0)
6741     }
6742 }
6743 impl ::std::ops::BitAndAssign for CERT_ROOT_PROGRAM_FLAGS {
bitand_assign(&mut self, rhs: Self)6744     fn bitand_assign(&mut self, rhs: Self) {
6745         self.0.bitand_assign(rhs.0)
6746     }
6747 }
6748 impl ::std::ops::Not for CERT_ROOT_PROGRAM_FLAGS {
6749     type Output = Self;
not(self) -> Self6750     fn not(self) -> Self {
6751         Self(self.0.not())
6752     }
6753 }
6754 pub const CERT_ROOT_PROGRAM_FLAG_ADDRESS: u32 = 8u32;
6755 pub const CERT_ROOT_PROGRAM_FLAG_OU: u32 = 16u32;
6756 pub const CERT_ROOT_PROGRAM_NAME_CONSTRAINTS_PROP_ID: u32 = 84u32;
6757 pub const CERT_SCARD_PIN_ID_PROP_ID: u32 = 90u32;
6758 pub const CERT_SCARD_PIN_INFO_PROP_ID: u32 = 91u32;
6759 pub const CERT_SCEP_CA_CERT_PROP_ID: u32 = 111u32;
6760 pub const CERT_SCEP_ENCRYPT_HASH_CNG_ALG_PROP_ID: u32 = 114u32;
6761 pub const CERT_SCEP_FLAGS_PROP_ID: u32 = 115u32;
6762 pub const CERT_SCEP_GUID_PROP_ID: u32 = 116u32;
6763 pub const CERT_SCEP_NONCE_PROP_ID: u32 = 113u32;
6764 pub const CERT_SCEP_RA_ENCRYPTION_CERT_PROP_ID: u32 = 110u32;
6765 pub const CERT_SCEP_RA_SIGNATURE_CERT_PROP_ID: u32 = 109u32;
6766 pub const CERT_SCEP_SERVER_CERTS_PROP_ID: u32 = 108u32;
6767 pub const CERT_SCEP_SIGNER_CERT_PROP_ID: u32 = 112u32;
6768 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6769 #[repr(C)]
6770 #[cfg(feature = "Win32_Foundation")]
6771 pub struct CERT_SELECTUI_INPUT {
6772     pub hStore: *mut ::std::ffi::c_void,
6773     pub prgpChain: *mut *mut CERT_CHAIN_CONTEXT,
6774     pub cChain: u32,
6775 }
6776 #[cfg(feature = "Win32_Foundation")]
6777 impl CERT_SELECTUI_INPUT {}
6778 #[cfg(feature = "Win32_Foundation")]
6779 impl ::std::default::Default for CERT_SELECTUI_INPUT {
default() -> Self6780     fn default() -> Self {
6781         unsafe { ::std::mem::zeroed() }
6782     }
6783 }
6784 #[cfg(feature = "Win32_Foundation")]
6785 impl ::std::fmt::Debug for CERT_SELECTUI_INPUT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6786     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6787         fmt.debug_struct("CERT_SELECTUI_INPUT").field("hStore", &self.hStore).field("prgpChain", &self.prgpChain).field("cChain", &self.cChain).finish()
6788     }
6789 }
6790 #[cfg(feature = "Win32_Foundation")]
6791 impl ::std::cmp::PartialEq for CERT_SELECTUI_INPUT {
eq(&self, other: &Self) -> bool6792     fn eq(&self, other: &Self) -> bool {
6793         self.hStore == other.hStore && self.prgpChain == other.prgpChain && self.cChain == other.cChain
6794     }
6795 }
6796 #[cfg(feature = "Win32_Foundation")]
6797 impl ::std::cmp::Eq for CERT_SELECTUI_INPUT {}
6798 #[cfg(feature = "Win32_Foundation")]
6799 unsafe impl ::windows::runtime::Abi for CERT_SELECTUI_INPUT {
6800     type Abi = Self;
6801     type DefaultType = Self;
6802 }
6803 pub const CERT_SELECT_ALLOW_DUPLICATES: u32 = 128u32;
6804 pub const CERT_SELECT_ALLOW_EXPIRED: u32 = 1u32;
6805 pub const CERT_SELECT_BY_FRIENDLYNAME: u32 = 13u32;
6806 pub const CERT_SELECT_BY_ISSUER_DISPLAYNAME: u32 = 12u32;
6807 pub const CERT_SELECT_BY_THUMBPRINT: u32 = 14u32;
6808 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6809 #[repr(C)]
6810 #[cfg(feature = "Win32_Foundation")]
6811 pub struct CERT_SELECT_CHAIN_PARA {
6812     pub hChainEngine: HCERTCHAINENGINE,
6813     pub pTime: *mut super::super::Foundation::FILETIME,
6814     pub hAdditionalStore: *mut ::std::ffi::c_void,
6815     pub pChainPara: *mut CERT_CHAIN_PARA,
6816     pub dwFlags: u32,
6817 }
6818 #[cfg(feature = "Win32_Foundation")]
6819 impl CERT_SELECT_CHAIN_PARA {}
6820 #[cfg(feature = "Win32_Foundation")]
6821 impl ::std::default::Default for CERT_SELECT_CHAIN_PARA {
default() -> Self6822     fn default() -> Self {
6823         unsafe { ::std::mem::zeroed() }
6824     }
6825 }
6826 #[cfg(feature = "Win32_Foundation")]
6827 impl ::std::fmt::Debug for CERT_SELECT_CHAIN_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6828     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6829         fmt.debug_struct("CERT_SELECT_CHAIN_PARA").field("hChainEngine", &self.hChainEngine).field("pTime", &self.pTime).field("hAdditionalStore", &self.hAdditionalStore).field("pChainPara", &self.pChainPara).field("dwFlags", &self.dwFlags).finish()
6830     }
6831 }
6832 #[cfg(feature = "Win32_Foundation")]
6833 impl ::std::cmp::PartialEq for CERT_SELECT_CHAIN_PARA {
eq(&self, other: &Self) -> bool6834     fn eq(&self, other: &Self) -> bool {
6835         self.hChainEngine == other.hChainEngine && self.pTime == other.pTime && self.hAdditionalStore == other.hAdditionalStore && self.pChainPara == other.pChainPara && self.dwFlags == other.dwFlags
6836     }
6837 }
6838 #[cfg(feature = "Win32_Foundation")]
6839 impl ::std::cmp::Eq for CERT_SELECT_CHAIN_PARA {}
6840 #[cfg(feature = "Win32_Foundation")]
6841 unsafe impl ::windows::runtime::Abi for CERT_SELECT_CHAIN_PARA {
6842     type Abi = Self;
6843     type DefaultType = Self;
6844 }
6845 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6846 #[repr(C)]
6847 pub struct CERT_SELECT_CRITERIA {
6848     pub dwType: CERT_SELECT_CRITERIA_TYPE,
6849     pub cPara: u32,
6850     pub ppPara: *mut *mut ::std::ffi::c_void,
6851 }
6852 impl CERT_SELECT_CRITERIA {}
6853 impl ::std::default::Default for CERT_SELECT_CRITERIA {
default() -> Self6854     fn default() -> Self {
6855         unsafe { ::std::mem::zeroed() }
6856     }
6857 }
6858 impl ::std::fmt::Debug for CERT_SELECT_CRITERIA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6859     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6860         fmt.debug_struct("CERT_SELECT_CRITERIA").field("dwType", &self.dwType).field("cPara", &self.cPara).field("ppPara", &self.ppPara).finish()
6861     }
6862 }
6863 impl ::std::cmp::PartialEq for CERT_SELECT_CRITERIA {
eq(&self, other: &Self) -> bool6864     fn eq(&self, other: &Self) -> bool {
6865         self.dwType == other.dwType && self.cPara == other.cPara && self.ppPara == other.ppPara
6866     }
6867 }
6868 impl ::std::cmp::Eq for CERT_SELECT_CRITERIA {}
6869 unsafe impl ::windows::runtime::Abi for CERT_SELECT_CRITERIA {
6870     type Abi = Self;
6871     type DefaultType = Self;
6872 }
6873 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6874 #[repr(transparent)]
6875 pub struct CERT_SELECT_CRITERIA_TYPE(pub u32);
6876 pub const CERT_SELECT_BY_ENHKEY_USAGE: CERT_SELECT_CRITERIA_TYPE = CERT_SELECT_CRITERIA_TYPE(1u32);
6877 pub const CERT_SELECT_BY_KEY_USAGE: CERT_SELECT_CRITERIA_TYPE = CERT_SELECT_CRITERIA_TYPE(2u32);
6878 pub const CERT_SELECT_BY_POLICY_OID: CERT_SELECT_CRITERIA_TYPE = CERT_SELECT_CRITERIA_TYPE(3u32);
6879 pub const CERT_SELECT_BY_PROV_NAME: CERT_SELECT_CRITERIA_TYPE = CERT_SELECT_CRITERIA_TYPE(4u32);
6880 pub const CERT_SELECT_BY_EXTENSION: CERT_SELECT_CRITERIA_TYPE = CERT_SELECT_CRITERIA_TYPE(5u32);
6881 pub const CERT_SELECT_BY_SUBJECT_HOST_NAME: CERT_SELECT_CRITERIA_TYPE = CERT_SELECT_CRITERIA_TYPE(6u32);
6882 pub const CERT_SELECT_BY_ISSUER_ATTR: CERT_SELECT_CRITERIA_TYPE = CERT_SELECT_CRITERIA_TYPE(7u32);
6883 pub const CERT_SELECT_BY_SUBJECT_ATTR: CERT_SELECT_CRITERIA_TYPE = CERT_SELECT_CRITERIA_TYPE(8u32);
6884 pub const CERT_SELECT_BY_ISSUER_NAME: CERT_SELECT_CRITERIA_TYPE = CERT_SELECT_CRITERIA_TYPE(9u32);
6885 pub const CERT_SELECT_BY_PUBLIC_KEY: CERT_SELECT_CRITERIA_TYPE = CERT_SELECT_CRITERIA_TYPE(10u32);
6886 pub const CERT_SELECT_BY_TLS_SIGNATURES: CERT_SELECT_CRITERIA_TYPE = CERT_SELECT_CRITERIA_TYPE(11u32);
6887 impl ::std::convert::From<u32> for CERT_SELECT_CRITERIA_TYPE {
from(value: u32) -> Self6888     fn from(value: u32) -> Self {
6889         Self(value)
6890     }
6891 }
6892 unsafe impl ::windows::runtime::Abi for CERT_SELECT_CRITERIA_TYPE {
6893     type Abi = Self;
6894     type DefaultType = Self;
6895 }
6896 impl ::std::ops::BitOr for CERT_SELECT_CRITERIA_TYPE {
6897     type Output = Self;
bitor(self, rhs: Self) -> Self6898     fn bitor(self, rhs: Self) -> Self {
6899         Self(self.0 | rhs.0)
6900     }
6901 }
6902 impl ::std::ops::BitAnd for CERT_SELECT_CRITERIA_TYPE {
6903     type Output = Self;
bitand(self, rhs: Self) -> Self6904     fn bitand(self, rhs: Self) -> Self {
6905         Self(self.0 & rhs.0)
6906     }
6907 }
6908 impl ::std::ops::BitOrAssign for CERT_SELECT_CRITERIA_TYPE {
bitor_assign(&mut self, rhs: Self)6909     fn bitor_assign(&mut self, rhs: Self) {
6910         self.0.bitor_assign(rhs.0)
6911     }
6912 }
6913 impl ::std::ops::BitAndAssign for CERT_SELECT_CRITERIA_TYPE {
bitand_assign(&mut self, rhs: Self)6914     fn bitand_assign(&mut self, rhs: Self) {
6915         self.0.bitand_assign(rhs.0)
6916     }
6917 }
6918 impl ::std::ops::Not for CERT_SELECT_CRITERIA_TYPE {
6919     type Output = Self;
not(self) -> Self6920     fn not(self) -> Self {
6921         Self(self.0.not())
6922     }
6923 }
6924 pub const CERT_SELECT_DISALLOW_SELFSIGNED: u32 = 4u32;
6925 pub const CERT_SELECT_HARDWARE_ONLY: u32 = 64u32;
6926 pub const CERT_SELECT_HAS_KEY_FOR_KEY_EXCHANGE: u32 = 32u32;
6927 pub const CERT_SELECT_HAS_KEY_FOR_SIGNATURE: u32 = 16u32;
6928 pub const CERT_SELECT_HAS_PRIVATE_KEY: u32 = 8u32;
6929 pub const CERT_SELECT_IGNORE_AUTOSELECT: u32 = 256u32;
6930 pub const CERT_SELECT_MAX_PARA: u32 = 500u32;
6931 #[derive(:: std :: clone :: Clone)]
6932 #[repr(C)]
6933 #[cfg(feature = "Win32_Foundation")]
6934 pub struct CERT_SELECT_STRUCT_A {
6935     pub dwSize: u32,
6936     pub hwndParent: super::super::Foundation::HWND,
6937     pub hInstance: super::super::Foundation::HINSTANCE,
6938     pub pTemplateName: super::super::Foundation::PSTR,
6939     pub dwFlags: CERT_SELECT_STRUCT_FLAGS,
6940     pub szTitle: super::super::Foundation::PSTR,
6941     pub cCertStore: u32,
6942     pub arrayCertStore: *mut *mut ::std::ffi::c_void,
6943     pub szPurposeOid: super::super::Foundation::PSTR,
6944     pub cCertContext: u32,
6945     pub arrayCertContext: *mut *mut CERT_CONTEXT,
6946     pub lCustData: super::super::Foundation::LPARAM,
6947     pub pfnHook: ::std::option::Option<PFNCMHOOKPROC>,
6948     pub pfnFilter: ::std::option::Option<PFNCMFILTERPROC>,
6949     pub szHelpFileName: super::super::Foundation::PSTR,
6950     pub dwHelpId: u32,
6951     pub hprov: usize,
6952 }
6953 #[cfg(feature = "Win32_Foundation")]
6954 impl CERT_SELECT_STRUCT_A {}
6955 #[cfg(feature = "Win32_Foundation")]
6956 impl ::std::default::Default for CERT_SELECT_STRUCT_A {
default() -> Self6957     fn default() -> Self {
6958         unsafe { ::std::mem::zeroed() }
6959     }
6960 }
6961 #[cfg(feature = "Win32_Foundation")]
6962 impl ::std::fmt::Debug for CERT_SELECT_STRUCT_A {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6963     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6964         fmt.debug_struct("CERT_SELECT_STRUCT_A")
6965             .field("dwSize", &self.dwSize)
6966             .field("hwndParent", &self.hwndParent)
6967             .field("hInstance", &self.hInstance)
6968             .field("pTemplateName", &self.pTemplateName)
6969             .field("dwFlags", &self.dwFlags)
6970             .field("szTitle", &self.szTitle)
6971             .field("cCertStore", &self.cCertStore)
6972             .field("arrayCertStore", &self.arrayCertStore)
6973             .field("szPurposeOid", &self.szPurposeOid)
6974             .field("cCertContext", &self.cCertContext)
6975             .field("arrayCertContext", &self.arrayCertContext)
6976             .field("lCustData", &self.lCustData)
6977             .field("szHelpFileName", &self.szHelpFileName)
6978             .field("dwHelpId", &self.dwHelpId)
6979             .field("hprov", &self.hprov)
6980             .finish()
6981     }
6982 }
6983 #[cfg(feature = "Win32_Foundation")]
6984 impl ::std::cmp::PartialEq for CERT_SELECT_STRUCT_A {
eq(&self, other: &Self) -> bool6985     fn eq(&self, other: &Self) -> bool {
6986         self.dwSize == other.dwSize
6987             && self.hwndParent == other.hwndParent
6988             && self.hInstance == other.hInstance
6989             && self.pTemplateName == other.pTemplateName
6990             && self.dwFlags == other.dwFlags
6991             && self.szTitle == other.szTitle
6992             && self.cCertStore == other.cCertStore
6993             && self.arrayCertStore == other.arrayCertStore
6994             && self.szPurposeOid == other.szPurposeOid
6995             && self.cCertContext == other.cCertContext
6996             && self.arrayCertContext == other.arrayCertContext
6997             && self.lCustData == other.lCustData
6998             && self.pfnHook.map(|f| f as usize) == other.pfnHook.map(|f| f as usize)
6999             && self.pfnFilter.map(|f| f as usize) == other.pfnFilter.map(|f| f as usize)
7000             && self.szHelpFileName == other.szHelpFileName
7001             && self.dwHelpId == other.dwHelpId
7002             && self.hprov == other.hprov
7003     }
7004 }
7005 #[cfg(feature = "Win32_Foundation")]
7006 impl ::std::cmp::Eq for CERT_SELECT_STRUCT_A {}
7007 #[cfg(feature = "Win32_Foundation")]
7008 unsafe impl ::windows::runtime::Abi for CERT_SELECT_STRUCT_A {
7009     type Abi = ::std::mem::ManuallyDrop<Self>;
7010     type DefaultType = Self;
7011 }
7012 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7013 #[repr(transparent)]
7014 pub struct CERT_SELECT_STRUCT_FLAGS(pub u32);
7015 pub const CSS_HIDE_PROPERTIES: CERT_SELECT_STRUCT_FLAGS = CERT_SELECT_STRUCT_FLAGS(1u32);
7016 pub const CSS_ENABLEHOOK: CERT_SELECT_STRUCT_FLAGS = CERT_SELECT_STRUCT_FLAGS(2u32);
7017 pub const CSS_ALLOWMULTISELECT: CERT_SELECT_STRUCT_FLAGS = CERT_SELECT_STRUCT_FLAGS(4u32);
7018 pub const CSS_SHOW_HELP: CERT_SELECT_STRUCT_FLAGS = CERT_SELECT_STRUCT_FLAGS(16u32);
7019 pub const CSS_ENABLETEMPLATE: CERT_SELECT_STRUCT_FLAGS = CERT_SELECT_STRUCT_FLAGS(32u32);
7020 pub const CSS_ENABLETEMPLATEHANDLE: CERT_SELECT_STRUCT_FLAGS = CERT_SELECT_STRUCT_FLAGS(64u32);
7021 impl ::std::convert::From<u32> for CERT_SELECT_STRUCT_FLAGS {
from(value: u32) -> Self7022     fn from(value: u32) -> Self {
7023         Self(value)
7024     }
7025 }
7026 unsafe impl ::windows::runtime::Abi for CERT_SELECT_STRUCT_FLAGS {
7027     type Abi = Self;
7028     type DefaultType = Self;
7029 }
7030 impl ::std::ops::BitOr for CERT_SELECT_STRUCT_FLAGS {
7031     type Output = Self;
bitor(self, rhs: Self) -> Self7032     fn bitor(self, rhs: Self) -> Self {
7033         Self(self.0 | rhs.0)
7034     }
7035 }
7036 impl ::std::ops::BitAnd for CERT_SELECT_STRUCT_FLAGS {
7037     type Output = Self;
bitand(self, rhs: Self) -> Self7038     fn bitand(self, rhs: Self) -> Self {
7039         Self(self.0 & rhs.0)
7040     }
7041 }
7042 impl ::std::ops::BitOrAssign for CERT_SELECT_STRUCT_FLAGS {
bitor_assign(&mut self, rhs: Self)7043     fn bitor_assign(&mut self, rhs: Self) {
7044         self.0.bitor_assign(rhs.0)
7045     }
7046 }
7047 impl ::std::ops::BitAndAssign for CERT_SELECT_STRUCT_FLAGS {
bitand_assign(&mut self, rhs: Self)7048     fn bitand_assign(&mut self, rhs: Self) {
7049         self.0.bitand_assign(rhs.0)
7050     }
7051 }
7052 impl ::std::ops::Not for CERT_SELECT_STRUCT_FLAGS {
7053     type Output = Self;
not(self) -> Self7054     fn not(self) -> Self {
7055         Self(self.0.not())
7056     }
7057 }
7058 #[derive(:: std :: clone :: Clone)]
7059 #[repr(C)]
7060 #[cfg(feature = "Win32_Foundation")]
7061 pub struct CERT_SELECT_STRUCT_W {
7062     pub dwSize: u32,
7063     pub hwndParent: super::super::Foundation::HWND,
7064     pub hInstance: super::super::Foundation::HINSTANCE,
7065     pub pTemplateName: super::super::Foundation::PWSTR,
7066     pub dwFlags: CERT_SELECT_STRUCT_FLAGS,
7067     pub szTitle: super::super::Foundation::PWSTR,
7068     pub cCertStore: u32,
7069     pub arrayCertStore: *mut *mut ::std::ffi::c_void,
7070     pub szPurposeOid: super::super::Foundation::PSTR,
7071     pub cCertContext: u32,
7072     pub arrayCertContext: *mut *mut CERT_CONTEXT,
7073     pub lCustData: super::super::Foundation::LPARAM,
7074     pub pfnHook: ::std::option::Option<PFNCMHOOKPROC>,
7075     pub pfnFilter: ::std::option::Option<PFNCMFILTERPROC>,
7076     pub szHelpFileName: super::super::Foundation::PWSTR,
7077     pub dwHelpId: u32,
7078     pub hprov: usize,
7079 }
7080 #[cfg(feature = "Win32_Foundation")]
7081 impl CERT_SELECT_STRUCT_W {}
7082 #[cfg(feature = "Win32_Foundation")]
7083 impl ::std::default::Default for CERT_SELECT_STRUCT_W {
default() -> Self7084     fn default() -> Self {
7085         unsafe { ::std::mem::zeroed() }
7086     }
7087 }
7088 #[cfg(feature = "Win32_Foundation")]
7089 impl ::std::fmt::Debug for CERT_SELECT_STRUCT_W {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7090     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7091         fmt.debug_struct("CERT_SELECT_STRUCT_W")
7092             .field("dwSize", &self.dwSize)
7093             .field("hwndParent", &self.hwndParent)
7094             .field("hInstance", &self.hInstance)
7095             .field("pTemplateName", &self.pTemplateName)
7096             .field("dwFlags", &self.dwFlags)
7097             .field("szTitle", &self.szTitle)
7098             .field("cCertStore", &self.cCertStore)
7099             .field("arrayCertStore", &self.arrayCertStore)
7100             .field("szPurposeOid", &self.szPurposeOid)
7101             .field("cCertContext", &self.cCertContext)
7102             .field("arrayCertContext", &self.arrayCertContext)
7103             .field("lCustData", &self.lCustData)
7104             .field("szHelpFileName", &self.szHelpFileName)
7105             .field("dwHelpId", &self.dwHelpId)
7106             .field("hprov", &self.hprov)
7107             .finish()
7108     }
7109 }
7110 #[cfg(feature = "Win32_Foundation")]
7111 impl ::std::cmp::PartialEq for CERT_SELECT_STRUCT_W {
eq(&self, other: &Self) -> bool7112     fn eq(&self, other: &Self) -> bool {
7113         self.dwSize == other.dwSize
7114             && self.hwndParent == other.hwndParent
7115             && self.hInstance == other.hInstance
7116             && self.pTemplateName == other.pTemplateName
7117             && self.dwFlags == other.dwFlags
7118             && self.szTitle == other.szTitle
7119             && self.cCertStore == other.cCertStore
7120             && self.arrayCertStore == other.arrayCertStore
7121             && self.szPurposeOid == other.szPurposeOid
7122             && self.cCertContext == other.cCertContext
7123             && self.arrayCertContext == other.arrayCertContext
7124             && self.lCustData == other.lCustData
7125             && self.pfnHook.map(|f| f as usize) == other.pfnHook.map(|f| f as usize)
7126             && self.pfnFilter.map(|f| f as usize) == other.pfnFilter.map(|f| f as usize)
7127             && self.szHelpFileName == other.szHelpFileName
7128             && self.dwHelpId == other.dwHelpId
7129             && self.hprov == other.hprov
7130     }
7131 }
7132 #[cfg(feature = "Win32_Foundation")]
7133 impl ::std::cmp::Eq for CERT_SELECT_STRUCT_W {}
7134 #[cfg(feature = "Win32_Foundation")]
7135 unsafe impl ::windows::runtime::Abi for CERT_SELECT_STRUCT_W {
7136     type Abi = ::std::mem::ManuallyDrop<Self>;
7137     type DefaultType = Self;
7138 }
7139 pub const CERT_SELECT_TRUSTED_ROOT: u32 = 2u32;
7140 pub const CERT_SEND_AS_TRUSTED_ISSUER_PROP_ID: u32 = 102u32;
7141 pub const CERT_SERIALIZABLE_KEY_CONTEXT_PROP_ID: u32 = 117u32;
7142 pub const CERT_SERIAL_CHAIN_PROP_ID: u32 = 119u32;
7143 pub const CERT_SERVER_OCSP_RESPONSE_ASYNC_FLAG: u32 = 1u32;
7144 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7145 #[repr(C)]
7146 pub struct CERT_SERVER_OCSP_RESPONSE_CONTEXT {
7147     pub cbSize: u32,
7148     pub pbEncodedOcspResponse: *mut u8,
7149     pub cbEncodedOcspResponse: u32,
7150 }
7151 impl CERT_SERVER_OCSP_RESPONSE_CONTEXT {}
7152 impl ::std::default::Default for CERT_SERVER_OCSP_RESPONSE_CONTEXT {
default() -> Self7153     fn default() -> Self {
7154         unsafe { ::std::mem::zeroed() }
7155     }
7156 }
7157 impl ::std::fmt::Debug for CERT_SERVER_OCSP_RESPONSE_CONTEXT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7158     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7159         fmt.debug_struct("CERT_SERVER_OCSP_RESPONSE_CONTEXT").field("cbSize", &self.cbSize).field("pbEncodedOcspResponse", &self.pbEncodedOcspResponse).field("cbEncodedOcspResponse", &self.cbEncodedOcspResponse).finish()
7160     }
7161 }
7162 impl ::std::cmp::PartialEq for CERT_SERVER_OCSP_RESPONSE_CONTEXT {
eq(&self, other: &Self) -> bool7163     fn eq(&self, other: &Self) -> bool {
7164         self.cbSize == other.cbSize && self.pbEncodedOcspResponse == other.pbEncodedOcspResponse && self.cbEncodedOcspResponse == other.cbEncodedOcspResponse
7165     }
7166 }
7167 impl ::std::cmp::Eq for CERT_SERVER_OCSP_RESPONSE_CONTEXT {}
7168 unsafe impl ::windows::runtime::Abi for CERT_SERVER_OCSP_RESPONSE_CONTEXT {
7169     type Abi = Self;
7170     type DefaultType = Self;
7171 }
7172 #[derive(:: std :: clone :: Clone)]
7173 #[repr(C)]
7174 #[cfg(feature = "Win32_Foundation")]
7175 pub struct CERT_SERVER_OCSP_RESPONSE_OPEN_PARA {
7176     pub cbSize: u32,
7177     pub dwFlags: u32,
7178     pub pcbUsedSize: *mut u32,
7179     pub pwszOcspDirectory: super::super::Foundation::PWSTR,
7180     pub pfnUpdateCallback: ::std::option::Option<PFN_CERT_SERVER_OCSP_RESPONSE_UPDATE_CALLBACK>,
7181     pub pvUpdateCallbackArg: *mut ::std::ffi::c_void,
7182 }
7183 #[cfg(feature = "Win32_Foundation")]
7184 impl CERT_SERVER_OCSP_RESPONSE_OPEN_PARA {}
7185 #[cfg(feature = "Win32_Foundation")]
7186 impl ::std::default::Default for CERT_SERVER_OCSP_RESPONSE_OPEN_PARA {
default() -> Self7187     fn default() -> Self {
7188         unsafe { ::std::mem::zeroed() }
7189     }
7190 }
7191 #[cfg(feature = "Win32_Foundation")]
7192 impl ::std::fmt::Debug for CERT_SERVER_OCSP_RESPONSE_OPEN_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7193     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7194         fmt.debug_struct("CERT_SERVER_OCSP_RESPONSE_OPEN_PARA").field("cbSize", &self.cbSize).field("dwFlags", &self.dwFlags).field("pcbUsedSize", &self.pcbUsedSize).field("pwszOcspDirectory", &self.pwszOcspDirectory).field("pvUpdateCallbackArg", &self.pvUpdateCallbackArg).finish()
7195     }
7196 }
7197 #[cfg(feature = "Win32_Foundation")]
7198 impl ::std::cmp::PartialEq for CERT_SERVER_OCSP_RESPONSE_OPEN_PARA {
eq(&self, other: &Self) -> bool7199     fn eq(&self, other: &Self) -> bool {
7200         self.cbSize == other.cbSize && self.dwFlags == other.dwFlags && self.pcbUsedSize == other.pcbUsedSize && self.pwszOcspDirectory == other.pwszOcspDirectory && self.pfnUpdateCallback.map(|f| f as usize) == other.pfnUpdateCallback.map(|f| f as usize) && self.pvUpdateCallbackArg == other.pvUpdateCallbackArg
7201     }
7202 }
7203 #[cfg(feature = "Win32_Foundation")]
7204 impl ::std::cmp::Eq for CERT_SERVER_OCSP_RESPONSE_OPEN_PARA {}
7205 #[cfg(feature = "Win32_Foundation")]
7206 unsafe impl ::windows::runtime::Abi for CERT_SERVER_OCSP_RESPONSE_OPEN_PARA {
7207     type Abi = ::std::mem::ManuallyDrop<Self>;
7208     type DefaultType = Self;
7209 }
7210 pub const CERT_SERVER_OCSP_RESPONSE_OPEN_PARA_READ_FLAG: u32 = 1u32;
7211 pub const CERT_SERVER_OCSP_RESPONSE_OPEN_PARA_WRITE_FLAG: u32 = 2u32;
7212 pub const CERT_SET_PROPERTY_IGNORE_PERSIST_ERROR_FLAG: u32 = 2147483648u32;
7213 pub const CERT_SET_PROPERTY_INHIBIT_PERSIST_FLAG: u32 = 1073741824u32;
7214 pub const CERT_SHA1_HASH_PROP_ID: u32 = 3u32;
7215 pub const CERT_SHA256_HASH_PROP_ID: u32 = 107u32;
7216 pub const CERT_SIGNATURE_HASH_PROP_ID: u32 = 15u32;
7217 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7218 #[repr(C)]
7219 #[cfg(feature = "Win32_Foundation")]
7220 pub struct CERT_SIGNED_CONTENT_INFO {
7221     pub ToBeSigned: CRYPTOAPI_BLOB,
7222     pub SignatureAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
7223     pub Signature: CRYPT_BIT_BLOB,
7224 }
7225 #[cfg(feature = "Win32_Foundation")]
7226 impl CERT_SIGNED_CONTENT_INFO {}
7227 #[cfg(feature = "Win32_Foundation")]
7228 impl ::std::default::Default for CERT_SIGNED_CONTENT_INFO {
default() -> Self7229     fn default() -> Self {
7230         unsafe { ::std::mem::zeroed() }
7231     }
7232 }
7233 #[cfg(feature = "Win32_Foundation")]
7234 impl ::std::fmt::Debug for CERT_SIGNED_CONTENT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7235     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7236         fmt.debug_struct("CERT_SIGNED_CONTENT_INFO").field("ToBeSigned", &self.ToBeSigned).field("SignatureAlgorithm", &self.SignatureAlgorithm).field("Signature", &self.Signature).finish()
7237     }
7238 }
7239 #[cfg(feature = "Win32_Foundation")]
7240 impl ::std::cmp::PartialEq for CERT_SIGNED_CONTENT_INFO {
eq(&self, other: &Self) -> bool7241     fn eq(&self, other: &Self) -> bool {
7242         self.ToBeSigned == other.ToBeSigned && self.SignatureAlgorithm == other.SignatureAlgorithm && self.Signature == other.Signature
7243     }
7244 }
7245 #[cfg(feature = "Win32_Foundation")]
7246 impl ::std::cmp::Eq for CERT_SIGNED_CONTENT_INFO {}
7247 #[cfg(feature = "Win32_Foundation")]
7248 unsafe impl ::windows::runtime::Abi for CERT_SIGNED_CONTENT_INFO {
7249     type Abi = Self;
7250     type DefaultType = Self;
7251 }
7252 pub const CERT_SIGN_HASH_CNG_ALG_PROP_ID: u32 = 89u32;
7253 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7254 #[repr(C)]
7255 #[cfg(feature = "Win32_Foundation")]
7256 pub struct CERT_SIMPLE_CHAIN {
7257     pub cbSize: u32,
7258     pub TrustStatus: CERT_TRUST_STATUS,
7259     pub cElement: u32,
7260     pub rgpElement: *mut *mut CERT_CHAIN_ELEMENT,
7261     pub pTrustListInfo: *mut CERT_TRUST_LIST_INFO,
7262     pub fHasRevocationFreshnessTime: super::super::Foundation::BOOL,
7263     pub dwRevocationFreshnessTime: u32,
7264 }
7265 #[cfg(feature = "Win32_Foundation")]
7266 impl CERT_SIMPLE_CHAIN {}
7267 #[cfg(feature = "Win32_Foundation")]
7268 impl ::std::default::Default for CERT_SIMPLE_CHAIN {
default() -> Self7269     fn default() -> Self {
7270         unsafe { ::std::mem::zeroed() }
7271     }
7272 }
7273 #[cfg(feature = "Win32_Foundation")]
7274 impl ::std::fmt::Debug for CERT_SIMPLE_CHAIN {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7275     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7276         fmt.debug_struct("CERT_SIMPLE_CHAIN")
7277             .field("cbSize", &self.cbSize)
7278             .field("TrustStatus", &self.TrustStatus)
7279             .field("cElement", &self.cElement)
7280             .field("rgpElement", &self.rgpElement)
7281             .field("pTrustListInfo", &self.pTrustListInfo)
7282             .field("fHasRevocationFreshnessTime", &self.fHasRevocationFreshnessTime)
7283             .field("dwRevocationFreshnessTime", &self.dwRevocationFreshnessTime)
7284             .finish()
7285     }
7286 }
7287 #[cfg(feature = "Win32_Foundation")]
7288 impl ::std::cmp::PartialEq for CERT_SIMPLE_CHAIN {
eq(&self, other: &Self) -> bool7289     fn eq(&self, other: &Self) -> bool {
7290         self.cbSize == other.cbSize && self.TrustStatus == other.TrustStatus && self.cElement == other.cElement && self.rgpElement == other.rgpElement && self.pTrustListInfo == other.pTrustListInfo && self.fHasRevocationFreshnessTime == other.fHasRevocationFreshnessTime && self.dwRevocationFreshnessTime == other.dwRevocationFreshnessTime
7291     }
7292 }
7293 #[cfg(feature = "Win32_Foundation")]
7294 impl ::std::cmp::Eq for CERT_SIMPLE_CHAIN {}
7295 #[cfg(feature = "Win32_Foundation")]
7296 unsafe impl ::windows::runtime::Abi for CERT_SIMPLE_CHAIN {
7297     type Abi = Self;
7298     type DefaultType = Self;
7299 }
7300 pub const CERT_SMART_CARD_DATA_PROP_ID: u32 = 16u32;
7301 pub const CERT_SMART_CARD_READER_NON_REMOVABLE_PROP_ID: u32 = 106u32;
7302 pub const CERT_SMART_CARD_READER_PROP_ID: u32 = 101u32;
7303 pub const CERT_SMART_CARD_ROOT_INFO_PROP_ID: u32 = 76u32;
7304 pub const CERT_SOURCE_LOCATION_PROP_ID: u32 = 72u32;
7305 pub const CERT_SOURCE_URL_PROP_ID: u32 = 73u32;
7306 pub const CERT_SRV_OCSP_RESP_MIN_SYNC_CERT_FILE_SECONDS_DEFAULT: u32 = 5u32;
7307 pub const CERT_STORE_ADD_ALWAYS: u32 = 4u32;
7308 pub const CERT_STORE_ADD_NEW: u32 = 1u32;
7309 pub const CERT_STORE_ADD_NEWER: u32 = 6u32;
7310 pub const CERT_STORE_ADD_NEWER_INHERIT_PROPERTIES: u32 = 7u32;
7311 pub const CERT_STORE_ADD_REPLACE_EXISTING: u32 = 3u32;
7312 pub const CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES: u32 = 5u32;
7313 pub const CERT_STORE_ADD_USE_EXISTING: u32 = 2u32;
7314 pub const CERT_STORE_BASE_CRL_FLAG: u32 = 256u32;
7315 pub const CERT_STORE_CERTIFICATE_CONTEXT: u32 = 1u32;
7316 pub const CERT_STORE_CRL_CONTEXT: u32 = 2u32;
7317 pub const CERT_STORE_CTL_CONTEXT: u32 = 3u32;
7318 pub const CERT_STORE_CTRL_AUTO_RESYNC: u32 = 4u32;
7319 pub const CERT_STORE_CTRL_CANCEL_NOTIFY: u32 = 5u32;
7320 pub const CERT_STORE_CTRL_COMMIT: u32 = 3u32;
7321 pub const CERT_STORE_CTRL_NOTIFY_CHANGE: u32 = 2u32;
7322 pub const CERT_STORE_CTRL_RESYNC: u32 = 1u32;
7323 pub const CERT_STORE_DELTA_CRL_FLAG: u32 = 512u32;
7324 pub const CERT_STORE_LOCALIZED_NAME_PROP_ID: u32 = 4096u32;
7325 pub const CERT_STORE_MANIFOLD_FLAG: u32 = 256u32;
7326 pub const CERT_STORE_NO_CRL_FLAG: u32 = 65536u32;
7327 pub const CERT_STORE_NO_ISSUER_FLAG: u32 = 131072u32;
7328 pub const CERT_STORE_PROV_CLOSE_FUNC: u32 = 0u32;
7329 pub const CERT_STORE_PROV_CONTROL_FUNC: u32 = 13u32;
7330 pub const CERT_STORE_PROV_DELETE_CERT_FUNC: u32 = 3u32;
7331 pub const CERT_STORE_PROV_DELETE_CRL_FUNC: u32 = 7u32;
7332 pub const CERT_STORE_PROV_DELETE_CTL_FUNC: u32 = 11u32;
7333 pub const CERT_STORE_PROV_FIND_CERT_FUNC: u32 = 14u32;
7334 pub const CERT_STORE_PROV_FIND_CRL_FUNC: u32 = 17u32;
7335 pub const CERT_STORE_PROV_FIND_CTL_FUNC: u32 = 20u32;
7336 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7337 #[repr(C)]
7338 pub struct CERT_STORE_PROV_FIND_INFO {
7339     pub cbSize: u32,
7340     pub dwMsgAndCertEncodingType: u32,
7341     pub dwFindFlags: u32,
7342     pub dwFindType: u32,
7343     pub pvFindPara: *mut ::std::ffi::c_void,
7344 }
7345 impl CERT_STORE_PROV_FIND_INFO {}
7346 impl ::std::default::Default for CERT_STORE_PROV_FIND_INFO {
default() -> Self7347     fn default() -> Self {
7348         unsafe { ::std::mem::zeroed() }
7349     }
7350 }
7351 impl ::std::fmt::Debug for CERT_STORE_PROV_FIND_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7352     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7353         fmt.debug_struct("CERT_STORE_PROV_FIND_INFO").field("cbSize", &self.cbSize).field("dwMsgAndCertEncodingType", &self.dwMsgAndCertEncodingType).field("dwFindFlags", &self.dwFindFlags).field("dwFindType", &self.dwFindType).field("pvFindPara", &self.pvFindPara).finish()
7354     }
7355 }
7356 impl ::std::cmp::PartialEq for CERT_STORE_PROV_FIND_INFO {
eq(&self, other: &Self) -> bool7357     fn eq(&self, other: &Self) -> bool {
7358         self.cbSize == other.cbSize && self.dwMsgAndCertEncodingType == other.dwMsgAndCertEncodingType && self.dwFindFlags == other.dwFindFlags && self.dwFindType == other.dwFindType && self.pvFindPara == other.pvFindPara
7359     }
7360 }
7361 impl ::std::cmp::Eq for CERT_STORE_PROV_FIND_INFO {}
7362 unsafe impl ::windows::runtime::Abi for CERT_STORE_PROV_FIND_INFO {
7363     type Abi = Self;
7364     type DefaultType = Self;
7365 }
7366 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7367 #[repr(transparent)]
7368 pub struct CERT_STORE_PROV_FLAGS(pub u32);
7369 pub const CERT_STORE_PROV_EXTERNAL_FLAG: CERT_STORE_PROV_FLAGS = CERT_STORE_PROV_FLAGS(1u32);
7370 pub const CERT_STORE_PROV_DELETED_FLAG: CERT_STORE_PROV_FLAGS = CERT_STORE_PROV_FLAGS(2u32);
7371 pub const CERT_STORE_PROV_NO_PERSIST_FLAG: CERT_STORE_PROV_FLAGS = CERT_STORE_PROV_FLAGS(4u32);
7372 pub const CERT_STORE_PROV_SYSTEM_STORE_FLAG: CERT_STORE_PROV_FLAGS = CERT_STORE_PROV_FLAGS(8u32);
7373 pub const CERT_STORE_PROV_LM_SYSTEM_STORE_FLAG: CERT_STORE_PROV_FLAGS = CERT_STORE_PROV_FLAGS(16u32);
7374 impl ::std::convert::From<u32> for CERT_STORE_PROV_FLAGS {
from(value: u32) -> Self7375     fn from(value: u32) -> Self {
7376         Self(value)
7377     }
7378 }
7379 unsafe impl ::windows::runtime::Abi for CERT_STORE_PROV_FLAGS {
7380     type Abi = Self;
7381     type DefaultType = Self;
7382 }
7383 impl ::std::ops::BitOr for CERT_STORE_PROV_FLAGS {
7384     type Output = Self;
bitor(self, rhs: Self) -> Self7385     fn bitor(self, rhs: Self) -> Self {
7386         Self(self.0 | rhs.0)
7387     }
7388 }
7389 impl ::std::ops::BitAnd for CERT_STORE_PROV_FLAGS {
7390     type Output = Self;
bitand(self, rhs: Self) -> Self7391     fn bitand(self, rhs: Self) -> Self {
7392         Self(self.0 & rhs.0)
7393     }
7394 }
7395 impl ::std::ops::BitOrAssign for CERT_STORE_PROV_FLAGS {
bitor_assign(&mut self, rhs: Self)7396     fn bitor_assign(&mut self, rhs: Self) {
7397         self.0.bitor_assign(rhs.0)
7398     }
7399 }
7400 impl ::std::ops::BitAndAssign for CERT_STORE_PROV_FLAGS {
bitand_assign(&mut self, rhs: Self)7401     fn bitand_assign(&mut self, rhs: Self) {
7402         self.0.bitand_assign(rhs.0)
7403     }
7404 }
7405 impl ::std::ops::Not for CERT_STORE_PROV_FLAGS {
7406     type Output = Self;
not(self) -> Self7407     fn not(self) -> Self {
7408         Self(self.0.not())
7409     }
7410 }
7411 pub const CERT_STORE_PROV_FREE_FIND_CERT_FUNC: u32 = 15u32;
7412 pub const CERT_STORE_PROV_FREE_FIND_CRL_FUNC: u32 = 18u32;
7413 pub const CERT_STORE_PROV_FREE_FIND_CTL_FUNC: u32 = 21u32;
7414 pub const CERT_STORE_PROV_GET_CERT_PROPERTY_FUNC: u32 = 16u32;
7415 pub const CERT_STORE_PROV_GET_CRL_PROPERTY_FUNC: u32 = 19u32;
7416 pub const CERT_STORE_PROV_GET_CTL_PROPERTY_FUNC: u32 = 22u32;
7417 pub const CERT_STORE_PROV_GP_SYSTEM_STORE_FLAG: u32 = 32u32;
7418 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7419 #[repr(C)]
7420 pub struct CERT_STORE_PROV_INFO {
7421     pub cbSize: u32,
7422     pub cStoreProvFunc: u32,
7423     pub rgpvStoreProvFunc: *mut *mut ::std::ffi::c_void,
7424     pub hStoreProv: *mut ::std::ffi::c_void,
7425     pub dwStoreProvFlags: CERT_STORE_PROV_FLAGS,
7426     pub hStoreProvFuncAddr2: *mut ::std::ffi::c_void,
7427 }
7428 impl CERT_STORE_PROV_INFO {}
7429 impl ::std::default::Default for CERT_STORE_PROV_INFO {
default() -> Self7430     fn default() -> Self {
7431         unsafe { ::std::mem::zeroed() }
7432     }
7433 }
7434 impl ::std::fmt::Debug for CERT_STORE_PROV_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7435     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7436         fmt.debug_struct("CERT_STORE_PROV_INFO")
7437             .field("cbSize", &self.cbSize)
7438             .field("cStoreProvFunc", &self.cStoreProvFunc)
7439             .field("rgpvStoreProvFunc", &self.rgpvStoreProvFunc)
7440             .field("hStoreProv", &self.hStoreProv)
7441             .field("dwStoreProvFlags", &self.dwStoreProvFlags)
7442             .field("hStoreProvFuncAddr2", &self.hStoreProvFuncAddr2)
7443             .finish()
7444     }
7445 }
7446 impl ::std::cmp::PartialEq for CERT_STORE_PROV_INFO {
eq(&self, other: &Self) -> bool7447     fn eq(&self, other: &Self) -> bool {
7448         self.cbSize == other.cbSize && self.cStoreProvFunc == other.cStoreProvFunc && self.rgpvStoreProvFunc == other.rgpvStoreProvFunc && self.hStoreProv == other.hStoreProv && self.dwStoreProvFlags == other.dwStoreProvFlags && self.hStoreProvFuncAddr2 == other.hStoreProvFuncAddr2
7449     }
7450 }
7451 impl ::std::cmp::Eq for CERT_STORE_PROV_INFO {}
7452 unsafe impl ::windows::runtime::Abi for CERT_STORE_PROV_INFO {
7453     type Abi = Self;
7454     type DefaultType = Self;
7455 }
7456 pub const CERT_STORE_PROV_READ_CERT_FUNC: u32 = 1u32;
7457 pub const CERT_STORE_PROV_READ_CRL_FUNC: u32 = 5u32;
7458 pub const CERT_STORE_PROV_READ_CTL_FUNC: u32 = 9u32;
7459 pub const CERT_STORE_PROV_SET_CERT_PROPERTY_FUNC: u32 = 4u32;
7460 pub const CERT_STORE_PROV_SET_CRL_PROPERTY_FUNC: u32 = 8u32;
7461 pub const CERT_STORE_PROV_SET_CTL_PROPERTY_FUNC: u32 = 12u32;
7462 pub const CERT_STORE_PROV_SHARED_USER_FLAG: u32 = 64u32;
7463 pub const CERT_STORE_PROV_WRITE_ADD_FLAG: u32 = 1u32;
7464 pub const CERT_STORE_PROV_WRITE_CERT_FUNC: u32 = 2u32;
7465 pub const CERT_STORE_PROV_WRITE_CRL_FUNC: u32 = 6u32;
7466 pub const CERT_STORE_PROV_WRITE_CTL_FUNC: u32 = 10u32;
7467 pub const CERT_STORE_REVOCATION_FLAG: u32 = 4u32;
7468 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7469 #[repr(transparent)]
7470 pub struct CERT_STORE_SAVE_AS(pub u32);
7471 pub const CERT_STORE_SAVE_AS_PKCS7: CERT_STORE_SAVE_AS = CERT_STORE_SAVE_AS(2u32);
7472 pub const CERT_STORE_SAVE_AS_STORE: CERT_STORE_SAVE_AS = CERT_STORE_SAVE_AS(1u32);
7473 impl ::std::convert::From<u32> for CERT_STORE_SAVE_AS {
from(value: u32) -> Self7474     fn from(value: u32) -> Self {
7475         Self(value)
7476     }
7477 }
7478 unsafe impl ::windows::runtime::Abi for CERT_STORE_SAVE_AS {
7479     type Abi = Self;
7480     type DefaultType = Self;
7481 }
7482 impl ::std::ops::BitOr for CERT_STORE_SAVE_AS {
7483     type Output = Self;
bitor(self, rhs: Self) -> Self7484     fn bitor(self, rhs: Self) -> Self {
7485         Self(self.0 | rhs.0)
7486     }
7487 }
7488 impl ::std::ops::BitAnd for CERT_STORE_SAVE_AS {
7489     type Output = Self;
bitand(self, rhs: Self) -> Self7490     fn bitand(self, rhs: Self) -> Self {
7491         Self(self.0 & rhs.0)
7492     }
7493 }
7494 impl ::std::ops::BitOrAssign for CERT_STORE_SAVE_AS {
bitor_assign(&mut self, rhs: Self)7495     fn bitor_assign(&mut self, rhs: Self) {
7496         self.0.bitor_assign(rhs.0)
7497     }
7498 }
7499 impl ::std::ops::BitAndAssign for CERT_STORE_SAVE_AS {
bitand_assign(&mut self, rhs: Self)7500     fn bitand_assign(&mut self, rhs: Self) {
7501         self.0.bitand_assign(rhs.0)
7502     }
7503 }
7504 impl ::std::ops::Not for CERT_STORE_SAVE_AS {
7505     type Output = Self;
not(self) -> Self7506     fn not(self) -> Self {
7507         Self(self.0.not())
7508     }
7509 }
7510 pub const CERT_STORE_SAVE_AS_PKCS12: u32 = 3u32;
7511 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7512 #[repr(transparent)]
7513 pub struct CERT_STORE_SAVE_TO(pub u32);
7514 pub const CERT_STORE_SAVE_TO_FILE: CERT_STORE_SAVE_TO = CERT_STORE_SAVE_TO(1u32);
7515 pub const CERT_STORE_SAVE_TO_FILENAME: CERT_STORE_SAVE_TO = CERT_STORE_SAVE_TO(4u32);
7516 pub const CERT_STORE_SAVE_TO_FILENAME_A: CERT_STORE_SAVE_TO = CERT_STORE_SAVE_TO(3u32);
7517 pub const CERT_STORE_SAVE_TO_FILENAME_W: CERT_STORE_SAVE_TO = CERT_STORE_SAVE_TO(4u32);
7518 pub const CERT_STORE_SAVE_TO_MEMORY: CERT_STORE_SAVE_TO = CERT_STORE_SAVE_TO(2u32);
7519 impl ::std::convert::From<u32> for CERT_STORE_SAVE_TO {
from(value: u32) -> Self7520     fn from(value: u32) -> Self {
7521         Self(value)
7522     }
7523 }
7524 unsafe impl ::windows::runtime::Abi for CERT_STORE_SAVE_TO {
7525     type Abi = Self;
7526     type DefaultType = Self;
7527 }
7528 impl ::std::ops::BitOr for CERT_STORE_SAVE_TO {
7529     type Output = Self;
bitor(self, rhs: Self) -> Self7530     fn bitor(self, rhs: Self) -> Self {
7531         Self(self.0 | rhs.0)
7532     }
7533 }
7534 impl ::std::ops::BitAnd for CERT_STORE_SAVE_TO {
7535     type Output = Self;
bitand(self, rhs: Self) -> Self7536     fn bitand(self, rhs: Self) -> Self {
7537         Self(self.0 & rhs.0)
7538     }
7539 }
7540 impl ::std::ops::BitOrAssign for CERT_STORE_SAVE_TO {
bitor_assign(&mut self, rhs: Self)7541     fn bitor_assign(&mut self, rhs: Self) {
7542         self.0.bitor_assign(rhs.0)
7543     }
7544 }
7545 impl ::std::ops::BitAndAssign for CERT_STORE_SAVE_TO {
bitand_assign(&mut self, rhs: Self)7546     fn bitand_assign(&mut self, rhs: Self) {
7547         self.0.bitand_assign(rhs.0)
7548     }
7549 }
7550 impl ::std::ops::Not for CERT_STORE_SAVE_TO {
7551     type Output = Self;
not(self) -> Self7552     fn not(self) -> Self {
7553         Self(self.0.not())
7554     }
7555 }
7556 pub const CERT_STORE_SHARE_STORE_FLAG: u32 = 64u32;
7557 pub const CERT_STORE_SIGNATURE_FLAG: u32 = 1u32;
7558 pub const CERT_STORE_TIME_VALIDITY_FLAG: u32 = 2u32;
7559 pub const CERT_STORE_UNSAFE_PHYSICAL_FLAG: u32 = 32u32;
7560 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7561 #[repr(transparent)]
7562 pub struct CERT_STRING_TYPE(pub u32);
7563 pub const CERT_SIMPLE_NAME_STR: CERT_STRING_TYPE = CERT_STRING_TYPE(1u32);
7564 pub const CERT_OID_NAME_STR: CERT_STRING_TYPE = CERT_STRING_TYPE(2u32);
7565 pub const CERT_X500_NAME_STR: CERT_STRING_TYPE = CERT_STRING_TYPE(3u32);
7566 impl ::std::convert::From<u32> for CERT_STRING_TYPE {
from(value: u32) -> Self7567     fn from(value: u32) -> Self {
7568         Self(value)
7569     }
7570 }
7571 unsafe impl ::windows::runtime::Abi for CERT_STRING_TYPE {
7572     type Abi = Self;
7573     type DefaultType = Self;
7574 }
7575 impl ::std::ops::BitOr for CERT_STRING_TYPE {
7576     type Output = Self;
bitor(self, rhs: Self) -> Self7577     fn bitor(self, rhs: Self) -> Self {
7578         Self(self.0 | rhs.0)
7579     }
7580 }
7581 impl ::std::ops::BitAnd for CERT_STRING_TYPE {
7582     type Output = Self;
bitand(self, rhs: Self) -> Self7583     fn bitand(self, rhs: Self) -> Self {
7584         Self(self.0 & rhs.0)
7585     }
7586 }
7587 impl ::std::ops::BitOrAssign for CERT_STRING_TYPE {
bitor_assign(&mut self, rhs: Self)7588     fn bitor_assign(&mut self, rhs: Self) {
7589         self.0.bitor_assign(rhs.0)
7590     }
7591 }
7592 impl ::std::ops::BitAndAssign for CERT_STRING_TYPE {
bitand_assign(&mut self, rhs: Self)7593     fn bitand_assign(&mut self, rhs: Self) {
7594         self.0.bitand_assign(rhs.0)
7595     }
7596 }
7597 impl ::std::ops::Not for CERT_STRING_TYPE {
7598     type Output = Self;
not(self) -> Self7599     fn not(self) -> Self {
7600         Self(self.0.not())
7601     }
7602 }
7603 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7604 #[repr(transparent)]
7605 pub struct CERT_STRONG_SIGN_FLAGS(pub u32);
7606 pub const CERT_STRONG_SIGN_ENABLE_CRL_CHECK: CERT_STRONG_SIGN_FLAGS = CERT_STRONG_SIGN_FLAGS(1u32);
7607 pub const CERT_STRONG_SIGN_ENABLE_OCSP_CHECK: CERT_STRONG_SIGN_FLAGS = CERT_STRONG_SIGN_FLAGS(2u32);
7608 impl ::std::convert::From<u32> for CERT_STRONG_SIGN_FLAGS {
from(value: u32) -> Self7609     fn from(value: u32) -> Self {
7610         Self(value)
7611     }
7612 }
7613 unsafe impl ::windows::runtime::Abi for CERT_STRONG_SIGN_FLAGS {
7614     type Abi = Self;
7615     type DefaultType = Self;
7616 }
7617 impl ::std::ops::BitOr for CERT_STRONG_SIGN_FLAGS {
7618     type Output = Self;
bitor(self, rhs: Self) -> Self7619     fn bitor(self, rhs: Self) -> Self {
7620         Self(self.0 | rhs.0)
7621     }
7622 }
7623 impl ::std::ops::BitAnd for CERT_STRONG_SIGN_FLAGS {
7624     type Output = Self;
bitand(self, rhs: Self) -> Self7625     fn bitand(self, rhs: Self) -> Self {
7626         Self(self.0 & rhs.0)
7627     }
7628 }
7629 impl ::std::ops::BitOrAssign for CERT_STRONG_SIGN_FLAGS {
bitor_assign(&mut self, rhs: Self)7630     fn bitor_assign(&mut self, rhs: Self) {
7631         self.0.bitor_assign(rhs.0)
7632     }
7633 }
7634 impl ::std::ops::BitAndAssign for CERT_STRONG_SIGN_FLAGS {
bitand_assign(&mut self, rhs: Self)7635     fn bitand_assign(&mut self, rhs: Self) {
7636         self.0.bitand_assign(rhs.0)
7637     }
7638 }
7639 impl ::std::ops::Not for CERT_STRONG_SIGN_FLAGS {
7640     type Output = Self;
not(self) -> Self7641     fn not(self) -> Self {
7642         Self(self.0.not())
7643     }
7644 }
7645 pub const CERT_STRONG_SIGN_OID_INFO_CHOICE: u32 = 2u32;
7646 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7647 #[repr(C)]
7648 #[cfg(feature = "Win32_Foundation")]
7649 pub struct CERT_STRONG_SIGN_PARA {
7650     pub cbSize: u32,
7651     pub dwInfoChoice: u32,
7652     pub Anonymous: CERT_STRONG_SIGN_PARA_0,
7653 }
7654 #[cfg(feature = "Win32_Foundation")]
7655 impl CERT_STRONG_SIGN_PARA {}
7656 #[cfg(feature = "Win32_Foundation")]
7657 impl ::std::default::Default for CERT_STRONG_SIGN_PARA {
default() -> Self7658     fn default() -> Self {
7659         unsafe { ::std::mem::zeroed() }
7660     }
7661 }
7662 #[cfg(feature = "Win32_Foundation")]
7663 impl ::std::cmp::PartialEq for CERT_STRONG_SIGN_PARA {
eq(&self, _other: &Self) -> bool7664     fn eq(&self, _other: &Self) -> bool {
7665         unimplemented!()
7666     }
7667 }
7668 #[cfg(feature = "Win32_Foundation")]
7669 impl ::std::cmp::Eq for CERT_STRONG_SIGN_PARA {}
7670 #[cfg(feature = "Win32_Foundation")]
7671 unsafe impl ::windows::runtime::Abi for CERT_STRONG_SIGN_PARA {
7672     type Abi = Self;
7673     type DefaultType = Self;
7674 }
7675 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7676 #[repr(C)]
7677 #[cfg(feature = "Win32_Foundation")]
7678 pub union CERT_STRONG_SIGN_PARA_0 {
7679     pub pvInfo: *mut ::std::ffi::c_void,
7680     pub pSerializedInfo: *mut CERT_STRONG_SIGN_SERIALIZED_INFO,
7681     pub pszOID: super::super::Foundation::PSTR,
7682 }
7683 #[cfg(feature = "Win32_Foundation")]
7684 impl CERT_STRONG_SIGN_PARA_0 {}
7685 #[cfg(feature = "Win32_Foundation")]
7686 impl ::std::default::Default for CERT_STRONG_SIGN_PARA_0 {
default() -> Self7687     fn default() -> Self {
7688         unsafe { ::std::mem::zeroed() }
7689     }
7690 }
7691 #[cfg(feature = "Win32_Foundation")]
7692 impl ::std::cmp::PartialEq for CERT_STRONG_SIGN_PARA_0 {
eq(&self, _other: &Self) -> bool7693     fn eq(&self, _other: &Self) -> bool {
7694         unimplemented!()
7695     }
7696 }
7697 #[cfg(feature = "Win32_Foundation")]
7698 impl ::std::cmp::Eq for CERT_STRONG_SIGN_PARA_0 {}
7699 #[cfg(feature = "Win32_Foundation")]
7700 unsafe impl ::windows::runtime::Abi for CERT_STRONG_SIGN_PARA_0 {
7701     type Abi = Self;
7702     type DefaultType = Self;
7703 }
7704 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7705 #[repr(C)]
7706 #[cfg(feature = "Win32_Foundation")]
7707 pub struct CERT_STRONG_SIGN_SERIALIZED_INFO {
7708     pub dwFlags: CERT_STRONG_SIGN_FLAGS,
7709     pub pwszCNGSignHashAlgids: super::super::Foundation::PWSTR,
7710     pub pwszCNGPubKeyMinBitLengths: super::super::Foundation::PWSTR,
7711 }
7712 #[cfg(feature = "Win32_Foundation")]
7713 impl CERT_STRONG_SIGN_SERIALIZED_INFO {}
7714 #[cfg(feature = "Win32_Foundation")]
7715 impl ::std::default::Default for CERT_STRONG_SIGN_SERIALIZED_INFO {
default() -> Self7716     fn default() -> Self {
7717         unsafe { ::std::mem::zeroed() }
7718     }
7719 }
7720 #[cfg(feature = "Win32_Foundation")]
7721 impl ::std::fmt::Debug for CERT_STRONG_SIGN_SERIALIZED_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7722     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7723         fmt.debug_struct("CERT_STRONG_SIGN_SERIALIZED_INFO").field("dwFlags", &self.dwFlags).field("pwszCNGSignHashAlgids", &self.pwszCNGSignHashAlgids).field("pwszCNGPubKeyMinBitLengths", &self.pwszCNGPubKeyMinBitLengths).finish()
7724     }
7725 }
7726 #[cfg(feature = "Win32_Foundation")]
7727 impl ::std::cmp::PartialEq for CERT_STRONG_SIGN_SERIALIZED_INFO {
eq(&self, other: &Self) -> bool7728     fn eq(&self, other: &Self) -> bool {
7729         self.dwFlags == other.dwFlags && self.pwszCNGSignHashAlgids == other.pwszCNGSignHashAlgids && self.pwszCNGPubKeyMinBitLengths == other.pwszCNGPubKeyMinBitLengths
7730     }
7731 }
7732 #[cfg(feature = "Win32_Foundation")]
7733 impl ::std::cmp::Eq for CERT_STRONG_SIGN_SERIALIZED_INFO {}
7734 #[cfg(feature = "Win32_Foundation")]
7735 unsafe impl ::windows::runtime::Abi for CERT_STRONG_SIGN_SERIALIZED_INFO {
7736     type Abi = Self;
7737     type DefaultType = Self;
7738 }
7739 pub const CERT_STRONG_SIGN_SERIALIZED_INFO_CHOICE: u32 = 1u32;
7740 pub const CERT_SUBJECT_DISABLE_CRL_PROP_ID: u32 = 86u32;
7741 pub const CERT_SUBJECT_INFO_ACCESS_PROP_ID: u32 = 80u32;
7742 pub const CERT_SUBJECT_NAME_MD5_HASH_PROP_ID: u32 = 29u32;
7743 pub const CERT_SUBJECT_OCSP_AUTHORITY_INFO_ACCESS_PROP_ID: u32 = 85u32;
7744 pub const CERT_SUBJECT_PUBLIC_KEY_MD5_HASH_PROP_ID: u32 = 25u32;
7745 pub const CERT_SUBJECT_PUB_KEY_BIT_LENGTH_PROP_ID: u32 = 92u32;
7746 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7747 #[repr(C)]
7748 #[cfg(feature = "Win32_Foundation")]
7749 pub struct CERT_SUPPORTED_ALGORITHM_INFO {
7750     pub Algorithm: CRYPT_ALGORITHM_IDENTIFIER,
7751     pub IntendedKeyUsage: CRYPT_BIT_BLOB,
7752     pub IntendedCertPolicies: CERT_POLICIES_INFO,
7753 }
7754 #[cfg(feature = "Win32_Foundation")]
7755 impl CERT_SUPPORTED_ALGORITHM_INFO {}
7756 #[cfg(feature = "Win32_Foundation")]
7757 impl ::std::default::Default for CERT_SUPPORTED_ALGORITHM_INFO {
default() -> Self7758     fn default() -> Self {
7759         unsafe { ::std::mem::zeroed() }
7760     }
7761 }
7762 #[cfg(feature = "Win32_Foundation")]
7763 impl ::std::fmt::Debug for CERT_SUPPORTED_ALGORITHM_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7764     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7765         fmt.debug_struct("CERT_SUPPORTED_ALGORITHM_INFO").field("Algorithm", &self.Algorithm).field("IntendedKeyUsage", &self.IntendedKeyUsage).field("IntendedCertPolicies", &self.IntendedCertPolicies).finish()
7766     }
7767 }
7768 #[cfg(feature = "Win32_Foundation")]
7769 impl ::std::cmp::PartialEq for CERT_SUPPORTED_ALGORITHM_INFO {
eq(&self, other: &Self) -> bool7770     fn eq(&self, other: &Self) -> bool {
7771         self.Algorithm == other.Algorithm && self.IntendedKeyUsage == other.IntendedKeyUsage && self.IntendedCertPolicies == other.IntendedCertPolicies
7772     }
7773 }
7774 #[cfg(feature = "Win32_Foundation")]
7775 impl ::std::cmp::Eq for CERT_SUPPORTED_ALGORITHM_INFO {}
7776 #[cfg(feature = "Win32_Foundation")]
7777 unsafe impl ::windows::runtime::Abi for CERT_SUPPORTED_ALGORITHM_INFO {
7778     type Abi = Self;
7779     type DefaultType = Self;
7780 }
7781 pub const CERT_SYSTEM_STORE_CURRENT_SERVICE_ID: u32 = 4u32;
7782 pub const CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY_ID: u32 = 7u32;
7783 pub const CERT_SYSTEM_STORE_CURRENT_USER_ID: u32 = 1u32;
7784 pub const CERT_SYSTEM_STORE_DEFER_READ_FLAG: u32 = 536870912u32;
7785 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7786 #[repr(transparent)]
7787 pub struct CERT_SYSTEM_STORE_FLAGS(pub u32);
7788 pub const CERT_SYSTEM_STORE_LOCATION_MASK: CERT_SYSTEM_STORE_FLAGS = CERT_SYSTEM_STORE_FLAGS(16711680u32);
7789 pub const CERT_SYSTEM_STORE_RELOCATE_FLAG: CERT_SYSTEM_STORE_FLAGS = CERT_SYSTEM_STORE_FLAGS(2147483648u32);
7790 impl ::std::convert::From<u32> for CERT_SYSTEM_STORE_FLAGS {
from(value: u32) -> Self7791     fn from(value: u32) -> Self {
7792         Self(value)
7793     }
7794 }
7795 unsafe impl ::windows::runtime::Abi for CERT_SYSTEM_STORE_FLAGS {
7796     type Abi = Self;
7797     type DefaultType = Self;
7798 }
7799 impl ::std::ops::BitOr for CERT_SYSTEM_STORE_FLAGS {
7800     type Output = Self;
bitor(self, rhs: Self) -> Self7801     fn bitor(self, rhs: Self) -> Self {
7802         Self(self.0 | rhs.0)
7803     }
7804 }
7805 impl ::std::ops::BitAnd for CERT_SYSTEM_STORE_FLAGS {
7806     type Output = Self;
bitand(self, rhs: Self) -> Self7807     fn bitand(self, rhs: Self) -> Self {
7808         Self(self.0 & rhs.0)
7809     }
7810 }
7811 impl ::std::ops::BitOrAssign for CERT_SYSTEM_STORE_FLAGS {
bitor_assign(&mut self, rhs: Self)7812     fn bitor_assign(&mut self, rhs: Self) {
7813         self.0.bitor_assign(rhs.0)
7814     }
7815 }
7816 impl ::std::ops::BitAndAssign for CERT_SYSTEM_STORE_FLAGS {
bitand_assign(&mut self, rhs: Self)7817     fn bitand_assign(&mut self, rhs: Self) {
7818         self.0.bitand_assign(rhs.0)
7819     }
7820 }
7821 impl ::std::ops::Not for CERT_SYSTEM_STORE_FLAGS {
7822     type Output = Self;
not(self) -> Self7823     fn not(self) -> Self {
7824         Self(self.0.not())
7825     }
7826 }
7827 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7828 #[repr(C)]
7829 pub struct CERT_SYSTEM_STORE_INFO {
7830     pub cbSize: u32,
7831 }
7832 impl CERT_SYSTEM_STORE_INFO {}
7833 impl ::std::default::Default for CERT_SYSTEM_STORE_INFO {
default() -> Self7834     fn default() -> Self {
7835         unsafe { ::std::mem::zeroed() }
7836     }
7837 }
7838 impl ::std::fmt::Debug for CERT_SYSTEM_STORE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7839     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7840         fmt.debug_struct("CERT_SYSTEM_STORE_INFO").field("cbSize", &self.cbSize).finish()
7841     }
7842 }
7843 impl ::std::cmp::PartialEq for CERT_SYSTEM_STORE_INFO {
eq(&self, other: &Self) -> bool7844     fn eq(&self, other: &Self) -> bool {
7845         self.cbSize == other.cbSize
7846     }
7847 }
7848 impl ::std::cmp::Eq for CERT_SYSTEM_STORE_INFO {}
7849 unsafe impl ::windows::runtime::Abi for CERT_SYSTEM_STORE_INFO {
7850     type Abi = Self;
7851     type DefaultType = Self;
7852 }
7853 pub const CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE_ID: u32 = 9u32;
7854 pub const CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY_ID: u32 = 8u32;
7855 pub const CERT_SYSTEM_STORE_LOCAL_MACHINE_ID: u32 = 2u32;
7856 pub const CERT_SYSTEM_STORE_LOCAL_MACHINE_WCOS_ID: u32 = 10u32;
7857 pub const CERT_SYSTEM_STORE_LOCATION_SHIFT: u32 = 16u32;
7858 pub const CERT_SYSTEM_STORE_MASK: u32 = 4294901760u32;
7859 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7860 #[repr(C)]
7861 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
7862 pub struct CERT_SYSTEM_STORE_RELOCATE_PARA {
7863     pub Anonymous1: CERT_SYSTEM_STORE_RELOCATE_PARA_0,
7864     pub Anonymous2: CERT_SYSTEM_STORE_RELOCATE_PARA_1,
7865 }
7866 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
7867 impl CERT_SYSTEM_STORE_RELOCATE_PARA {}
7868 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
7869 impl ::std::default::Default for CERT_SYSTEM_STORE_RELOCATE_PARA {
default() -> Self7870     fn default() -> Self {
7871         unsafe { ::std::mem::zeroed() }
7872     }
7873 }
7874 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
7875 impl ::std::cmp::PartialEq for CERT_SYSTEM_STORE_RELOCATE_PARA {
eq(&self, _other: &Self) -> bool7876     fn eq(&self, _other: &Self) -> bool {
7877         unimplemented!()
7878     }
7879 }
7880 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
7881 impl ::std::cmp::Eq for CERT_SYSTEM_STORE_RELOCATE_PARA {}
7882 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
7883 unsafe impl ::windows::runtime::Abi for CERT_SYSTEM_STORE_RELOCATE_PARA {
7884     type Abi = Self;
7885     type DefaultType = Self;
7886 }
7887 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7888 #[repr(C)]
7889 #[cfg(feature = "Win32_System_Registry")]
7890 pub union CERT_SYSTEM_STORE_RELOCATE_PARA_0 {
7891     pub hKeyBase: super::super::System::Registry::HKEY,
7892     pub pvBase: *mut ::std::ffi::c_void,
7893 }
7894 #[cfg(feature = "Win32_System_Registry")]
7895 impl CERT_SYSTEM_STORE_RELOCATE_PARA_0 {}
7896 #[cfg(feature = "Win32_System_Registry")]
7897 impl ::std::default::Default for CERT_SYSTEM_STORE_RELOCATE_PARA_0 {
default() -> Self7898     fn default() -> Self {
7899         unsafe { ::std::mem::zeroed() }
7900     }
7901 }
7902 #[cfg(feature = "Win32_System_Registry")]
7903 impl ::std::cmp::PartialEq for CERT_SYSTEM_STORE_RELOCATE_PARA_0 {
eq(&self, _other: &Self) -> bool7904     fn eq(&self, _other: &Self) -> bool {
7905         unimplemented!()
7906     }
7907 }
7908 #[cfg(feature = "Win32_System_Registry")]
7909 impl ::std::cmp::Eq for CERT_SYSTEM_STORE_RELOCATE_PARA_0 {}
7910 #[cfg(feature = "Win32_System_Registry")]
7911 unsafe impl ::windows::runtime::Abi for CERT_SYSTEM_STORE_RELOCATE_PARA_0 {
7912     type Abi = Self;
7913     type DefaultType = Self;
7914 }
7915 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7916 #[repr(C)]
7917 #[cfg(feature = "Win32_Foundation")]
7918 pub union CERT_SYSTEM_STORE_RELOCATE_PARA_1 {
7919     pub pvSystemStore: *mut ::std::ffi::c_void,
7920     pub pszSystemStore: super::super::Foundation::PSTR,
7921     pub pwszSystemStore: super::super::Foundation::PWSTR,
7922 }
7923 #[cfg(feature = "Win32_Foundation")]
7924 impl CERT_SYSTEM_STORE_RELOCATE_PARA_1 {}
7925 #[cfg(feature = "Win32_Foundation")]
7926 impl ::std::default::Default for CERT_SYSTEM_STORE_RELOCATE_PARA_1 {
default() -> Self7927     fn default() -> Self {
7928         unsafe { ::std::mem::zeroed() }
7929     }
7930 }
7931 #[cfg(feature = "Win32_Foundation")]
7932 impl ::std::cmp::PartialEq for CERT_SYSTEM_STORE_RELOCATE_PARA_1 {
eq(&self, _other: &Self) -> bool7933     fn eq(&self, _other: &Self) -> bool {
7934         unimplemented!()
7935     }
7936 }
7937 #[cfg(feature = "Win32_Foundation")]
7938 impl ::std::cmp::Eq for CERT_SYSTEM_STORE_RELOCATE_PARA_1 {}
7939 #[cfg(feature = "Win32_Foundation")]
7940 unsafe impl ::windows::runtime::Abi for CERT_SYSTEM_STORE_RELOCATE_PARA_1 {
7941     type Abi = Self;
7942     type DefaultType = Self;
7943 }
7944 pub const CERT_SYSTEM_STORE_SERVICES_ID: u32 = 5u32;
7945 pub const CERT_SYSTEM_STORE_UNPROTECTED_FLAG: u32 = 1073741824u32;
7946 pub const CERT_SYSTEM_STORE_USERS_ID: u32 = 6u32;
7947 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7948 #[repr(C)]
7949 #[cfg(feature = "Win32_Foundation")]
7950 pub struct CERT_TEMPLATE_EXT {
7951     pub pszObjId: super::super::Foundation::PSTR,
7952     pub dwMajorVersion: u32,
7953     pub fMinorVersion: super::super::Foundation::BOOL,
7954     pub dwMinorVersion: u32,
7955 }
7956 #[cfg(feature = "Win32_Foundation")]
7957 impl CERT_TEMPLATE_EXT {}
7958 #[cfg(feature = "Win32_Foundation")]
7959 impl ::std::default::Default for CERT_TEMPLATE_EXT {
default() -> Self7960     fn default() -> Self {
7961         unsafe { ::std::mem::zeroed() }
7962     }
7963 }
7964 #[cfg(feature = "Win32_Foundation")]
7965 impl ::std::fmt::Debug for CERT_TEMPLATE_EXT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7966     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7967         fmt.debug_struct("CERT_TEMPLATE_EXT").field("pszObjId", &self.pszObjId).field("dwMajorVersion", &self.dwMajorVersion).field("fMinorVersion", &self.fMinorVersion).field("dwMinorVersion", &self.dwMinorVersion).finish()
7968     }
7969 }
7970 #[cfg(feature = "Win32_Foundation")]
7971 impl ::std::cmp::PartialEq for CERT_TEMPLATE_EXT {
eq(&self, other: &Self) -> bool7972     fn eq(&self, other: &Self) -> bool {
7973         self.pszObjId == other.pszObjId && self.dwMajorVersion == other.dwMajorVersion && self.fMinorVersion == other.fMinorVersion && self.dwMinorVersion == other.dwMinorVersion
7974     }
7975 }
7976 #[cfg(feature = "Win32_Foundation")]
7977 impl ::std::cmp::Eq for CERT_TEMPLATE_EXT {}
7978 #[cfg(feature = "Win32_Foundation")]
7979 unsafe impl ::windows::runtime::Abi for CERT_TEMPLATE_EXT {
7980     type Abi = Self;
7981     type DefaultType = Self;
7982 }
7983 pub const CERT_TIMESTAMP_HASH_USE_TYPE: u32 = 2u32;
7984 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7985 #[repr(C)]
7986 #[cfg(feature = "Win32_Foundation")]
7987 pub struct CERT_TPM_SPECIFICATION_INFO {
7988     pub pwszFamily: super::super::Foundation::PWSTR,
7989     pub dwLevel: u32,
7990     pub dwRevision: u32,
7991 }
7992 #[cfg(feature = "Win32_Foundation")]
7993 impl CERT_TPM_SPECIFICATION_INFO {}
7994 #[cfg(feature = "Win32_Foundation")]
7995 impl ::std::default::Default for CERT_TPM_SPECIFICATION_INFO {
default() -> Self7996     fn default() -> Self {
7997         unsafe { ::std::mem::zeroed() }
7998     }
7999 }
8000 #[cfg(feature = "Win32_Foundation")]
8001 impl ::std::fmt::Debug for CERT_TPM_SPECIFICATION_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8002     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8003         fmt.debug_struct("CERT_TPM_SPECIFICATION_INFO").field("pwszFamily", &self.pwszFamily).field("dwLevel", &self.dwLevel).field("dwRevision", &self.dwRevision).finish()
8004     }
8005 }
8006 #[cfg(feature = "Win32_Foundation")]
8007 impl ::std::cmp::PartialEq for CERT_TPM_SPECIFICATION_INFO {
eq(&self, other: &Self) -> bool8008     fn eq(&self, other: &Self) -> bool {
8009         self.pwszFamily == other.pwszFamily && self.dwLevel == other.dwLevel && self.dwRevision == other.dwRevision
8010     }
8011 }
8012 #[cfg(feature = "Win32_Foundation")]
8013 impl ::std::cmp::Eq for CERT_TPM_SPECIFICATION_INFO {}
8014 #[cfg(feature = "Win32_Foundation")]
8015 unsafe impl ::windows::runtime::Abi for CERT_TPM_SPECIFICATION_INFO {
8016     type Abi = Self;
8017     type DefaultType = Self;
8018 }
8019 pub const CERT_TRUST_AUTO_UPDATE_CA_REVOCATION: u32 = 16u32;
8020 pub const CERT_TRUST_AUTO_UPDATE_END_REVOCATION: u32 = 32u32;
8021 pub const CERT_TRUST_CTL_IS_NOT_SIGNATURE_VALID: u32 = 262144u32;
8022 pub const CERT_TRUST_CTL_IS_NOT_TIME_VALID: u32 = 131072u32;
8023 pub const CERT_TRUST_CTL_IS_NOT_VALID_FOR_USAGE: u32 = 524288u32;
8024 pub const CERT_TRUST_DO_FULL_SEARCH: u32 = 1u32;
8025 pub const CERT_TRUST_DO_FULL_TRUST: u32 = 5u32;
8026 pub const CERT_TRUST_HAS_ALLOW_WEAK_SIGNATURE: u32 = 131072u32;
8027 pub const CERT_TRUST_HAS_AUTO_UPDATE_WEAK_SIGNATURE: u32 = 32768u32;
8028 pub const CERT_TRUST_HAS_CRL_VALIDITY_EXTENDED: u32 = 4096u32;
8029 pub const CERT_TRUST_HAS_EXACT_MATCH_ISSUER: u32 = 1u32;
8030 pub const CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT: u32 = 32768u32;
8031 pub const CERT_TRUST_HAS_ISSUANCE_CHAIN_POLICY: u32 = 512u32;
8032 pub const CERT_TRUST_HAS_KEY_MATCH_ISSUER: u32 = 2u32;
8033 pub const CERT_TRUST_HAS_NAME_MATCH_ISSUER: u32 = 4u32;
8034 pub const CERT_TRUST_HAS_NOT_DEFINED_NAME_CONSTRAINT: u32 = 8192u32;
8035 pub const CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT: u32 = 16384u32;
8036 pub const CERT_TRUST_HAS_NOT_SUPPORTED_CRITICAL_EXT: u32 = 134217728u32;
8037 pub const CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT: u32 = 4096u32;
8038 pub const CERT_TRUST_HAS_PREFERRED_ISSUER: u32 = 256u32;
8039 pub const CERT_TRUST_HAS_VALID_NAME_CONSTRAINTS: u32 = 1024u32;
8040 pub const CERT_TRUST_HAS_WEAK_HYGIENE: u32 = 2097152u32;
8041 pub const CERT_TRUST_HAS_WEAK_SIGNATURE: u32 = 1048576u32;
8042 pub const CERT_TRUST_INVALID_BASIC_CONSTRAINTS: u32 = 1024u32;
8043 pub const CERT_TRUST_INVALID_EXTENSION: u32 = 256u32;
8044 pub const CERT_TRUST_INVALID_NAME_CONSTRAINTS: u32 = 2048u32;
8045 pub const CERT_TRUST_INVALID_POLICY_CONSTRAINTS: u32 = 512u32;
8046 pub const CERT_TRUST_IS_CA_TRUSTED: u32 = 16384u32;
8047 pub const CERT_TRUST_IS_COMPLEX_CHAIN: u32 = 65536u32;
8048 pub const CERT_TRUST_IS_CYCLIC: u32 = 128u32;
8049 pub const CERT_TRUST_IS_EXPLICIT_DISTRUST: u32 = 67108864u32;
8050 pub const CERT_TRUST_IS_FROM_EXCLUSIVE_TRUST_STORE: u32 = 8192u32;
8051 pub const CERT_TRUST_IS_KEY_ROLLOVER: u32 = 128u32;
8052 pub const CERT_TRUST_IS_NOT_SIGNATURE_VALID: u32 = 8u32;
8053 pub const CERT_TRUST_IS_NOT_TIME_NESTED: u32 = 2u32;
8054 pub const CERT_TRUST_IS_NOT_TIME_VALID: u32 = 1u32;
8055 pub const CERT_TRUST_IS_NOT_VALID_FOR_USAGE: u32 = 16u32;
8056 pub const CERT_TRUST_IS_OFFLINE_REVOCATION: u32 = 16777216u32;
8057 pub const CERT_TRUST_IS_PARTIAL_CHAIN: u32 = 65536u32;
8058 pub const CERT_TRUST_IS_PEER_TRUSTED: u32 = 2048u32;
8059 pub const CERT_TRUST_IS_REVOKED: u32 = 4u32;
8060 pub const CERT_TRUST_IS_SELF_SIGNED: u32 = 8u32;
8061 pub const CERT_TRUST_IS_UNTRUSTED_ROOT: u32 = 32u32;
8062 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8063 #[repr(C)]
8064 #[cfg(feature = "Win32_Foundation")]
8065 pub struct CERT_TRUST_LIST_INFO {
8066     pub cbSize: u32,
8067     pub pCtlEntry: *mut CTL_ENTRY,
8068     pub pCtlContext: *mut CTL_CONTEXT,
8069 }
8070 #[cfg(feature = "Win32_Foundation")]
8071 impl CERT_TRUST_LIST_INFO {}
8072 #[cfg(feature = "Win32_Foundation")]
8073 impl ::std::default::Default for CERT_TRUST_LIST_INFO {
default() -> Self8074     fn default() -> Self {
8075         unsafe { ::std::mem::zeroed() }
8076     }
8077 }
8078 #[cfg(feature = "Win32_Foundation")]
8079 impl ::std::fmt::Debug for CERT_TRUST_LIST_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8080     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8081         fmt.debug_struct("CERT_TRUST_LIST_INFO").field("cbSize", &self.cbSize).field("pCtlEntry", &self.pCtlEntry).field("pCtlContext", &self.pCtlContext).finish()
8082     }
8083 }
8084 #[cfg(feature = "Win32_Foundation")]
8085 impl ::std::cmp::PartialEq for CERT_TRUST_LIST_INFO {
eq(&self, other: &Self) -> bool8086     fn eq(&self, other: &Self) -> bool {
8087         self.cbSize == other.cbSize && self.pCtlEntry == other.pCtlEntry && self.pCtlContext == other.pCtlContext
8088     }
8089 }
8090 #[cfg(feature = "Win32_Foundation")]
8091 impl ::std::cmp::Eq for CERT_TRUST_LIST_INFO {}
8092 #[cfg(feature = "Win32_Foundation")]
8093 unsafe impl ::windows::runtime::Abi for CERT_TRUST_LIST_INFO {
8094     type Abi = Self;
8095     type DefaultType = Self;
8096 }
8097 pub const CERT_TRUST_MASK: u32 = 16777215u32;
8098 pub const CERT_TRUST_NO_ERROR: u32 = 0u32;
8099 pub const CERT_TRUST_NO_ISSUANCE_CHAIN_POLICY: u32 = 33554432u32;
8100 pub const CERT_TRUST_NO_OCSP_FAILOVER_TO_CRL: u32 = 64u32;
8101 pub const CERT_TRUST_NO_TIME_CHECK: u32 = 33554432u32;
8102 pub const CERT_TRUST_PERMIT_MISSING_CRLS: u32 = 2u32;
8103 pub const CERT_TRUST_PUB_ALLOW_END_USER_TRUST: u32 = 0u32;
8104 pub const CERT_TRUST_PUB_ALLOW_ENTERPRISE_ADMIN_TRUST: u32 = 2u32;
8105 pub const CERT_TRUST_PUB_ALLOW_MACHINE_ADMIN_TRUST: u32 = 1u32;
8106 pub const CERT_TRUST_PUB_ALLOW_TRUST_MASK: u32 = 3u32;
8107 pub const CERT_TRUST_PUB_CHECK_PUBLISHER_REV_FLAG: u32 = 256u32;
8108 pub const CERT_TRUST_PUB_CHECK_TIMESTAMP_REV_FLAG: u32 = 512u32;
8109 pub const CERT_TRUST_REVOCATION_STATUS_UNKNOWN: u32 = 64u32;
8110 pub const CERT_TRUST_SSL_HANDSHAKE_OCSP: u32 = 262144u32;
8111 pub const CERT_TRUST_SSL_RECONNECT_OCSP: u32 = 1048576u32;
8112 pub const CERT_TRUST_SSL_TIME_VALID: u32 = 16777216u32;
8113 pub const CERT_TRUST_SSL_TIME_VALID_OCSP: u32 = 524288u32;
8114 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8115 #[repr(C)]
8116 pub struct CERT_TRUST_STATUS {
8117     pub dwErrorStatus: u32,
8118     pub dwInfoStatus: u32,
8119 }
8120 impl CERT_TRUST_STATUS {}
8121 impl ::std::default::Default for CERT_TRUST_STATUS {
default() -> Self8122     fn default() -> Self {
8123         unsafe { ::std::mem::zeroed() }
8124     }
8125 }
8126 impl ::std::fmt::Debug for CERT_TRUST_STATUS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8127     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8128         fmt.debug_struct("CERT_TRUST_STATUS").field("dwErrorStatus", &self.dwErrorStatus).field("dwInfoStatus", &self.dwInfoStatus).finish()
8129     }
8130 }
8131 impl ::std::cmp::PartialEq for CERT_TRUST_STATUS {
eq(&self, other: &Self) -> bool8132     fn eq(&self, other: &Self) -> bool {
8133         self.dwErrorStatus == other.dwErrorStatus && self.dwInfoStatus == other.dwInfoStatus
8134     }
8135 }
8136 impl ::std::cmp::Eq for CERT_TRUST_STATUS {}
8137 unsafe impl ::windows::runtime::Abi for CERT_TRUST_STATUS {
8138     type Abi = Self;
8139     type DefaultType = Self;
8140 }
8141 pub const CERT_UNICODE_ATTR_ERR_INDEX_MASK: u32 = 63u32;
8142 pub const CERT_UNICODE_ATTR_ERR_INDEX_SHIFT: u32 = 16u32;
8143 pub const CERT_UNICODE_IS_RDN_ATTRS_FLAG: u32 = 1u32;
8144 pub const CERT_UNICODE_RDN_ERR_INDEX_MASK: u32 = 1023u32;
8145 pub const CERT_UNICODE_RDN_ERR_INDEX_SHIFT: u32 = 22u32;
8146 pub const CERT_UNICODE_VALUE_ERR_INDEX_MASK: u32 = 65535u32;
8147 pub const CERT_UNICODE_VALUE_ERR_INDEX_SHIFT: u32 = 0u32;
8148 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8149 #[repr(C)]
8150 #[cfg(feature = "Win32_Foundation")]
8151 pub struct CERT_USAGE_MATCH {
8152     pub dwType: u32,
8153     pub Usage: CTL_USAGE,
8154 }
8155 #[cfg(feature = "Win32_Foundation")]
8156 impl CERT_USAGE_MATCH {}
8157 #[cfg(feature = "Win32_Foundation")]
8158 impl ::std::default::Default for CERT_USAGE_MATCH {
default() -> Self8159     fn default() -> Self {
8160         unsafe { ::std::mem::zeroed() }
8161     }
8162 }
8163 #[cfg(feature = "Win32_Foundation")]
8164 impl ::std::fmt::Debug for CERT_USAGE_MATCH {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8165     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8166         fmt.debug_struct("CERT_USAGE_MATCH").field("dwType", &self.dwType).field("Usage", &self.Usage).finish()
8167     }
8168 }
8169 #[cfg(feature = "Win32_Foundation")]
8170 impl ::std::cmp::PartialEq for CERT_USAGE_MATCH {
eq(&self, other: &Self) -> bool8171     fn eq(&self, other: &Self) -> bool {
8172         self.dwType == other.dwType && self.Usage == other.Usage
8173     }
8174 }
8175 #[cfg(feature = "Win32_Foundation")]
8176 impl ::std::cmp::Eq for CERT_USAGE_MATCH {}
8177 #[cfg(feature = "Win32_Foundation")]
8178 unsafe impl ::windows::runtime::Abi for CERT_USAGE_MATCH {
8179     type Abi = Self;
8180     type DefaultType = Self;
8181 }
8182 pub const CERT_V1: u32 = 0u32;
8183 pub const CERT_V2: u32 = 1u32;
8184 pub const CERT_V3: u32 = 2u32;
8185 pub const CERT_VALIDITY_AFTER_END: u32 = 2u32;
8186 pub const CERT_VALIDITY_BEFORE_START: u32 = 1u32;
8187 pub const CERT_VALIDITY_CERTIFICATE_REVOKED: u32 = 8u32;
8188 pub const CERT_VALIDITY_CRL_OUT_OF_DATE: u32 = 1073741824u32;
8189 pub const CERT_VALIDITY_EXPLICITLY_DISTRUSTED: u32 = 16777216u32;
8190 pub const CERT_VALIDITY_EXTENDED_USAGE_FAILURE: u32 = 32u32;
8191 pub const CERT_VALIDITY_ISSUER_DISTRUST: u32 = 33554432u32;
8192 pub const CERT_VALIDITY_ISSUER_INVALID: u32 = 256u32;
8193 pub const CERT_VALIDITY_KEY_USAGE_EXT_FAILURE: u32 = 16u32;
8194 pub const CERT_VALIDITY_MASK_TRUST: u32 = 4294901760u32;
8195 pub const CERT_VALIDITY_MASK_VALIDITY: u32 = 65535u32;
8196 pub const CERT_VALIDITY_NAME_CONSTRAINTS_FAILURE: u32 = 64u32;
8197 pub const CERT_VALIDITY_NO_CRL_FOUND: u32 = 536870912u32;
8198 pub const CERT_VALIDITY_NO_ISSUER_CERT_FOUND: u32 = 268435456u32;
8199 pub const CERT_VALIDITY_NO_TRUST_DATA: u32 = 2147483648u32;
8200 pub const CERT_VALIDITY_OTHER_ERROR: u32 = 2048u32;
8201 pub const CERT_VALIDITY_OTHER_EXTENSION_FAILURE: u32 = 512u32;
8202 pub const CERT_VALIDITY_PERIOD_NESTING_FAILURE: u32 = 1024u32;
8203 pub const CERT_VALIDITY_SIGNATURE_FAILS: u32 = 4u32;
8204 pub const CERT_VALIDITY_UNKNOWN_CRITICAL_EXTENSION: u32 = 128u32;
8205 pub const CERT_VERIFY_ALLOW_MORE_USAGE_FLAG: u32 = 8u32;
8206 pub const CERT_VERIFY_CACHE_ONLY_BASED_REVOCATION: u32 = 2u32;
8207 #[derive(:: std :: clone :: Clone)]
8208 #[repr(C)]
8209 #[cfg(feature = "Win32_Foundation")]
8210 pub struct CERT_VERIFY_CERTIFICATE_TRUST {
8211     pub cbSize: u32,
8212     pub pccert: *mut CERT_CONTEXT,
8213     pub dwFlags: u32,
8214     pub dwIgnoreErr: u32,
8215     pub pdwErrors: *mut u32,
8216     pub pszUsageOid: super::super::Foundation::PSTR,
8217     pub hprov: usize,
8218     pub cRootStores: u32,
8219     pub rghstoreRoots: *mut *mut ::std::ffi::c_void,
8220     pub cStores: u32,
8221     pub rghstoreCAs: *mut *mut ::std::ffi::c_void,
8222     pub cTrustStores: u32,
8223     pub rghstoreTrust: *mut *mut ::std::ffi::c_void,
8224     pub lCustData: super::super::Foundation::LPARAM,
8225     pub pfnTrustHelper: ::std::option::Option<PFNTRUSTHELPER>,
8226     pub pcChain: *mut u32,
8227     pub prgChain: *mut *mut *mut CERT_CONTEXT,
8228     pub prgdwErrors: *mut *mut u32,
8229     pub prgpbTrustInfo: *mut *mut CRYPTOAPI_BLOB,
8230 }
8231 #[cfg(feature = "Win32_Foundation")]
8232 impl CERT_VERIFY_CERTIFICATE_TRUST {}
8233 #[cfg(feature = "Win32_Foundation")]
8234 impl ::std::default::Default for CERT_VERIFY_CERTIFICATE_TRUST {
default() -> Self8235     fn default() -> Self {
8236         unsafe { ::std::mem::zeroed() }
8237     }
8238 }
8239 #[cfg(feature = "Win32_Foundation")]
8240 impl ::std::fmt::Debug for CERT_VERIFY_CERTIFICATE_TRUST {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8241     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8242         fmt.debug_struct("CERT_VERIFY_CERTIFICATE_TRUST")
8243             .field("cbSize", &self.cbSize)
8244             .field("pccert", &self.pccert)
8245             .field("dwFlags", &self.dwFlags)
8246             .field("dwIgnoreErr", &self.dwIgnoreErr)
8247             .field("pdwErrors", &self.pdwErrors)
8248             .field("pszUsageOid", &self.pszUsageOid)
8249             .field("hprov", &self.hprov)
8250             .field("cRootStores", &self.cRootStores)
8251             .field("rghstoreRoots", &self.rghstoreRoots)
8252             .field("cStores", &self.cStores)
8253             .field("rghstoreCAs", &self.rghstoreCAs)
8254             .field("cTrustStores", &self.cTrustStores)
8255             .field("rghstoreTrust", &self.rghstoreTrust)
8256             .field("lCustData", &self.lCustData)
8257             .field("pcChain", &self.pcChain)
8258             .field("prgChain", &self.prgChain)
8259             .field("prgdwErrors", &self.prgdwErrors)
8260             .field("prgpbTrustInfo", &self.prgpbTrustInfo)
8261             .finish()
8262     }
8263 }
8264 #[cfg(feature = "Win32_Foundation")]
8265 impl ::std::cmp::PartialEq for CERT_VERIFY_CERTIFICATE_TRUST {
eq(&self, other: &Self) -> bool8266     fn eq(&self, other: &Self) -> bool {
8267         self.cbSize == other.cbSize
8268             && self.pccert == other.pccert
8269             && self.dwFlags == other.dwFlags
8270             && self.dwIgnoreErr == other.dwIgnoreErr
8271             && self.pdwErrors == other.pdwErrors
8272             && self.pszUsageOid == other.pszUsageOid
8273             && self.hprov == other.hprov
8274             && self.cRootStores == other.cRootStores
8275             && self.rghstoreRoots == other.rghstoreRoots
8276             && self.cStores == other.cStores
8277             && self.rghstoreCAs == other.rghstoreCAs
8278             && self.cTrustStores == other.cTrustStores
8279             && self.rghstoreTrust == other.rghstoreTrust
8280             && self.lCustData == other.lCustData
8281             && self.pfnTrustHelper.map(|f| f as usize) == other.pfnTrustHelper.map(|f| f as usize)
8282             && self.pcChain == other.pcChain
8283             && self.prgChain == other.prgChain
8284             && self.prgdwErrors == other.prgdwErrors
8285             && self.prgpbTrustInfo == other.prgpbTrustInfo
8286     }
8287 }
8288 #[cfg(feature = "Win32_Foundation")]
8289 impl ::std::cmp::Eq for CERT_VERIFY_CERTIFICATE_TRUST {}
8290 #[cfg(feature = "Win32_Foundation")]
8291 unsafe impl ::windows::runtime::Abi for CERT_VERIFY_CERTIFICATE_TRUST {
8292     type Abi = ::std::mem::ManuallyDrop<Self>;
8293     type DefaultType = Self;
8294 }
8295 pub const CERT_VERIFY_INHIBIT_CTL_UPDATE_FLAG: u32 = 1u32;
8296 pub const CERT_VERIFY_NO_TIME_CHECK_FLAG: u32 = 4u32;
8297 pub const CERT_VERIFY_REV_ACCUMULATIVE_TIMEOUT_FLAG: u32 = 4u32;
8298 pub const CERT_VERIFY_REV_CHAIN_FLAG: u32 = 1u32;
8299 pub const CERT_VERIFY_REV_NO_OCSP_FAILOVER_TO_CRL_FLAG: u32 = 16u32;
8300 pub const CERT_VERIFY_REV_SERVER_OCSP_FLAG: u32 = 8u32;
8301 pub const CERT_VERIFY_REV_SERVER_OCSP_WIRE_ONLY_FLAG: u32 = 32u32;
8302 pub const CERT_VERIFY_TRUSTED_SIGNERS_FLAG: u32 = 2u32;
8303 pub const CERT_VERIFY_UPDATED_CTL_FLAG: u32 = 1u32;
8304 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8305 #[repr(C)]
8306 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_System_SystemServices", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
8307 pub struct CERT_VIEWPROPERTIES_STRUCT_A {
8308     pub dwSize: u32,
8309     pub hwndParent: super::super::Foundation::HWND,
8310     pub hInstance: super::super::Foundation::HINSTANCE,
8311     pub dwFlags: super::super::System::SystemServices::CERT_VIEWPROPERTIES_STRUCT_FLAGS,
8312     pub szTitle: super::super::Foundation::PSTR,
8313     pub pCertContext: *mut CERT_CONTEXT,
8314     pub arrayPurposes: *mut super::super::Foundation::PSTR,
8315     pub cArrayPurposes: u32,
8316     pub cRootStores: u32,
8317     pub rghstoreRoots: *mut *mut ::std::ffi::c_void,
8318     pub cStores: u32,
8319     pub rghstoreCAs: *mut *mut ::std::ffi::c_void,
8320     pub cTrustStores: u32,
8321     pub rghstoreTrust: *mut *mut ::std::ffi::c_void,
8322     pub hprov: usize,
8323     pub lCustData: super::super::Foundation::LPARAM,
8324     pub dwPad: u32,
8325     pub szHelpFileName: super::super::Foundation::PSTR,
8326     pub dwHelpId: u32,
8327     pub nStartPage: u32,
8328     pub cArrayPropSheetPages: u32,
8329     pub arrayPropSheetPages: *mut super::super::UI::Controls::PROPSHEETPAGEA,
8330 }
8331 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_System_SystemServices", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
8332 impl CERT_VIEWPROPERTIES_STRUCT_A {}
8333 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_System_SystemServices", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
8334 impl ::std::default::Default for CERT_VIEWPROPERTIES_STRUCT_A {
default() -> Self8335     fn default() -> Self {
8336         unsafe { ::std::mem::zeroed() }
8337     }
8338 }
8339 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_System_SystemServices", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
8340 impl ::std::fmt::Debug for CERT_VIEWPROPERTIES_STRUCT_A {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8341     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8342         fmt.debug_struct("CERT_VIEWPROPERTIES_STRUCT_A")
8343             .field("dwSize", &self.dwSize)
8344             .field("hwndParent", &self.hwndParent)
8345             .field("hInstance", &self.hInstance)
8346             .field("dwFlags", &self.dwFlags)
8347             .field("szTitle", &self.szTitle)
8348             .field("pCertContext", &self.pCertContext)
8349             .field("arrayPurposes", &self.arrayPurposes)
8350             .field("cArrayPurposes", &self.cArrayPurposes)
8351             .field("cRootStores", &self.cRootStores)
8352             .field("rghstoreRoots", &self.rghstoreRoots)
8353             .field("cStores", &self.cStores)
8354             .field("rghstoreCAs", &self.rghstoreCAs)
8355             .field("cTrustStores", &self.cTrustStores)
8356             .field("rghstoreTrust", &self.rghstoreTrust)
8357             .field("hprov", &self.hprov)
8358             .field("lCustData", &self.lCustData)
8359             .field("dwPad", &self.dwPad)
8360             .field("szHelpFileName", &self.szHelpFileName)
8361             .field("dwHelpId", &self.dwHelpId)
8362             .field("nStartPage", &self.nStartPage)
8363             .field("cArrayPropSheetPages", &self.cArrayPropSheetPages)
8364             .field("arrayPropSheetPages", &self.arrayPropSheetPages)
8365             .finish()
8366     }
8367 }
8368 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_System_SystemServices", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
8369 impl ::std::cmp::PartialEq for CERT_VIEWPROPERTIES_STRUCT_A {
eq(&self, other: &Self) -> bool8370     fn eq(&self, other: &Self) -> bool {
8371         self.dwSize == other.dwSize
8372             && self.hwndParent == other.hwndParent
8373             && self.hInstance == other.hInstance
8374             && self.dwFlags == other.dwFlags
8375             && self.szTitle == other.szTitle
8376             && self.pCertContext == other.pCertContext
8377             && self.arrayPurposes == other.arrayPurposes
8378             && self.cArrayPurposes == other.cArrayPurposes
8379             && self.cRootStores == other.cRootStores
8380             && self.rghstoreRoots == other.rghstoreRoots
8381             && self.cStores == other.cStores
8382             && self.rghstoreCAs == other.rghstoreCAs
8383             && self.cTrustStores == other.cTrustStores
8384             && self.rghstoreTrust == other.rghstoreTrust
8385             && self.hprov == other.hprov
8386             && self.lCustData == other.lCustData
8387             && self.dwPad == other.dwPad
8388             && self.szHelpFileName == other.szHelpFileName
8389             && self.dwHelpId == other.dwHelpId
8390             && self.nStartPage == other.nStartPage
8391             && self.cArrayPropSheetPages == other.cArrayPropSheetPages
8392             && self.arrayPropSheetPages == other.arrayPropSheetPages
8393     }
8394 }
8395 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_System_SystemServices", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
8396 impl ::std::cmp::Eq for CERT_VIEWPROPERTIES_STRUCT_A {}
8397 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_System_SystemServices", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
8398 unsafe impl ::windows::runtime::Abi for CERT_VIEWPROPERTIES_STRUCT_A {
8399     type Abi = Self;
8400     type DefaultType = Self;
8401 }
8402 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8403 #[repr(C)]
8404 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_System_SystemServices", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
8405 pub struct CERT_VIEWPROPERTIES_STRUCT_W {
8406     pub dwSize: u32,
8407     pub hwndParent: super::super::Foundation::HWND,
8408     pub hInstance: super::super::Foundation::HINSTANCE,
8409     pub dwFlags: super::super::System::SystemServices::CERT_VIEWPROPERTIES_STRUCT_FLAGS,
8410     pub szTitle: super::super::Foundation::PWSTR,
8411     pub pCertContext: *mut CERT_CONTEXT,
8412     pub arrayPurposes: *mut super::super::Foundation::PSTR,
8413     pub cArrayPurposes: u32,
8414     pub cRootStores: u32,
8415     pub rghstoreRoots: *mut *mut ::std::ffi::c_void,
8416     pub cStores: u32,
8417     pub rghstoreCAs: *mut *mut ::std::ffi::c_void,
8418     pub cTrustStores: u32,
8419     pub rghstoreTrust: *mut *mut ::std::ffi::c_void,
8420     pub hprov: usize,
8421     pub lCustData: super::super::Foundation::LPARAM,
8422     pub dwPad: u32,
8423     pub szHelpFileName: super::super::Foundation::PWSTR,
8424     pub dwHelpId: u32,
8425     pub nStartPage: u32,
8426     pub cArrayPropSheetPages: u32,
8427     pub arrayPropSheetPages: *mut super::super::UI::Controls::PROPSHEETPAGEA,
8428 }
8429 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_System_SystemServices", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
8430 impl CERT_VIEWPROPERTIES_STRUCT_W {}
8431 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_System_SystemServices", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
8432 impl ::std::default::Default for CERT_VIEWPROPERTIES_STRUCT_W {
default() -> Self8433     fn default() -> Self {
8434         unsafe { ::std::mem::zeroed() }
8435     }
8436 }
8437 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_System_SystemServices", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
8438 impl ::std::fmt::Debug for CERT_VIEWPROPERTIES_STRUCT_W {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8439     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8440         fmt.debug_struct("CERT_VIEWPROPERTIES_STRUCT_W")
8441             .field("dwSize", &self.dwSize)
8442             .field("hwndParent", &self.hwndParent)
8443             .field("hInstance", &self.hInstance)
8444             .field("dwFlags", &self.dwFlags)
8445             .field("szTitle", &self.szTitle)
8446             .field("pCertContext", &self.pCertContext)
8447             .field("arrayPurposes", &self.arrayPurposes)
8448             .field("cArrayPurposes", &self.cArrayPurposes)
8449             .field("cRootStores", &self.cRootStores)
8450             .field("rghstoreRoots", &self.rghstoreRoots)
8451             .field("cStores", &self.cStores)
8452             .field("rghstoreCAs", &self.rghstoreCAs)
8453             .field("cTrustStores", &self.cTrustStores)
8454             .field("rghstoreTrust", &self.rghstoreTrust)
8455             .field("hprov", &self.hprov)
8456             .field("lCustData", &self.lCustData)
8457             .field("dwPad", &self.dwPad)
8458             .field("szHelpFileName", &self.szHelpFileName)
8459             .field("dwHelpId", &self.dwHelpId)
8460             .field("nStartPage", &self.nStartPage)
8461             .field("cArrayPropSheetPages", &self.cArrayPropSheetPages)
8462             .field("arrayPropSheetPages", &self.arrayPropSheetPages)
8463             .finish()
8464     }
8465 }
8466 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_System_SystemServices", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
8467 impl ::std::cmp::PartialEq for CERT_VIEWPROPERTIES_STRUCT_W {
eq(&self, other: &Self) -> bool8468     fn eq(&self, other: &Self) -> bool {
8469         self.dwSize == other.dwSize
8470             && self.hwndParent == other.hwndParent
8471             && self.hInstance == other.hInstance
8472             && self.dwFlags == other.dwFlags
8473             && self.szTitle == other.szTitle
8474             && self.pCertContext == other.pCertContext
8475             && self.arrayPurposes == other.arrayPurposes
8476             && self.cArrayPurposes == other.cArrayPurposes
8477             && self.cRootStores == other.cRootStores
8478             && self.rghstoreRoots == other.rghstoreRoots
8479             && self.cStores == other.cStores
8480             && self.rghstoreCAs == other.rghstoreCAs
8481             && self.cTrustStores == other.cTrustStores
8482             && self.rghstoreTrust == other.rghstoreTrust
8483             && self.hprov == other.hprov
8484             && self.lCustData == other.lCustData
8485             && self.dwPad == other.dwPad
8486             && self.szHelpFileName == other.szHelpFileName
8487             && self.dwHelpId == other.dwHelpId
8488             && self.nStartPage == other.nStartPage
8489             && self.cArrayPropSheetPages == other.cArrayPropSheetPages
8490             && self.arrayPropSheetPages == other.arrayPropSheetPages
8491     }
8492 }
8493 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_System_SystemServices", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
8494 impl ::std::cmp::Eq for CERT_VIEWPROPERTIES_STRUCT_W {}
8495 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_System_SystemServices", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
8496 unsafe impl ::windows::runtime::Abi for CERT_VIEWPROPERTIES_STRUCT_W {
8497     type Abi = Self;
8498     type DefaultType = Self;
8499 }
8500 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8501 #[repr(C)]
8502 pub struct CERT_X942_DH_PARAMETERS {
8503     pub p: CRYPTOAPI_BLOB,
8504     pub g: CRYPTOAPI_BLOB,
8505     pub q: CRYPTOAPI_BLOB,
8506     pub j: CRYPTOAPI_BLOB,
8507     pub pValidationParams: *mut CERT_X942_DH_VALIDATION_PARAMS,
8508 }
8509 impl CERT_X942_DH_PARAMETERS {}
8510 impl ::std::default::Default for CERT_X942_DH_PARAMETERS {
default() -> Self8511     fn default() -> Self {
8512         unsafe { ::std::mem::zeroed() }
8513     }
8514 }
8515 impl ::std::fmt::Debug for CERT_X942_DH_PARAMETERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8516     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8517         fmt.debug_struct("CERT_X942_DH_PARAMETERS").field("p", &self.p).field("g", &self.g).field("q", &self.q).field("j", &self.j).field("pValidationParams", &self.pValidationParams).finish()
8518     }
8519 }
8520 impl ::std::cmp::PartialEq for CERT_X942_DH_PARAMETERS {
eq(&self, other: &Self) -> bool8521     fn eq(&self, other: &Self) -> bool {
8522         self.p == other.p && self.g == other.g && self.q == other.q && self.j == other.j && self.pValidationParams == other.pValidationParams
8523     }
8524 }
8525 impl ::std::cmp::Eq for CERT_X942_DH_PARAMETERS {}
8526 unsafe impl ::windows::runtime::Abi for CERT_X942_DH_PARAMETERS {
8527     type Abi = Self;
8528     type DefaultType = Self;
8529 }
8530 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8531 #[repr(C)]
8532 pub struct CERT_X942_DH_VALIDATION_PARAMS {
8533     pub seed: CRYPT_BIT_BLOB,
8534     pub pgenCounter: u32,
8535 }
8536 impl CERT_X942_DH_VALIDATION_PARAMS {}
8537 impl ::std::default::Default for CERT_X942_DH_VALIDATION_PARAMS {
default() -> Self8538     fn default() -> Self {
8539         unsafe { ::std::mem::zeroed() }
8540     }
8541 }
8542 impl ::std::fmt::Debug for CERT_X942_DH_VALIDATION_PARAMS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8543     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8544         fmt.debug_struct("CERT_X942_DH_VALIDATION_PARAMS").field("seed", &self.seed).field("pgenCounter", &self.pgenCounter).finish()
8545     }
8546 }
8547 impl ::std::cmp::PartialEq for CERT_X942_DH_VALIDATION_PARAMS {
eq(&self, other: &Self) -> bool8548     fn eq(&self, other: &Self) -> bool {
8549         self.seed == other.seed && self.pgenCounter == other.pgenCounter
8550     }
8551 }
8552 impl ::std::cmp::Eq for CERT_X942_DH_VALIDATION_PARAMS {}
8553 unsafe impl ::windows::runtime::Abi for CERT_X942_DH_VALIDATION_PARAMS {
8554     type Abi = Self;
8555     type DefaultType = Self;
8556 }
8557 pub const CERT_XML_NAME_STR: u32 = 4u32;
8558 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8559 #[repr(transparent)]
8560 pub struct CESSetupProperty(pub i32);
8561 pub const ENUM_CESSETUPPROP_USE_IISAPPPOOLIDENTITY: CESSetupProperty = CESSetupProperty(0i32);
8562 pub const ENUM_CESSETUPPROP_CACONFIG: CESSetupProperty = CESSetupProperty(1i32);
8563 pub const ENUM_CESSETUPPROP_AUTHENTICATION: CESSetupProperty = CESSetupProperty(2i32);
8564 pub const ENUM_CESSETUPPROP_SSLCERTHASH: CESSetupProperty = CESSetupProperty(3i32);
8565 pub const ENUM_CESSETUPPROP_URL: CESSetupProperty = CESSetupProperty(4i32);
8566 pub const ENUM_CESSETUPPROP_RENEWALONLY: CESSetupProperty = CESSetupProperty(5i32);
8567 pub const ENUM_CESSETUPPROP_ALLOW_KEYBASED_RENEWAL: CESSetupProperty = CESSetupProperty(6i32);
8568 impl ::std::convert::From<i32> for CESSetupProperty {
from(value: i32) -> Self8569     fn from(value: i32) -> Self {
8570         Self(value)
8571     }
8572 }
8573 unsafe impl ::windows::runtime::Abi for CESSetupProperty {
8574     type Abi = Self;
8575     type DefaultType = Self;
8576 }
8577 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8578 #[repr(C)]
8579 #[cfg(feature = "Win32_Foundation")]
8580 pub struct CLAIMLIST {
8581     pub count: u32,
8582     pub claims: *mut super::super::Foundation::PWSTR,
8583 }
8584 #[cfg(feature = "Win32_Foundation")]
8585 impl CLAIMLIST {}
8586 #[cfg(feature = "Win32_Foundation")]
8587 impl ::std::default::Default for CLAIMLIST {
default() -> Self8588     fn default() -> Self {
8589         unsafe { ::std::mem::zeroed() }
8590     }
8591 }
8592 #[cfg(feature = "Win32_Foundation")]
8593 impl ::std::fmt::Debug for CLAIMLIST {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8594     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8595         fmt.debug_struct("CLAIMLIST").field("count", &self.count).field("claims", &self.claims).finish()
8596     }
8597 }
8598 #[cfg(feature = "Win32_Foundation")]
8599 impl ::std::cmp::PartialEq for CLAIMLIST {
eq(&self, other: &Self) -> bool8600     fn eq(&self, other: &Self) -> bool {
8601         self.count == other.count && self.claims == other.claims
8602     }
8603 }
8604 #[cfg(feature = "Win32_Foundation")]
8605 impl ::std::cmp::Eq for CLAIMLIST {}
8606 #[cfg(feature = "Win32_Foundation")]
8607 unsafe impl ::windows::runtime::Abi for CLAIMLIST {
8608     type Abi = Self;
8609     type DefaultType = Self;
8610 }
8611 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8612 #[repr(C)]
8613 #[cfg(feature = "Win32_Foundation")]
8614 pub struct CMC_ADD_ATTRIBUTES_INFO {
8615     pub dwCmcDataReference: u32,
8616     pub cCertReference: u32,
8617     pub rgdwCertReference: *mut u32,
8618     pub cAttribute: u32,
8619     pub rgAttribute: *mut CRYPT_ATTRIBUTE,
8620 }
8621 #[cfg(feature = "Win32_Foundation")]
8622 impl CMC_ADD_ATTRIBUTES_INFO {}
8623 #[cfg(feature = "Win32_Foundation")]
8624 impl ::std::default::Default for CMC_ADD_ATTRIBUTES_INFO {
default() -> Self8625     fn default() -> Self {
8626         unsafe { ::std::mem::zeroed() }
8627     }
8628 }
8629 #[cfg(feature = "Win32_Foundation")]
8630 impl ::std::fmt::Debug for CMC_ADD_ATTRIBUTES_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8631     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8632         fmt.debug_struct("CMC_ADD_ATTRIBUTES_INFO").field("dwCmcDataReference", &self.dwCmcDataReference).field("cCertReference", &self.cCertReference).field("rgdwCertReference", &self.rgdwCertReference).field("cAttribute", &self.cAttribute).field("rgAttribute", &self.rgAttribute).finish()
8633     }
8634 }
8635 #[cfg(feature = "Win32_Foundation")]
8636 impl ::std::cmp::PartialEq for CMC_ADD_ATTRIBUTES_INFO {
eq(&self, other: &Self) -> bool8637     fn eq(&self, other: &Self) -> bool {
8638         self.dwCmcDataReference == other.dwCmcDataReference && self.cCertReference == other.cCertReference && self.rgdwCertReference == other.rgdwCertReference && self.cAttribute == other.cAttribute && self.rgAttribute == other.rgAttribute
8639     }
8640 }
8641 #[cfg(feature = "Win32_Foundation")]
8642 impl ::std::cmp::Eq for CMC_ADD_ATTRIBUTES_INFO {}
8643 #[cfg(feature = "Win32_Foundation")]
8644 unsafe impl ::windows::runtime::Abi for CMC_ADD_ATTRIBUTES_INFO {
8645     type Abi = Self;
8646     type DefaultType = Self;
8647 }
8648 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8649 #[repr(C)]
8650 #[cfg(feature = "Win32_Foundation")]
8651 pub struct CMC_ADD_EXTENSIONS_INFO {
8652     pub dwCmcDataReference: u32,
8653     pub cCertReference: u32,
8654     pub rgdwCertReference: *mut u32,
8655     pub cExtension: u32,
8656     pub rgExtension: *mut CERT_EXTENSION,
8657 }
8658 #[cfg(feature = "Win32_Foundation")]
8659 impl CMC_ADD_EXTENSIONS_INFO {}
8660 #[cfg(feature = "Win32_Foundation")]
8661 impl ::std::default::Default for CMC_ADD_EXTENSIONS_INFO {
default() -> Self8662     fn default() -> Self {
8663         unsafe { ::std::mem::zeroed() }
8664     }
8665 }
8666 #[cfg(feature = "Win32_Foundation")]
8667 impl ::std::fmt::Debug for CMC_ADD_EXTENSIONS_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8668     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8669         fmt.debug_struct("CMC_ADD_EXTENSIONS_INFO").field("dwCmcDataReference", &self.dwCmcDataReference).field("cCertReference", &self.cCertReference).field("rgdwCertReference", &self.rgdwCertReference).field("cExtension", &self.cExtension).field("rgExtension", &self.rgExtension).finish()
8670     }
8671 }
8672 #[cfg(feature = "Win32_Foundation")]
8673 impl ::std::cmp::PartialEq for CMC_ADD_EXTENSIONS_INFO {
eq(&self, other: &Self) -> bool8674     fn eq(&self, other: &Self) -> bool {
8675         self.dwCmcDataReference == other.dwCmcDataReference && self.cCertReference == other.cCertReference && self.rgdwCertReference == other.rgdwCertReference && self.cExtension == other.cExtension && self.rgExtension == other.rgExtension
8676     }
8677 }
8678 #[cfg(feature = "Win32_Foundation")]
8679 impl ::std::cmp::Eq for CMC_ADD_EXTENSIONS_INFO {}
8680 #[cfg(feature = "Win32_Foundation")]
8681 unsafe impl ::windows::runtime::Abi for CMC_ADD_EXTENSIONS_INFO {
8682     type Abi = Self;
8683     type DefaultType = Self;
8684 }
8685 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8686 #[repr(C)]
8687 #[cfg(feature = "Win32_Foundation")]
8688 pub struct CMC_DATA_INFO {
8689     pub cTaggedAttribute: u32,
8690     pub rgTaggedAttribute: *mut CMC_TAGGED_ATTRIBUTE,
8691     pub cTaggedRequest: u32,
8692     pub rgTaggedRequest: *mut CMC_TAGGED_REQUEST,
8693     pub cTaggedContentInfo: u32,
8694     pub rgTaggedContentInfo: *mut CMC_TAGGED_CONTENT_INFO,
8695     pub cTaggedOtherMsg: u32,
8696     pub rgTaggedOtherMsg: *mut CMC_TAGGED_OTHER_MSG,
8697 }
8698 #[cfg(feature = "Win32_Foundation")]
8699 impl CMC_DATA_INFO {}
8700 #[cfg(feature = "Win32_Foundation")]
8701 impl ::std::default::Default for CMC_DATA_INFO {
default() -> Self8702     fn default() -> Self {
8703         unsafe { ::std::mem::zeroed() }
8704     }
8705 }
8706 #[cfg(feature = "Win32_Foundation")]
8707 impl ::std::fmt::Debug for CMC_DATA_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8708     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8709         fmt.debug_struct("CMC_DATA_INFO")
8710             .field("cTaggedAttribute", &self.cTaggedAttribute)
8711             .field("rgTaggedAttribute", &self.rgTaggedAttribute)
8712             .field("cTaggedRequest", &self.cTaggedRequest)
8713             .field("rgTaggedRequest", &self.rgTaggedRequest)
8714             .field("cTaggedContentInfo", &self.cTaggedContentInfo)
8715             .field("rgTaggedContentInfo", &self.rgTaggedContentInfo)
8716             .field("cTaggedOtherMsg", &self.cTaggedOtherMsg)
8717             .field("rgTaggedOtherMsg", &self.rgTaggedOtherMsg)
8718             .finish()
8719     }
8720 }
8721 #[cfg(feature = "Win32_Foundation")]
8722 impl ::std::cmp::PartialEq for CMC_DATA_INFO {
eq(&self, other: &Self) -> bool8723     fn eq(&self, other: &Self) -> bool {
8724         self.cTaggedAttribute == other.cTaggedAttribute && self.rgTaggedAttribute == other.rgTaggedAttribute && self.cTaggedRequest == other.cTaggedRequest && self.rgTaggedRequest == other.rgTaggedRequest && self.cTaggedContentInfo == other.cTaggedContentInfo && self.rgTaggedContentInfo == other.rgTaggedContentInfo && self.cTaggedOtherMsg == other.cTaggedOtherMsg && self.rgTaggedOtherMsg == other.rgTaggedOtherMsg
8725     }
8726 }
8727 #[cfg(feature = "Win32_Foundation")]
8728 impl ::std::cmp::Eq for CMC_DATA_INFO {}
8729 #[cfg(feature = "Win32_Foundation")]
8730 unsafe impl ::windows::runtime::Abi for CMC_DATA_INFO {
8731     type Abi = Self;
8732     type DefaultType = Self;
8733 }
8734 pub const CMC_FAIL_BAD_ALG: u32 = 0u32;
8735 pub const CMC_FAIL_BAD_CERT_ID: u32 = 4u32;
8736 pub const CMC_FAIL_BAD_IDENTITY: u32 = 7u32;
8737 pub const CMC_FAIL_BAD_MESSAGE_CHECK: u32 = 1u32;
8738 pub const CMC_FAIL_BAD_REQUEST: u32 = 2u32;
8739 pub const CMC_FAIL_BAD_TIME: u32 = 3u32;
8740 pub const CMC_FAIL_INTERNAL_CA_ERROR: u32 = 11u32;
8741 pub const CMC_FAIL_MUST_ARCHIVE_KEYS: u32 = 6u32;
8742 pub const CMC_FAIL_NO_KEY_REUSE: u32 = 10u32;
8743 pub const CMC_FAIL_POP_FAILED: u32 = 9u32;
8744 pub const CMC_FAIL_POP_REQUIRED: u32 = 8u32;
8745 pub const CMC_FAIL_TRY_LATER: u32 = 12u32;
8746 pub const CMC_FAIL_UNSUPORTED_EXT: u32 = 5u32;
8747 pub const CMC_OTHER_INFO_FAIL_CHOICE: u32 = 1u32;
8748 pub const CMC_OTHER_INFO_NO_CHOICE: u32 = 0u32;
8749 pub const CMC_OTHER_INFO_PEND_CHOICE: u32 = 2u32;
8750 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8751 #[repr(C)]
8752 #[cfg(feature = "Win32_Foundation")]
8753 pub struct CMC_PEND_INFO {
8754     pub PendToken: CRYPTOAPI_BLOB,
8755     pub PendTime: super::super::Foundation::FILETIME,
8756 }
8757 #[cfg(feature = "Win32_Foundation")]
8758 impl CMC_PEND_INFO {}
8759 #[cfg(feature = "Win32_Foundation")]
8760 impl ::std::default::Default for CMC_PEND_INFO {
default() -> Self8761     fn default() -> Self {
8762         unsafe { ::std::mem::zeroed() }
8763     }
8764 }
8765 #[cfg(feature = "Win32_Foundation")]
8766 impl ::std::fmt::Debug for CMC_PEND_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8767     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8768         fmt.debug_struct("CMC_PEND_INFO").field("PendToken", &self.PendToken).field("PendTime", &self.PendTime).finish()
8769     }
8770 }
8771 #[cfg(feature = "Win32_Foundation")]
8772 impl ::std::cmp::PartialEq for CMC_PEND_INFO {
eq(&self, other: &Self) -> bool8773     fn eq(&self, other: &Self) -> bool {
8774         self.PendToken == other.PendToken && self.PendTime == other.PendTime
8775     }
8776 }
8777 #[cfg(feature = "Win32_Foundation")]
8778 impl ::std::cmp::Eq for CMC_PEND_INFO {}
8779 #[cfg(feature = "Win32_Foundation")]
8780 unsafe impl ::windows::runtime::Abi for CMC_PEND_INFO {
8781     type Abi = Self;
8782     type DefaultType = Self;
8783 }
8784 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8785 #[repr(C)]
8786 #[cfg(feature = "Win32_Foundation")]
8787 pub struct CMC_RESPONSE_INFO {
8788     pub cTaggedAttribute: u32,
8789     pub rgTaggedAttribute: *mut CMC_TAGGED_ATTRIBUTE,
8790     pub cTaggedContentInfo: u32,
8791     pub rgTaggedContentInfo: *mut CMC_TAGGED_CONTENT_INFO,
8792     pub cTaggedOtherMsg: u32,
8793     pub rgTaggedOtherMsg: *mut CMC_TAGGED_OTHER_MSG,
8794 }
8795 #[cfg(feature = "Win32_Foundation")]
8796 impl CMC_RESPONSE_INFO {}
8797 #[cfg(feature = "Win32_Foundation")]
8798 impl ::std::default::Default for CMC_RESPONSE_INFO {
default() -> Self8799     fn default() -> Self {
8800         unsafe { ::std::mem::zeroed() }
8801     }
8802 }
8803 #[cfg(feature = "Win32_Foundation")]
8804 impl ::std::fmt::Debug for CMC_RESPONSE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8805     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8806         fmt.debug_struct("CMC_RESPONSE_INFO")
8807             .field("cTaggedAttribute", &self.cTaggedAttribute)
8808             .field("rgTaggedAttribute", &self.rgTaggedAttribute)
8809             .field("cTaggedContentInfo", &self.cTaggedContentInfo)
8810             .field("rgTaggedContentInfo", &self.rgTaggedContentInfo)
8811             .field("cTaggedOtherMsg", &self.cTaggedOtherMsg)
8812             .field("rgTaggedOtherMsg", &self.rgTaggedOtherMsg)
8813             .finish()
8814     }
8815 }
8816 #[cfg(feature = "Win32_Foundation")]
8817 impl ::std::cmp::PartialEq for CMC_RESPONSE_INFO {
eq(&self, other: &Self) -> bool8818     fn eq(&self, other: &Self) -> bool {
8819         self.cTaggedAttribute == other.cTaggedAttribute && self.rgTaggedAttribute == other.rgTaggedAttribute && self.cTaggedContentInfo == other.cTaggedContentInfo && self.rgTaggedContentInfo == other.rgTaggedContentInfo && self.cTaggedOtherMsg == other.cTaggedOtherMsg && self.rgTaggedOtherMsg == other.rgTaggedOtherMsg
8820     }
8821 }
8822 #[cfg(feature = "Win32_Foundation")]
8823 impl ::std::cmp::Eq for CMC_RESPONSE_INFO {}
8824 #[cfg(feature = "Win32_Foundation")]
8825 unsafe impl ::windows::runtime::Abi for CMC_RESPONSE_INFO {
8826     type Abi = Self;
8827     type DefaultType = Self;
8828 }
8829 pub const CMC_STATUS_CONFIRM_REQUIRED: u32 = 5u32;
8830 pub const CMC_STATUS_FAILED: u32 = 2u32;
8831 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8832 #[repr(C)]
8833 #[cfg(feature = "Win32_Foundation")]
8834 pub struct CMC_STATUS_INFO {
8835     pub dwStatus: u32,
8836     pub cBodyList: u32,
8837     pub rgdwBodyList: *mut u32,
8838     pub pwszStatusString: super::super::Foundation::PWSTR,
8839     pub dwOtherInfoChoice: u32,
8840     pub Anonymous: CMC_STATUS_INFO_0,
8841 }
8842 #[cfg(feature = "Win32_Foundation")]
8843 impl CMC_STATUS_INFO {}
8844 #[cfg(feature = "Win32_Foundation")]
8845 impl ::std::default::Default for CMC_STATUS_INFO {
default() -> Self8846     fn default() -> Self {
8847         unsafe { ::std::mem::zeroed() }
8848     }
8849 }
8850 #[cfg(feature = "Win32_Foundation")]
8851 impl ::std::cmp::PartialEq for CMC_STATUS_INFO {
eq(&self, _other: &Self) -> bool8852     fn eq(&self, _other: &Self) -> bool {
8853         unimplemented!()
8854     }
8855 }
8856 #[cfg(feature = "Win32_Foundation")]
8857 impl ::std::cmp::Eq for CMC_STATUS_INFO {}
8858 #[cfg(feature = "Win32_Foundation")]
8859 unsafe impl ::windows::runtime::Abi for CMC_STATUS_INFO {
8860     type Abi = Self;
8861     type DefaultType = Self;
8862 }
8863 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8864 #[repr(C)]
8865 #[cfg(feature = "Win32_Foundation")]
8866 pub union CMC_STATUS_INFO_0 {
8867     pub dwFailInfo: u32,
8868     pub pPendInfo: *mut CMC_PEND_INFO,
8869 }
8870 #[cfg(feature = "Win32_Foundation")]
8871 impl CMC_STATUS_INFO_0 {}
8872 #[cfg(feature = "Win32_Foundation")]
8873 impl ::std::default::Default for CMC_STATUS_INFO_0 {
default() -> Self8874     fn default() -> Self {
8875         unsafe { ::std::mem::zeroed() }
8876     }
8877 }
8878 #[cfg(feature = "Win32_Foundation")]
8879 impl ::std::cmp::PartialEq for CMC_STATUS_INFO_0 {
eq(&self, _other: &Self) -> bool8880     fn eq(&self, _other: &Self) -> bool {
8881         unimplemented!()
8882     }
8883 }
8884 #[cfg(feature = "Win32_Foundation")]
8885 impl ::std::cmp::Eq for CMC_STATUS_INFO_0 {}
8886 #[cfg(feature = "Win32_Foundation")]
8887 unsafe impl ::windows::runtime::Abi for CMC_STATUS_INFO_0 {
8888     type Abi = Self;
8889     type DefaultType = Self;
8890 }
8891 pub const CMC_STATUS_NO_SUPPORT: u32 = 4u32;
8892 pub const CMC_STATUS_PENDING: u32 = 3u32;
8893 pub const CMC_STATUS_SUCCESS: u32 = 0u32;
8894 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8895 #[repr(C)]
8896 #[cfg(feature = "Win32_Foundation")]
8897 pub struct CMC_TAGGED_ATTRIBUTE {
8898     pub dwBodyPartID: u32,
8899     pub Attribute: CRYPT_ATTRIBUTE,
8900 }
8901 #[cfg(feature = "Win32_Foundation")]
8902 impl CMC_TAGGED_ATTRIBUTE {}
8903 #[cfg(feature = "Win32_Foundation")]
8904 impl ::std::default::Default for CMC_TAGGED_ATTRIBUTE {
default() -> Self8905     fn default() -> Self {
8906         unsafe { ::std::mem::zeroed() }
8907     }
8908 }
8909 #[cfg(feature = "Win32_Foundation")]
8910 impl ::std::fmt::Debug for CMC_TAGGED_ATTRIBUTE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8911     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8912         fmt.debug_struct("CMC_TAGGED_ATTRIBUTE").field("dwBodyPartID", &self.dwBodyPartID).field("Attribute", &self.Attribute).finish()
8913     }
8914 }
8915 #[cfg(feature = "Win32_Foundation")]
8916 impl ::std::cmp::PartialEq for CMC_TAGGED_ATTRIBUTE {
eq(&self, other: &Self) -> bool8917     fn eq(&self, other: &Self) -> bool {
8918         self.dwBodyPartID == other.dwBodyPartID && self.Attribute == other.Attribute
8919     }
8920 }
8921 #[cfg(feature = "Win32_Foundation")]
8922 impl ::std::cmp::Eq for CMC_TAGGED_ATTRIBUTE {}
8923 #[cfg(feature = "Win32_Foundation")]
8924 unsafe impl ::windows::runtime::Abi for CMC_TAGGED_ATTRIBUTE {
8925     type Abi = Self;
8926     type DefaultType = Self;
8927 }
8928 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8929 #[repr(C)]
8930 pub struct CMC_TAGGED_CERT_REQUEST {
8931     pub dwBodyPartID: u32,
8932     pub SignedCertRequest: CRYPTOAPI_BLOB,
8933 }
8934 impl CMC_TAGGED_CERT_REQUEST {}
8935 impl ::std::default::Default for CMC_TAGGED_CERT_REQUEST {
default() -> Self8936     fn default() -> Self {
8937         unsafe { ::std::mem::zeroed() }
8938     }
8939 }
8940 impl ::std::fmt::Debug for CMC_TAGGED_CERT_REQUEST {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8941     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8942         fmt.debug_struct("CMC_TAGGED_CERT_REQUEST").field("dwBodyPartID", &self.dwBodyPartID).field("SignedCertRequest", &self.SignedCertRequest).finish()
8943     }
8944 }
8945 impl ::std::cmp::PartialEq for CMC_TAGGED_CERT_REQUEST {
eq(&self, other: &Self) -> bool8946     fn eq(&self, other: &Self) -> bool {
8947         self.dwBodyPartID == other.dwBodyPartID && self.SignedCertRequest == other.SignedCertRequest
8948     }
8949 }
8950 impl ::std::cmp::Eq for CMC_TAGGED_CERT_REQUEST {}
8951 unsafe impl ::windows::runtime::Abi for CMC_TAGGED_CERT_REQUEST {
8952     type Abi = Self;
8953     type DefaultType = Self;
8954 }
8955 pub const CMC_TAGGED_CERT_REQUEST_CHOICE: u32 = 1u32;
8956 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8957 #[repr(C)]
8958 pub struct CMC_TAGGED_CONTENT_INFO {
8959     pub dwBodyPartID: u32,
8960     pub EncodedContentInfo: CRYPTOAPI_BLOB,
8961 }
8962 impl CMC_TAGGED_CONTENT_INFO {}
8963 impl ::std::default::Default for CMC_TAGGED_CONTENT_INFO {
default() -> Self8964     fn default() -> Self {
8965         unsafe { ::std::mem::zeroed() }
8966     }
8967 }
8968 impl ::std::fmt::Debug for CMC_TAGGED_CONTENT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8969     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8970         fmt.debug_struct("CMC_TAGGED_CONTENT_INFO").field("dwBodyPartID", &self.dwBodyPartID).field("EncodedContentInfo", &self.EncodedContentInfo).finish()
8971     }
8972 }
8973 impl ::std::cmp::PartialEq for CMC_TAGGED_CONTENT_INFO {
eq(&self, other: &Self) -> bool8974     fn eq(&self, other: &Self) -> bool {
8975         self.dwBodyPartID == other.dwBodyPartID && self.EncodedContentInfo == other.EncodedContentInfo
8976     }
8977 }
8978 impl ::std::cmp::Eq for CMC_TAGGED_CONTENT_INFO {}
8979 unsafe impl ::windows::runtime::Abi for CMC_TAGGED_CONTENT_INFO {
8980     type Abi = Self;
8981     type DefaultType = Self;
8982 }
8983 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8984 #[repr(C)]
8985 #[cfg(feature = "Win32_Foundation")]
8986 pub struct CMC_TAGGED_OTHER_MSG {
8987     pub dwBodyPartID: u32,
8988     pub pszObjId: super::super::Foundation::PSTR,
8989     pub Value: CRYPTOAPI_BLOB,
8990 }
8991 #[cfg(feature = "Win32_Foundation")]
8992 impl CMC_TAGGED_OTHER_MSG {}
8993 #[cfg(feature = "Win32_Foundation")]
8994 impl ::std::default::Default for CMC_TAGGED_OTHER_MSG {
default() -> Self8995     fn default() -> Self {
8996         unsafe { ::std::mem::zeroed() }
8997     }
8998 }
8999 #[cfg(feature = "Win32_Foundation")]
9000 impl ::std::fmt::Debug for CMC_TAGGED_OTHER_MSG {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9001     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9002         fmt.debug_struct("CMC_TAGGED_OTHER_MSG").field("dwBodyPartID", &self.dwBodyPartID).field("pszObjId", &self.pszObjId).field("Value", &self.Value).finish()
9003     }
9004 }
9005 #[cfg(feature = "Win32_Foundation")]
9006 impl ::std::cmp::PartialEq for CMC_TAGGED_OTHER_MSG {
eq(&self, other: &Self) -> bool9007     fn eq(&self, other: &Self) -> bool {
9008         self.dwBodyPartID == other.dwBodyPartID && self.pszObjId == other.pszObjId && self.Value == other.Value
9009     }
9010 }
9011 #[cfg(feature = "Win32_Foundation")]
9012 impl ::std::cmp::Eq for CMC_TAGGED_OTHER_MSG {}
9013 #[cfg(feature = "Win32_Foundation")]
9014 unsafe impl ::windows::runtime::Abi for CMC_TAGGED_OTHER_MSG {
9015     type Abi = Self;
9016     type DefaultType = Self;
9017 }
9018 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9019 #[repr(C)]
9020 pub struct CMC_TAGGED_REQUEST {
9021     pub dwTaggedRequestChoice: u32,
9022     pub Anonymous: CMC_TAGGED_REQUEST_0,
9023 }
9024 impl CMC_TAGGED_REQUEST {}
9025 impl ::std::default::Default for CMC_TAGGED_REQUEST {
default() -> Self9026     fn default() -> Self {
9027         unsafe { ::std::mem::zeroed() }
9028     }
9029 }
9030 impl ::std::cmp::PartialEq for CMC_TAGGED_REQUEST {
eq(&self, _other: &Self) -> bool9031     fn eq(&self, _other: &Self) -> bool {
9032         unimplemented!()
9033     }
9034 }
9035 impl ::std::cmp::Eq for CMC_TAGGED_REQUEST {}
9036 unsafe impl ::windows::runtime::Abi for CMC_TAGGED_REQUEST {
9037     type Abi = Self;
9038     type DefaultType = Self;
9039 }
9040 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9041 #[repr(C)]
9042 pub union CMC_TAGGED_REQUEST_0 {
9043     pub pTaggedCertRequest: *mut CMC_TAGGED_CERT_REQUEST,
9044 }
9045 impl CMC_TAGGED_REQUEST_0 {}
9046 impl ::std::default::Default for CMC_TAGGED_REQUEST_0 {
default() -> Self9047     fn default() -> Self {
9048         unsafe { ::std::mem::zeroed() }
9049     }
9050 }
9051 impl ::std::cmp::PartialEq for CMC_TAGGED_REQUEST_0 {
eq(&self, _other: &Self) -> bool9052     fn eq(&self, _other: &Self) -> bool {
9053         unimplemented!()
9054     }
9055 }
9056 impl ::std::cmp::Eq for CMC_TAGGED_REQUEST_0 {}
9057 unsafe impl ::windows::runtime::Abi for CMC_TAGGED_REQUEST_0 {
9058     type Abi = Self;
9059     type DefaultType = Self;
9060 }
9061 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9062 #[repr(C)]
9063 #[cfg(feature = "Win32_Foundation")]
9064 pub struct CMFLTR {
9065     pub dwSize: u32,
9066     pub cExtensionChecks: u32,
9067     pub arrayExtensionChecks: *mut CMOID,
9068     pub dwCheckingFlags: u32,
9069 }
9070 #[cfg(feature = "Win32_Foundation")]
9071 impl CMFLTR {}
9072 #[cfg(feature = "Win32_Foundation")]
9073 impl ::std::default::Default for CMFLTR {
default() -> Self9074     fn default() -> Self {
9075         unsafe { ::std::mem::zeroed() }
9076     }
9077 }
9078 #[cfg(feature = "Win32_Foundation")]
9079 impl ::std::fmt::Debug for CMFLTR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9080     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9081         fmt.debug_struct("CMFLTR").field("dwSize", &self.dwSize).field("cExtensionChecks", &self.cExtensionChecks).field("arrayExtensionChecks", &self.arrayExtensionChecks).field("dwCheckingFlags", &self.dwCheckingFlags).finish()
9082     }
9083 }
9084 #[cfg(feature = "Win32_Foundation")]
9085 impl ::std::cmp::PartialEq for CMFLTR {
eq(&self, other: &Self) -> bool9086     fn eq(&self, other: &Self) -> bool {
9087         self.dwSize == other.dwSize && self.cExtensionChecks == other.cExtensionChecks && self.arrayExtensionChecks == other.arrayExtensionChecks && self.dwCheckingFlags == other.dwCheckingFlags
9088     }
9089 }
9090 #[cfg(feature = "Win32_Foundation")]
9091 impl ::std::cmp::Eq for CMFLTR {}
9092 #[cfg(feature = "Win32_Foundation")]
9093 unsafe impl ::windows::runtime::Abi for CMFLTR {
9094     type Abi = Self;
9095     type DefaultType = Self;
9096 }
9097 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9098 #[repr(C)]
9099 #[cfg(feature = "Win32_Foundation")]
9100 pub struct CMOID {
9101     pub szExtensionOID: super::super::Foundation::PSTR,
9102     pub dwTestOperation: u32,
9103     pub pbTestData: *mut u8,
9104     pub cbTestData: u32,
9105 }
9106 #[cfg(feature = "Win32_Foundation")]
9107 impl CMOID {}
9108 #[cfg(feature = "Win32_Foundation")]
9109 impl ::std::default::Default for CMOID {
default() -> Self9110     fn default() -> Self {
9111         unsafe { ::std::mem::zeroed() }
9112     }
9113 }
9114 #[cfg(feature = "Win32_Foundation")]
9115 impl ::std::fmt::Debug for CMOID {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9116     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9117         fmt.debug_struct("CMOID").field("szExtensionOID", &self.szExtensionOID).field("dwTestOperation", &self.dwTestOperation).field("pbTestData", &self.pbTestData).field("cbTestData", &self.cbTestData).finish()
9118     }
9119 }
9120 #[cfg(feature = "Win32_Foundation")]
9121 impl ::std::cmp::PartialEq for CMOID {
eq(&self, other: &Self) -> bool9122     fn eq(&self, other: &Self) -> bool {
9123         self.szExtensionOID == other.szExtensionOID && self.dwTestOperation == other.dwTestOperation && self.pbTestData == other.pbTestData && self.cbTestData == other.cbTestData
9124     }
9125 }
9126 #[cfg(feature = "Win32_Foundation")]
9127 impl ::std::cmp::Eq for CMOID {}
9128 #[cfg(feature = "Win32_Foundation")]
9129 unsafe impl ::windows::runtime::Abi for CMOID {
9130     type Abi = Self;
9131     type DefaultType = Self;
9132 }
9133 pub const CMSCEPSetup: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2857327618, 36476, 18884, [148, 250, 103, 165, 204, 94, 173, 180]);
9134 pub const CMSG_ATTR_CERT_COUNT_PARAM: u32 = 31u32;
9135 pub const CMSG_ATTR_CERT_PARAM: u32 = 32u32;
9136 pub const CMSG_AUTHENTICATED_ATTRIBUTES_FLAG: u32 = 8u32;
9137 pub const CMSG_BARE_CONTENT_FLAG: u32 = 1u32;
9138 pub const CMSG_BARE_CONTENT_PARAM: u32 = 3u32;
9139 pub const CMSG_CERT_COUNT_PARAM: u32 = 11u32;
9140 pub const CMSG_CERT_PARAM: u32 = 12u32;
9141 pub const CMSG_CMS_ENCAPSULATED_CONTENT_FLAG: u32 = 64u32;
9142 pub const CMSG_CMS_ENCAPSULATED_CTL_FLAG: u32 = 32768u32;
9143 pub const CMSG_CMS_RECIPIENT_COUNT_PARAM: u32 = 33u32;
9144 pub const CMSG_CMS_RECIPIENT_ENCRYPTED_KEY_INDEX_PARAM: u32 = 35u32;
9145 pub const CMSG_CMS_RECIPIENT_INDEX_PARAM: u32 = 34u32;
9146 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9147 #[repr(C)]
9148 #[cfg(feature = "Win32_Foundation")]
9149 pub struct CMSG_CMS_RECIPIENT_INFO {
9150     pub dwRecipientChoice: u32,
9151     pub Anonymous: CMSG_CMS_RECIPIENT_INFO_0,
9152 }
9153 #[cfg(feature = "Win32_Foundation")]
9154 impl CMSG_CMS_RECIPIENT_INFO {}
9155 #[cfg(feature = "Win32_Foundation")]
9156 impl ::std::default::Default for CMSG_CMS_RECIPIENT_INFO {
default() -> Self9157     fn default() -> Self {
9158         unsafe { ::std::mem::zeroed() }
9159     }
9160 }
9161 #[cfg(feature = "Win32_Foundation")]
9162 impl ::std::cmp::PartialEq for CMSG_CMS_RECIPIENT_INFO {
eq(&self, _other: &Self) -> bool9163     fn eq(&self, _other: &Self) -> bool {
9164         unimplemented!()
9165     }
9166 }
9167 #[cfg(feature = "Win32_Foundation")]
9168 impl ::std::cmp::Eq for CMSG_CMS_RECIPIENT_INFO {}
9169 #[cfg(feature = "Win32_Foundation")]
9170 unsafe impl ::windows::runtime::Abi for CMSG_CMS_RECIPIENT_INFO {
9171     type Abi = Self;
9172     type DefaultType = Self;
9173 }
9174 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9175 #[repr(C)]
9176 #[cfg(feature = "Win32_Foundation")]
9177 pub union CMSG_CMS_RECIPIENT_INFO_0 {
9178     pub pKeyTrans: *mut CMSG_KEY_TRANS_RECIPIENT_INFO,
9179     pub pKeyAgree: *mut CMSG_KEY_AGREE_RECIPIENT_INFO,
9180     pub pMailList: *mut CMSG_MAIL_LIST_RECIPIENT_INFO,
9181 }
9182 #[cfg(feature = "Win32_Foundation")]
9183 impl CMSG_CMS_RECIPIENT_INFO_0 {}
9184 #[cfg(feature = "Win32_Foundation")]
9185 impl ::std::default::Default for CMSG_CMS_RECIPIENT_INFO_0 {
default() -> Self9186     fn default() -> Self {
9187         unsafe { ::std::mem::zeroed() }
9188     }
9189 }
9190 #[cfg(feature = "Win32_Foundation")]
9191 impl ::std::cmp::PartialEq for CMSG_CMS_RECIPIENT_INFO_0 {
eq(&self, _other: &Self) -> bool9192     fn eq(&self, _other: &Self) -> bool {
9193         unimplemented!()
9194     }
9195 }
9196 #[cfg(feature = "Win32_Foundation")]
9197 impl ::std::cmp::Eq for CMSG_CMS_RECIPIENT_INFO_0 {}
9198 #[cfg(feature = "Win32_Foundation")]
9199 unsafe impl ::windows::runtime::Abi for CMSG_CMS_RECIPIENT_INFO_0 {
9200     type Abi = Self;
9201     type DefaultType = Self;
9202 }
9203 pub const CMSG_CMS_RECIPIENT_INFO_PARAM: u32 = 36u32;
9204 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9205 #[repr(C)]
9206 #[cfg(feature = "Win32_Foundation")]
9207 pub struct CMSG_CMS_SIGNER_INFO {
9208     pub dwVersion: u32,
9209     pub SignerId: CERT_ID,
9210     pub HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
9211     pub HashEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
9212     pub EncryptedHash: CRYPTOAPI_BLOB,
9213     pub AuthAttrs: CRYPT_ATTRIBUTES,
9214     pub UnauthAttrs: CRYPT_ATTRIBUTES,
9215 }
9216 #[cfg(feature = "Win32_Foundation")]
9217 impl CMSG_CMS_SIGNER_INFO {}
9218 #[cfg(feature = "Win32_Foundation")]
9219 impl ::std::default::Default for CMSG_CMS_SIGNER_INFO {
default() -> Self9220     fn default() -> Self {
9221         unsafe { ::std::mem::zeroed() }
9222     }
9223 }
9224 #[cfg(feature = "Win32_Foundation")]
9225 impl ::std::cmp::PartialEq for CMSG_CMS_SIGNER_INFO {
eq(&self, _other: &Self) -> bool9226     fn eq(&self, _other: &Self) -> bool {
9227         unimplemented!()
9228     }
9229 }
9230 #[cfg(feature = "Win32_Foundation")]
9231 impl ::std::cmp::Eq for CMSG_CMS_SIGNER_INFO {}
9232 #[cfg(feature = "Win32_Foundation")]
9233 unsafe impl ::windows::runtime::Abi for CMSG_CMS_SIGNER_INFO {
9234     type Abi = Self;
9235     type DefaultType = Self;
9236 }
9237 pub const CMSG_CMS_SIGNER_INFO_PARAM: u32 = 39u32;
9238 #[derive(:: std :: clone :: Clone)]
9239 #[repr(C)]
9240 #[cfg(feature = "Win32_Foundation")]
9241 pub struct CMSG_CNG_CONTENT_DECRYPT_INFO {
9242     pub cbSize: u32,
9243     pub ContentEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
9244     pub pfnAlloc: ::std::option::Option<PFN_CMSG_ALLOC>,
9245     pub pfnFree: ::std::option::Option<PFN_CMSG_FREE>,
9246     pub hNCryptKey: usize,
9247     pub pbContentEncryptKey: *mut u8,
9248     pub cbContentEncryptKey: u32,
9249     pub hCNGContentEncryptKey: BCRYPT_KEY_HANDLE,
9250     pub pbCNGContentEncryptKeyObject: *mut u8,
9251 }
9252 #[cfg(feature = "Win32_Foundation")]
9253 impl CMSG_CNG_CONTENT_DECRYPT_INFO {}
9254 #[cfg(feature = "Win32_Foundation")]
9255 impl ::std::default::Default for CMSG_CNG_CONTENT_DECRYPT_INFO {
default() -> Self9256     fn default() -> Self {
9257         unsafe { ::std::mem::zeroed() }
9258     }
9259 }
9260 #[cfg(feature = "Win32_Foundation")]
9261 impl ::std::fmt::Debug for CMSG_CNG_CONTENT_DECRYPT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9262     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9263         fmt.debug_struct("CMSG_CNG_CONTENT_DECRYPT_INFO")
9264             .field("cbSize", &self.cbSize)
9265             .field("ContentEncryptionAlgorithm", &self.ContentEncryptionAlgorithm)
9266             .field("hNCryptKey", &self.hNCryptKey)
9267             .field("pbContentEncryptKey", &self.pbContentEncryptKey)
9268             .field("cbContentEncryptKey", &self.cbContentEncryptKey)
9269             .field("hCNGContentEncryptKey", &self.hCNGContentEncryptKey)
9270             .field("pbCNGContentEncryptKeyObject", &self.pbCNGContentEncryptKeyObject)
9271             .finish()
9272     }
9273 }
9274 #[cfg(feature = "Win32_Foundation")]
9275 impl ::std::cmp::PartialEq for CMSG_CNG_CONTENT_DECRYPT_INFO {
eq(&self, other: &Self) -> bool9276     fn eq(&self, other: &Self) -> bool {
9277         self.cbSize == other.cbSize
9278             && self.ContentEncryptionAlgorithm == other.ContentEncryptionAlgorithm
9279             && self.pfnAlloc.map(|f| f as usize) == other.pfnAlloc.map(|f| f as usize)
9280             && self.pfnFree.map(|f| f as usize) == other.pfnFree.map(|f| f as usize)
9281             && self.hNCryptKey == other.hNCryptKey
9282             && self.pbContentEncryptKey == other.pbContentEncryptKey
9283             && self.cbContentEncryptKey == other.cbContentEncryptKey
9284             && self.hCNGContentEncryptKey == other.hCNGContentEncryptKey
9285             && self.pbCNGContentEncryptKeyObject == other.pbCNGContentEncryptKeyObject
9286     }
9287 }
9288 #[cfg(feature = "Win32_Foundation")]
9289 impl ::std::cmp::Eq for CMSG_CNG_CONTENT_DECRYPT_INFO {}
9290 #[cfg(feature = "Win32_Foundation")]
9291 unsafe impl ::windows::runtime::Abi for CMSG_CNG_CONTENT_DECRYPT_INFO {
9292     type Abi = ::std::mem::ManuallyDrop<Self>;
9293     type DefaultType = Self;
9294 }
9295 pub const CMSG_COMPUTED_HASH_PARAM: u32 = 22u32;
9296 pub const CMSG_CONTENTS_OCTETS_FLAG: u32 = 16u32;
9297 pub const CMSG_CONTENT_ENCRYPT_FREE_OBJID_FLAG: u32 = 2u32;
9298 pub const CMSG_CONTENT_ENCRYPT_FREE_PARA_FLAG: u32 = 1u32;
9299 #[cfg(feature = "Win32_Foundation")]
9300 impl ::std::clone::Clone for CMSG_CONTENT_ENCRYPT_INFO {
clone(&self) -> Self9301     fn clone(&self) -> Self {
9302         unimplemented!()
9303     }
9304 }
9305 #[repr(C)]
9306 #[cfg(feature = "Win32_Foundation")]
9307 pub struct CMSG_CONTENT_ENCRYPT_INFO {
9308     pub cbSize: u32,
9309     pub hCryptProv: usize,
9310     pub ContentEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
9311     pub pvEncryptionAuxInfo: *mut ::std::ffi::c_void,
9312     pub cRecipients: u32,
9313     pub rgCmsRecipients: *mut CMSG_RECIPIENT_ENCODE_INFO,
9314     pub pfnAlloc: ::std::option::Option<PFN_CMSG_ALLOC>,
9315     pub pfnFree: ::std::option::Option<PFN_CMSG_FREE>,
9316     pub dwEncryptFlags: u32,
9317     pub Anonymous: CMSG_CONTENT_ENCRYPT_INFO_0,
9318     pub dwFlags: u32,
9319     pub fCNG: super::super::Foundation::BOOL,
9320     pub pbCNGContentEncryptKeyObject: *mut u8,
9321     pub pbContentEncryptKey: *mut u8,
9322     pub cbContentEncryptKey: u32,
9323 }
9324 #[cfg(feature = "Win32_Foundation")]
9325 impl CMSG_CONTENT_ENCRYPT_INFO {}
9326 #[cfg(feature = "Win32_Foundation")]
9327 impl ::std::default::Default for CMSG_CONTENT_ENCRYPT_INFO {
default() -> Self9328     fn default() -> Self {
9329         unsafe { ::std::mem::zeroed() }
9330     }
9331 }
9332 #[cfg(feature = "Win32_Foundation")]
9333 impl ::std::cmp::PartialEq for CMSG_CONTENT_ENCRYPT_INFO {
eq(&self, _other: &Self) -> bool9334     fn eq(&self, _other: &Self) -> bool {
9335         unimplemented!()
9336     }
9337 }
9338 #[cfg(feature = "Win32_Foundation")]
9339 impl ::std::cmp::Eq for CMSG_CONTENT_ENCRYPT_INFO {}
9340 #[cfg(feature = "Win32_Foundation")]
9341 unsafe impl ::windows::runtime::Abi for CMSG_CONTENT_ENCRYPT_INFO {
9342     type Abi = ::std::mem::ManuallyDrop<Self>;
9343     type DefaultType = Self;
9344 }
9345 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9346 #[repr(C)]
9347 pub union CMSG_CONTENT_ENCRYPT_INFO_0 {
9348     pub hContentEncryptKey: usize,
9349     pub hCNGContentEncryptKey: BCRYPT_KEY_HANDLE,
9350 }
9351 impl CMSG_CONTENT_ENCRYPT_INFO_0 {}
9352 impl ::std::default::Default for CMSG_CONTENT_ENCRYPT_INFO_0 {
default() -> Self9353     fn default() -> Self {
9354         unsafe { ::std::mem::zeroed() }
9355     }
9356 }
9357 impl ::std::cmp::PartialEq for CMSG_CONTENT_ENCRYPT_INFO_0 {
eq(&self, _other: &Self) -> bool9358     fn eq(&self, _other: &Self) -> bool {
9359         unimplemented!()
9360     }
9361 }
9362 impl ::std::cmp::Eq for CMSG_CONTENT_ENCRYPT_INFO_0 {}
9363 unsafe impl ::windows::runtime::Abi for CMSG_CONTENT_ENCRYPT_INFO_0 {
9364     type Abi = Self;
9365     type DefaultType = Self;
9366 }
9367 pub const CMSG_CONTENT_ENCRYPT_PAD_ENCODED_LEN_FLAG: u32 = 1u32;
9368 pub const CMSG_CONTENT_ENCRYPT_RELEASE_CONTEXT_FLAG: u32 = 32768u32;
9369 pub const CMSG_CONTENT_PARAM: u32 = 2u32;
9370 pub const CMSG_CRL_COUNT_PARAM: u32 = 13u32;
9371 pub const CMSG_CRL_PARAM: u32 = 14u32;
9372 pub const CMSG_CRYPT_RELEASE_CONTEXT_FLAG: u32 = 32768u32;
9373 pub const CMSG_CTRL_ADD_ATTR_CERT: u32 = 14u32;
9374 pub const CMSG_CTRL_ADD_CERT: u32 = 10u32;
9375 pub const CMSG_CTRL_ADD_CMS_SIGNER_INFO: u32 = 20u32;
9376 pub const CMSG_CTRL_ADD_CRL: u32 = 12u32;
9377 pub const CMSG_CTRL_ADD_SIGNER: u32 = 6u32;
9378 pub const CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR: u32 = 8u32;
9379 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9380 #[repr(C)]
9381 pub struct CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA {
9382     pub cbSize: u32,
9383     pub dwSignerIndex: u32,
9384     pub blob: CRYPTOAPI_BLOB,
9385 }
9386 impl CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA {}
9387 impl ::std::default::Default for CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA {
default() -> Self9388     fn default() -> Self {
9389         unsafe { ::std::mem::zeroed() }
9390     }
9391 }
9392 impl ::std::fmt::Debug for CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9393     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9394         fmt.debug_struct("CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA").field("cbSize", &self.cbSize).field("dwSignerIndex", &self.dwSignerIndex).field("blob", &self.blob).finish()
9395     }
9396 }
9397 impl ::std::cmp::PartialEq for CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA {
eq(&self, other: &Self) -> bool9398     fn eq(&self, other: &Self) -> bool {
9399         self.cbSize == other.cbSize && self.dwSignerIndex == other.dwSignerIndex && self.blob == other.blob
9400     }
9401 }
9402 impl ::std::cmp::Eq for CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA {}
9403 unsafe impl ::windows::runtime::Abi for CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA {
9404     type Abi = Self;
9405     type DefaultType = Self;
9406 }
9407 pub const CMSG_CTRL_DECRYPT: u32 = 2u32;
9408 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9409 #[repr(C)]
9410 pub struct CMSG_CTRL_DECRYPT_PARA {
9411     pub cbSize: u32,
9412     pub Anonymous: CMSG_CTRL_DECRYPT_PARA_0,
9413     pub dwKeySpec: u32,
9414     pub dwRecipientIndex: u32,
9415 }
9416 impl CMSG_CTRL_DECRYPT_PARA {}
9417 impl ::std::default::Default for CMSG_CTRL_DECRYPT_PARA {
default() -> Self9418     fn default() -> Self {
9419         unsafe { ::std::mem::zeroed() }
9420     }
9421 }
9422 impl ::std::cmp::PartialEq for CMSG_CTRL_DECRYPT_PARA {
eq(&self, _other: &Self) -> bool9423     fn eq(&self, _other: &Self) -> bool {
9424         unimplemented!()
9425     }
9426 }
9427 impl ::std::cmp::Eq for CMSG_CTRL_DECRYPT_PARA {}
9428 unsafe impl ::windows::runtime::Abi for CMSG_CTRL_DECRYPT_PARA {
9429     type Abi = Self;
9430     type DefaultType = Self;
9431 }
9432 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9433 #[repr(C)]
9434 pub union CMSG_CTRL_DECRYPT_PARA_0 {
9435     pub hCryptProv: usize,
9436     pub hNCryptKey: usize,
9437 }
9438 impl CMSG_CTRL_DECRYPT_PARA_0 {}
9439 impl ::std::default::Default for CMSG_CTRL_DECRYPT_PARA_0 {
default() -> Self9440     fn default() -> Self {
9441         unsafe { ::std::mem::zeroed() }
9442     }
9443 }
9444 impl ::std::cmp::PartialEq for CMSG_CTRL_DECRYPT_PARA_0 {
eq(&self, _other: &Self) -> bool9445     fn eq(&self, _other: &Self) -> bool {
9446         unimplemented!()
9447     }
9448 }
9449 impl ::std::cmp::Eq for CMSG_CTRL_DECRYPT_PARA_0 {}
9450 unsafe impl ::windows::runtime::Abi for CMSG_CTRL_DECRYPT_PARA_0 {
9451     type Abi = Self;
9452     type DefaultType = Self;
9453 }
9454 pub const CMSG_CTRL_DEL_ATTR_CERT: u32 = 15u32;
9455 pub const CMSG_CTRL_DEL_CERT: u32 = 11u32;
9456 pub const CMSG_CTRL_DEL_CRL: u32 = 13u32;
9457 pub const CMSG_CTRL_DEL_SIGNER: u32 = 7u32;
9458 pub const CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR: u32 = 9u32;
9459 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9460 #[repr(C)]
9461 pub struct CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA {
9462     pub cbSize: u32,
9463     pub dwSignerIndex: u32,
9464     pub dwUnauthAttrIndex: u32,
9465 }
9466 impl CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA {}
9467 impl ::std::default::Default for CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA {
default() -> Self9468     fn default() -> Self {
9469         unsafe { ::std::mem::zeroed() }
9470     }
9471 }
9472 impl ::std::fmt::Debug for CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9473     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9474         fmt.debug_struct("CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA").field("cbSize", &self.cbSize).field("dwSignerIndex", &self.dwSignerIndex).field("dwUnauthAttrIndex", &self.dwUnauthAttrIndex).finish()
9475     }
9476 }
9477 impl ::std::cmp::PartialEq for CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA {
eq(&self, other: &Self) -> bool9478     fn eq(&self, other: &Self) -> bool {
9479         self.cbSize == other.cbSize && self.dwSignerIndex == other.dwSignerIndex && self.dwUnauthAttrIndex == other.dwUnauthAttrIndex
9480     }
9481 }
9482 impl ::std::cmp::Eq for CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA {}
9483 unsafe impl ::windows::runtime::Abi for CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA {
9484     type Abi = Self;
9485     type DefaultType = Self;
9486 }
9487 pub const CMSG_CTRL_ENABLE_STRONG_SIGNATURE: u32 = 21u32;
9488 pub const CMSG_CTRL_KEY_AGREE_DECRYPT: u32 = 17u32;
9489 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9490 #[repr(C)]
9491 #[cfg(feature = "Win32_Foundation")]
9492 pub struct CMSG_CTRL_KEY_AGREE_DECRYPT_PARA {
9493     pub cbSize: u32,
9494     pub Anonymous: CMSG_CTRL_KEY_AGREE_DECRYPT_PARA_0,
9495     pub dwKeySpec: u32,
9496     pub pKeyAgree: *mut CMSG_KEY_AGREE_RECIPIENT_INFO,
9497     pub dwRecipientIndex: u32,
9498     pub dwRecipientEncryptedKeyIndex: u32,
9499     pub OriginatorPublicKey: CRYPT_BIT_BLOB,
9500 }
9501 #[cfg(feature = "Win32_Foundation")]
9502 impl CMSG_CTRL_KEY_AGREE_DECRYPT_PARA {}
9503 #[cfg(feature = "Win32_Foundation")]
9504 impl ::std::default::Default for CMSG_CTRL_KEY_AGREE_DECRYPT_PARA {
default() -> Self9505     fn default() -> Self {
9506         unsafe { ::std::mem::zeroed() }
9507     }
9508 }
9509 #[cfg(feature = "Win32_Foundation")]
9510 impl ::std::cmp::PartialEq for CMSG_CTRL_KEY_AGREE_DECRYPT_PARA {
eq(&self, _other: &Self) -> bool9511     fn eq(&self, _other: &Self) -> bool {
9512         unimplemented!()
9513     }
9514 }
9515 #[cfg(feature = "Win32_Foundation")]
9516 impl ::std::cmp::Eq for CMSG_CTRL_KEY_AGREE_DECRYPT_PARA {}
9517 #[cfg(feature = "Win32_Foundation")]
9518 unsafe impl ::windows::runtime::Abi for CMSG_CTRL_KEY_AGREE_DECRYPT_PARA {
9519     type Abi = Self;
9520     type DefaultType = Self;
9521 }
9522 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9523 #[repr(C)]
9524 pub union CMSG_CTRL_KEY_AGREE_DECRYPT_PARA_0 {
9525     pub hCryptProv: usize,
9526     pub hNCryptKey: usize,
9527 }
9528 impl CMSG_CTRL_KEY_AGREE_DECRYPT_PARA_0 {}
9529 impl ::std::default::Default for CMSG_CTRL_KEY_AGREE_DECRYPT_PARA_0 {
default() -> Self9530     fn default() -> Self {
9531         unsafe { ::std::mem::zeroed() }
9532     }
9533 }
9534 impl ::std::cmp::PartialEq for CMSG_CTRL_KEY_AGREE_DECRYPT_PARA_0 {
eq(&self, _other: &Self) -> bool9535     fn eq(&self, _other: &Self) -> bool {
9536         unimplemented!()
9537     }
9538 }
9539 impl ::std::cmp::Eq for CMSG_CTRL_KEY_AGREE_DECRYPT_PARA_0 {}
9540 unsafe impl ::windows::runtime::Abi for CMSG_CTRL_KEY_AGREE_DECRYPT_PARA_0 {
9541     type Abi = Self;
9542     type DefaultType = Self;
9543 }
9544 pub const CMSG_CTRL_KEY_TRANS_DECRYPT: u32 = 16u32;
9545 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9546 #[repr(C)]
9547 #[cfg(feature = "Win32_Foundation")]
9548 pub struct CMSG_CTRL_KEY_TRANS_DECRYPT_PARA {
9549     pub cbSize: u32,
9550     pub Anonymous: CMSG_CTRL_KEY_TRANS_DECRYPT_PARA_0,
9551     pub dwKeySpec: u32,
9552     pub pKeyTrans: *mut CMSG_KEY_TRANS_RECIPIENT_INFO,
9553     pub dwRecipientIndex: u32,
9554 }
9555 #[cfg(feature = "Win32_Foundation")]
9556 impl CMSG_CTRL_KEY_TRANS_DECRYPT_PARA {}
9557 #[cfg(feature = "Win32_Foundation")]
9558 impl ::std::default::Default for CMSG_CTRL_KEY_TRANS_DECRYPT_PARA {
default() -> Self9559     fn default() -> Self {
9560         unsafe { ::std::mem::zeroed() }
9561     }
9562 }
9563 #[cfg(feature = "Win32_Foundation")]
9564 impl ::std::cmp::PartialEq for CMSG_CTRL_KEY_TRANS_DECRYPT_PARA {
eq(&self, _other: &Self) -> bool9565     fn eq(&self, _other: &Self) -> bool {
9566         unimplemented!()
9567     }
9568 }
9569 #[cfg(feature = "Win32_Foundation")]
9570 impl ::std::cmp::Eq for CMSG_CTRL_KEY_TRANS_DECRYPT_PARA {}
9571 #[cfg(feature = "Win32_Foundation")]
9572 unsafe impl ::windows::runtime::Abi for CMSG_CTRL_KEY_TRANS_DECRYPT_PARA {
9573     type Abi = Self;
9574     type DefaultType = Self;
9575 }
9576 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9577 #[repr(C)]
9578 pub union CMSG_CTRL_KEY_TRANS_DECRYPT_PARA_0 {
9579     pub hCryptProv: usize,
9580     pub hNCryptKey: usize,
9581 }
9582 impl CMSG_CTRL_KEY_TRANS_DECRYPT_PARA_0 {}
9583 impl ::std::default::Default for CMSG_CTRL_KEY_TRANS_DECRYPT_PARA_0 {
default() -> Self9584     fn default() -> Self {
9585         unsafe { ::std::mem::zeroed() }
9586     }
9587 }
9588 impl ::std::cmp::PartialEq for CMSG_CTRL_KEY_TRANS_DECRYPT_PARA_0 {
eq(&self, _other: &Self) -> bool9589     fn eq(&self, _other: &Self) -> bool {
9590         unimplemented!()
9591     }
9592 }
9593 impl ::std::cmp::Eq for CMSG_CTRL_KEY_TRANS_DECRYPT_PARA_0 {}
9594 unsafe impl ::windows::runtime::Abi for CMSG_CTRL_KEY_TRANS_DECRYPT_PARA_0 {
9595     type Abi = Self;
9596     type DefaultType = Self;
9597 }
9598 pub const CMSG_CTRL_MAIL_LIST_DECRYPT: u32 = 18u32;
9599 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9600 #[repr(C)]
9601 #[cfg(feature = "Win32_Foundation")]
9602 pub struct CMSG_CTRL_MAIL_LIST_DECRYPT_PARA {
9603     pub cbSize: u32,
9604     pub hCryptProv: usize,
9605     pub pMailList: *mut CMSG_MAIL_LIST_RECIPIENT_INFO,
9606     pub dwRecipientIndex: u32,
9607     pub dwKeyChoice: u32,
9608     pub Anonymous: CMSG_CTRL_MAIL_LIST_DECRYPT_PARA_0,
9609 }
9610 #[cfg(feature = "Win32_Foundation")]
9611 impl CMSG_CTRL_MAIL_LIST_DECRYPT_PARA {}
9612 #[cfg(feature = "Win32_Foundation")]
9613 impl ::std::default::Default for CMSG_CTRL_MAIL_LIST_DECRYPT_PARA {
default() -> Self9614     fn default() -> Self {
9615         unsafe { ::std::mem::zeroed() }
9616     }
9617 }
9618 #[cfg(feature = "Win32_Foundation")]
9619 impl ::std::cmp::PartialEq for CMSG_CTRL_MAIL_LIST_DECRYPT_PARA {
eq(&self, _other: &Self) -> bool9620     fn eq(&self, _other: &Self) -> bool {
9621         unimplemented!()
9622     }
9623 }
9624 #[cfg(feature = "Win32_Foundation")]
9625 impl ::std::cmp::Eq for CMSG_CTRL_MAIL_LIST_DECRYPT_PARA {}
9626 #[cfg(feature = "Win32_Foundation")]
9627 unsafe impl ::windows::runtime::Abi for CMSG_CTRL_MAIL_LIST_DECRYPT_PARA {
9628     type Abi = Self;
9629     type DefaultType = Self;
9630 }
9631 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9632 #[repr(C)]
9633 pub union CMSG_CTRL_MAIL_LIST_DECRYPT_PARA_0 {
9634     pub hKeyEncryptionKey: usize,
9635     pub pvKeyEncryptionKey: *mut ::std::ffi::c_void,
9636 }
9637 impl CMSG_CTRL_MAIL_LIST_DECRYPT_PARA_0 {}
9638 impl ::std::default::Default for CMSG_CTRL_MAIL_LIST_DECRYPT_PARA_0 {
default() -> Self9639     fn default() -> Self {
9640         unsafe { ::std::mem::zeroed() }
9641     }
9642 }
9643 impl ::std::cmp::PartialEq for CMSG_CTRL_MAIL_LIST_DECRYPT_PARA_0 {
eq(&self, _other: &Self) -> bool9644     fn eq(&self, _other: &Self) -> bool {
9645         unimplemented!()
9646     }
9647 }
9648 impl ::std::cmp::Eq for CMSG_CTRL_MAIL_LIST_DECRYPT_PARA_0 {}
9649 unsafe impl ::windows::runtime::Abi for CMSG_CTRL_MAIL_LIST_DECRYPT_PARA_0 {
9650     type Abi = Self;
9651     type DefaultType = Self;
9652 }
9653 pub const CMSG_CTRL_VERIFY_HASH: u32 = 5u32;
9654 pub const CMSG_CTRL_VERIFY_SIGNATURE: u32 = 1u32;
9655 pub const CMSG_CTRL_VERIFY_SIGNATURE_EX: u32 = 19u32;
9656 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9657 #[repr(C)]
9658 pub struct CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA {
9659     pub cbSize: u32,
9660     pub hCryptProv: usize,
9661     pub dwSignerIndex: u32,
9662     pub dwSignerType: u32,
9663     pub pvSigner: *mut ::std::ffi::c_void,
9664 }
9665 impl CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA {}
9666 impl ::std::default::Default for CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA {
default() -> Self9667     fn default() -> Self {
9668         unsafe { ::std::mem::zeroed() }
9669     }
9670 }
9671 impl ::std::fmt::Debug for CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9672     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9673         fmt.debug_struct("CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA").field("cbSize", &self.cbSize).field("hCryptProv", &self.hCryptProv).field("dwSignerIndex", &self.dwSignerIndex).field("dwSignerType", &self.dwSignerType).field("pvSigner", &self.pvSigner).finish()
9674     }
9675 }
9676 impl ::std::cmp::PartialEq for CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA {
eq(&self, other: &Self) -> bool9677     fn eq(&self, other: &Self) -> bool {
9678         self.cbSize == other.cbSize && self.hCryptProv == other.hCryptProv && self.dwSignerIndex == other.dwSignerIndex && self.dwSignerType == other.dwSignerType && self.pvSigner == other.pvSigner
9679     }
9680 }
9681 impl ::std::cmp::Eq for CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA {}
9682 unsafe impl ::windows::runtime::Abi for CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA {
9683     type Abi = Self;
9684     type DefaultType = Self;
9685 }
9686 pub const CMSG_DETACHED_FLAG: u32 = 4u32;
9687 pub const CMSG_ENCODED_MESSAGE: u32 = 29u32;
9688 pub const CMSG_ENCODED_SIGNER: u32 = 28u32;
9689 pub const CMSG_ENCODE_HASHED_SUBJECT_IDENTIFIER_FLAG: u32 = 2u32;
9690 pub const CMSG_ENCODE_SORTED_CTL_FLAG: u32 = 1u32;
9691 pub const CMSG_ENCODING_TYPE_MASK: u32 = 4294901760u32;
9692 pub const CMSG_ENCRYPTED: u32 = 6u32;
9693 pub const CMSG_ENCRYPTED_DIGEST: u32 = 27u32;
9694 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9695 #[repr(C)]
9696 #[cfg(feature = "Win32_Foundation")]
9697 pub struct CMSG_ENCRYPTED_ENCODE_INFO {
9698     pub cbSize: u32,
9699     pub ContentEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
9700     pub pvEncryptionAuxInfo: *mut ::std::ffi::c_void,
9701 }
9702 #[cfg(feature = "Win32_Foundation")]
9703 impl CMSG_ENCRYPTED_ENCODE_INFO {}
9704 #[cfg(feature = "Win32_Foundation")]
9705 impl ::std::default::Default for CMSG_ENCRYPTED_ENCODE_INFO {
default() -> Self9706     fn default() -> Self {
9707         unsafe { ::std::mem::zeroed() }
9708     }
9709 }
9710 #[cfg(feature = "Win32_Foundation")]
9711 impl ::std::fmt::Debug for CMSG_ENCRYPTED_ENCODE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9712     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9713         fmt.debug_struct("CMSG_ENCRYPTED_ENCODE_INFO").field("cbSize", &self.cbSize).field("ContentEncryptionAlgorithm", &self.ContentEncryptionAlgorithm).field("pvEncryptionAuxInfo", &self.pvEncryptionAuxInfo).finish()
9714     }
9715 }
9716 #[cfg(feature = "Win32_Foundation")]
9717 impl ::std::cmp::PartialEq for CMSG_ENCRYPTED_ENCODE_INFO {
eq(&self, other: &Self) -> bool9718     fn eq(&self, other: &Self) -> bool {
9719         self.cbSize == other.cbSize && self.ContentEncryptionAlgorithm == other.ContentEncryptionAlgorithm && self.pvEncryptionAuxInfo == other.pvEncryptionAuxInfo
9720     }
9721 }
9722 #[cfg(feature = "Win32_Foundation")]
9723 impl ::std::cmp::Eq for CMSG_ENCRYPTED_ENCODE_INFO {}
9724 #[cfg(feature = "Win32_Foundation")]
9725 unsafe impl ::windows::runtime::Abi for CMSG_ENCRYPTED_ENCODE_INFO {
9726     type Abi = Self;
9727     type DefaultType = Self;
9728 }
9729 pub const CMSG_ENCRYPT_PARAM: u32 = 26u32;
9730 pub const CMSG_ENVELOPED_DATA_CMS_VERSION: u32 = 2u32;
9731 pub const CMSG_ENVELOPED_DATA_PKCS_1_5_VERSION: u32 = 0u32;
9732 pub const CMSG_ENVELOPED_DATA_V0: u32 = 0u32;
9733 pub const CMSG_ENVELOPED_DATA_V2: u32 = 2u32;
9734 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9735 #[repr(C)]
9736 #[cfg(feature = "Win32_Foundation")]
9737 pub struct CMSG_ENVELOPED_ENCODE_INFO {
9738     pub cbSize: u32,
9739     pub hCryptProv: usize,
9740     pub ContentEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
9741     pub pvEncryptionAuxInfo: *mut ::std::ffi::c_void,
9742     pub cRecipients: u32,
9743     pub rgpRecipients: *mut *mut CERT_INFO,
9744 }
9745 #[cfg(feature = "Win32_Foundation")]
9746 impl CMSG_ENVELOPED_ENCODE_INFO {}
9747 #[cfg(feature = "Win32_Foundation")]
9748 impl ::std::default::Default for CMSG_ENVELOPED_ENCODE_INFO {
default() -> Self9749     fn default() -> Self {
9750         unsafe { ::std::mem::zeroed() }
9751     }
9752 }
9753 #[cfg(feature = "Win32_Foundation")]
9754 impl ::std::fmt::Debug for CMSG_ENVELOPED_ENCODE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9755     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9756         fmt.debug_struct("CMSG_ENVELOPED_ENCODE_INFO")
9757             .field("cbSize", &self.cbSize)
9758             .field("hCryptProv", &self.hCryptProv)
9759             .field("ContentEncryptionAlgorithm", &self.ContentEncryptionAlgorithm)
9760             .field("pvEncryptionAuxInfo", &self.pvEncryptionAuxInfo)
9761             .field("cRecipients", &self.cRecipients)
9762             .field("rgpRecipients", &self.rgpRecipients)
9763             .finish()
9764     }
9765 }
9766 #[cfg(feature = "Win32_Foundation")]
9767 impl ::std::cmp::PartialEq for CMSG_ENVELOPED_ENCODE_INFO {
eq(&self, other: &Self) -> bool9768     fn eq(&self, other: &Self) -> bool {
9769         self.cbSize == other.cbSize && self.hCryptProv == other.hCryptProv && self.ContentEncryptionAlgorithm == other.ContentEncryptionAlgorithm && self.pvEncryptionAuxInfo == other.pvEncryptionAuxInfo && self.cRecipients == other.cRecipients && self.rgpRecipients == other.rgpRecipients
9770     }
9771 }
9772 #[cfg(feature = "Win32_Foundation")]
9773 impl ::std::cmp::Eq for CMSG_ENVELOPED_ENCODE_INFO {}
9774 #[cfg(feature = "Win32_Foundation")]
9775 unsafe impl ::windows::runtime::Abi for CMSG_ENVELOPED_ENCODE_INFO {
9776     type Abi = Self;
9777     type DefaultType = Self;
9778 }
9779 pub const CMSG_ENVELOPED_RECIPIENT_V0: u32 = 0u32;
9780 pub const CMSG_ENVELOPED_RECIPIENT_V2: u32 = 2u32;
9781 pub const CMSG_ENVELOPED_RECIPIENT_V3: u32 = 3u32;
9782 pub const CMSG_ENVELOPED_RECIPIENT_V4: u32 = 4u32;
9783 pub const CMSG_ENVELOPE_ALGORITHM_PARAM: u32 = 15u32;
9784 pub const CMSG_HASHED_DATA_CMS_VERSION: u32 = 2u32;
9785 pub const CMSG_HASHED_DATA_PKCS_1_5_VERSION: u32 = 0u32;
9786 pub const CMSG_HASHED_DATA_V0: u32 = 0u32;
9787 pub const CMSG_HASHED_DATA_V2: u32 = 2u32;
9788 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9789 #[repr(C)]
9790 #[cfg(feature = "Win32_Foundation")]
9791 pub struct CMSG_HASHED_ENCODE_INFO {
9792     pub cbSize: u32,
9793     pub hCryptProv: usize,
9794     pub HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
9795     pub pvHashAuxInfo: *mut ::std::ffi::c_void,
9796 }
9797 #[cfg(feature = "Win32_Foundation")]
9798 impl CMSG_HASHED_ENCODE_INFO {}
9799 #[cfg(feature = "Win32_Foundation")]
9800 impl ::std::default::Default for CMSG_HASHED_ENCODE_INFO {
default() -> Self9801     fn default() -> Self {
9802         unsafe { ::std::mem::zeroed() }
9803     }
9804 }
9805 #[cfg(feature = "Win32_Foundation")]
9806 impl ::std::fmt::Debug for CMSG_HASHED_ENCODE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9807     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9808         fmt.debug_struct("CMSG_HASHED_ENCODE_INFO").field("cbSize", &self.cbSize).field("hCryptProv", &self.hCryptProv).field("HashAlgorithm", &self.HashAlgorithm).field("pvHashAuxInfo", &self.pvHashAuxInfo).finish()
9809     }
9810 }
9811 #[cfg(feature = "Win32_Foundation")]
9812 impl ::std::cmp::PartialEq for CMSG_HASHED_ENCODE_INFO {
eq(&self, other: &Self) -> bool9813     fn eq(&self, other: &Self) -> bool {
9814         self.cbSize == other.cbSize && self.hCryptProv == other.hCryptProv && self.HashAlgorithm == other.HashAlgorithm && self.pvHashAuxInfo == other.pvHashAuxInfo
9815     }
9816 }
9817 #[cfg(feature = "Win32_Foundation")]
9818 impl ::std::cmp::Eq for CMSG_HASHED_ENCODE_INFO {}
9819 #[cfg(feature = "Win32_Foundation")]
9820 unsafe impl ::windows::runtime::Abi for CMSG_HASHED_ENCODE_INFO {
9821     type Abi = Self;
9822     type DefaultType = Self;
9823 }
9824 pub const CMSG_HASH_ALGORITHM_PARAM: u32 = 20u32;
9825 pub const CMSG_HASH_DATA_PARAM: u32 = 21u32;
9826 pub const CMSG_INDEFINITE_LENGTH: u32 = 4294967295u32;
9827 pub const CMSG_INNER_CONTENT_TYPE_PARAM: u32 = 4u32;
9828 pub const CMSG_KEY_AGREE_ENCRYPT_FREE_MATERIAL_FLAG: u32 = 2u32;
9829 pub const CMSG_KEY_AGREE_ENCRYPT_FREE_OBJID_FLAG: u32 = 32u32;
9830 pub const CMSG_KEY_AGREE_ENCRYPT_FREE_PARA_FLAG: u32 = 1u32;
9831 pub const CMSG_KEY_AGREE_ENCRYPT_FREE_PUBKEY_ALG_FLAG: u32 = 4u32;
9832 pub const CMSG_KEY_AGREE_ENCRYPT_FREE_PUBKEY_BITS_FLAG: u32 = 16u32;
9833 pub const CMSG_KEY_AGREE_ENCRYPT_FREE_PUBKEY_PARA_FLAG: u32 = 8u32;
9834 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9835 #[repr(C)]
9836 #[cfg(feature = "Win32_Foundation")]
9837 pub struct CMSG_KEY_AGREE_ENCRYPT_INFO {
9838     pub cbSize: u32,
9839     pub dwRecipientIndex: u32,
9840     pub KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
9841     pub UserKeyingMaterial: CRYPTOAPI_BLOB,
9842     pub dwOriginatorChoice: CMSG_KEY_AGREE_ORIGINATOR,
9843     pub Anonymous: CMSG_KEY_AGREE_ENCRYPT_INFO_0,
9844     pub cKeyAgreeKeyEncryptInfo: u32,
9845     pub rgpKeyAgreeKeyEncryptInfo: *mut *mut CMSG_KEY_AGREE_KEY_ENCRYPT_INFO,
9846     pub dwFlags: u32,
9847 }
9848 #[cfg(feature = "Win32_Foundation")]
9849 impl CMSG_KEY_AGREE_ENCRYPT_INFO {}
9850 #[cfg(feature = "Win32_Foundation")]
9851 impl ::std::default::Default for CMSG_KEY_AGREE_ENCRYPT_INFO {
default() -> Self9852     fn default() -> Self {
9853         unsafe { ::std::mem::zeroed() }
9854     }
9855 }
9856 #[cfg(feature = "Win32_Foundation")]
9857 impl ::std::cmp::PartialEq for CMSG_KEY_AGREE_ENCRYPT_INFO {
eq(&self, _other: &Self) -> bool9858     fn eq(&self, _other: &Self) -> bool {
9859         unimplemented!()
9860     }
9861 }
9862 #[cfg(feature = "Win32_Foundation")]
9863 impl ::std::cmp::Eq for CMSG_KEY_AGREE_ENCRYPT_INFO {}
9864 #[cfg(feature = "Win32_Foundation")]
9865 unsafe impl ::windows::runtime::Abi for CMSG_KEY_AGREE_ENCRYPT_INFO {
9866     type Abi = Self;
9867     type DefaultType = Self;
9868 }
9869 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9870 #[repr(C)]
9871 #[cfg(feature = "Win32_Foundation")]
9872 pub union CMSG_KEY_AGREE_ENCRYPT_INFO_0 {
9873     pub OriginatorCertId: CERT_ID,
9874     pub OriginatorPublicKeyInfo: CERT_PUBLIC_KEY_INFO,
9875 }
9876 #[cfg(feature = "Win32_Foundation")]
9877 impl CMSG_KEY_AGREE_ENCRYPT_INFO_0 {}
9878 #[cfg(feature = "Win32_Foundation")]
9879 impl ::std::default::Default for CMSG_KEY_AGREE_ENCRYPT_INFO_0 {
default() -> Self9880     fn default() -> Self {
9881         unsafe { ::std::mem::zeroed() }
9882     }
9883 }
9884 #[cfg(feature = "Win32_Foundation")]
9885 impl ::std::cmp::PartialEq for CMSG_KEY_AGREE_ENCRYPT_INFO_0 {
eq(&self, _other: &Self) -> bool9886     fn eq(&self, _other: &Self) -> bool {
9887         unimplemented!()
9888     }
9889 }
9890 #[cfg(feature = "Win32_Foundation")]
9891 impl ::std::cmp::Eq for CMSG_KEY_AGREE_ENCRYPT_INFO_0 {}
9892 #[cfg(feature = "Win32_Foundation")]
9893 unsafe impl ::windows::runtime::Abi for CMSG_KEY_AGREE_ENCRYPT_INFO_0 {
9894     type Abi = Self;
9895     type DefaultType = Self;
9896 }
9897 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9898 #[repr(C)]
9899 pub struct CMSG_KEY_AGREE_KEY_ENCRYPT_INFO {
9900     pub cbSize: u32,
9901     pub EncryptedKey: CRYPTOAPI_BLOB,
9902 }
9903 impl CMSG_KEY_AGREE_KEY_ENCRYPT_INFO {}
9904 impl ::std::default::Default for CMSG_KEY_AGREE_KEY_ENCRYPT_INFO {
default() -> Self9905     fn default() -> Self {
9906         unsafe { ::std::mem::zeroed() }
9907     }
9908 }
9909 impl ::std::fmt::Debug for CMSG_KEY_AGREE_KEY_ENCRYPT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9910     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9911         fmt.debug_struct("CMSG_KEY_AGREE_KEY_ENCRYPT_INFO").field("cbSize", &self.cbSize).field("EncryptedKey", &self.EncryptedKey).finish()
9912     }
9913 }
9914 impl ::std::cmp::PartialEq for CMSG_KEY_AGREE_KEY_ENCRYPT_INFO {
eq(&self, other: &Self) -> bool9915     fn eq(&self, other: &Self) -> bool {
9916         self.cbSize == other.cbSize && self.EncryptedKey == other.EncryptedKey
9917     }
9918 }
9919 impl ::std::cmp::Eq for CMSG_KEY_AGREE_KEY_ENCRYPT_INFO {}
9920 unsafe impl ::windows::runtime::Abi for CMSG_KEY_AGREE_KEY_ENCRYPT_INFO {
9921     type Abi = Self;
9922     type DefaultType = Self;
9923 }
9924 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9925 #[repr(transparent)]
9926 pub struct CMSG_KEY_AGREE_OPTION(pub u32);
9927 pub const CMSG_KEY_AGREE_EPHEMERAL_KEY_CHOICE: CMSG_KEY_AGREE_OPTION = CMSG_KEY_AGREE_OPTION(1u32);
9928 pub const CMSG_KEY_AGREE_STATIC_KEY_CHOICE: CMSG_KEY_AGREE_OPTION = CMSG_KEY_AGREE_OPTION(2u32);
9929 impl ::std::convert::From<u32> for CMSG_KEY_AGREE_OPTION {
from(value: u32) -> Self9930     fn from(value: u32) -> Self {
9931         Self(value)
9932     }
9933 }
9934 unsafe impl ::windows::runtime::Abi for CMSG_KEY_AGREE_OPTION {
9935     type Abi = Self;
9936     type DefaultType = Self;
9937 }
9938 impl ::std::ops::BitOr for CMSG_KEY_AGREE_OPTION {
9939     type Output = Self;
bitor(self, rhs: Self) -> Self9940     fn bitor(self, rhs: Self) -> Self {
9941         Self(self.0 | rhs.0)
9942     }
9943 }
9944 impl ::std::ops::BitAnd for CMSG_KEY_AGREE_OPTION {
9945     type Output = Self;
bitand(self, rhs: Self) -> Self9946     fn bitand(self, rhs: Self) -> Self {
9947         Self(self.0 & rhs.0)
9948     }
9949 }
9950 impl ::std::ops::BitOrAssign for CMSG_KEY_AGREE_OPTION {
bitor_assign(&mut self, rhs: Self)9951     fn bitor_assign(&mut self, rhs: Self) {
9952         self.0.bitor_assign(rhs.0)
9953     }
9954 }
9955 impl ::std::ops::BitAndAssign for CMSG_KEY_AGREE_OPTION {
bitand_assign(&mut self, rhs: Self)9956     fn bitand_assign(&mut self, rhs: Self) {
9957         self.0.bitand_assign(rhs.0)
9958     }
9959 }
9960 impl ::std::ops::Not for CMSG_KEY_AGREE_OPTION {
9961     type Output = Self;
not(self) -> Self9962     fn not(self) -> Self {
9963         Self(self.0.not())
9964     }
9965 }
9966 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9967 #[repr(transparent)]
9968 pub struct CMSG_KEY_AGREE_ORIGINATOR(pub u32);
9969 pub const CMSG_KEY_AGREE_ORIGINATOR_CERT: CMSG_KEY_AGREE_ORIGINATOR = CMSG_KEY_AGREE_ORIGINATOR(1u32);
9970 pub const CMSG_KEY_AGREE_ORIGINATOR_PUBLIC_KEY: CMSG_KEY_AGREE_ORIGINATOR = CMSG_KEY_AGREE_ORIGINATOR(2u32);
9971 impl ::std::convert::From<u32> for CMSG_KEY_AGREE_ORIGINATOR {
from(value: u32) -> Self9972     fn from(value: u32) -> Self {
9973         Self(value)
9974     }
9975 }
9976 unsafe impl ::windows::runtime::Abi for CMSG_KEY_AGREE_ORIGINATOR {
9977     type Abi = Self;
9978     type DefaultType = Self;
9979 }
9980 impl ::std::ops::BitOr for CMSG_KEY_AGREE_ORIGINATOR {
9981     type Output = Self;
bitor(self, rhs: Self) -> Self9982     fn bitor(self, rhs: Self) -> Self {
9983         Self(self.0 | rhs.0)
9984     }
9985 }
9986 impl ::std::ops::BitAnd for CMSG_KEY_AGREE_ORIGINATOR {
9987     type Output = Self;
bitand(self, rhs: Self) -> Self9988     fn bitand(self, rhs: Self) -> Self {
9989         Self(self.0 & rhs.0)
9990     }
9991 }
9992 impl ::std::ops::BitOrAssign for CMSG_KEY_AGREE_ORIGINATOR {
bitor_assign(&mut self, rhs: Self)9993     fn bitor_assign(&mut self, rhs: Self) {
9994         self.0.bitor_assign(rhs.0)
9995     }
9996 }
9997 impl ::std::ops::BitAndAssign for CMSG_KEY_AGREE_ORIGINATOR {
bitand_assign(&mut self, rhs: Self)9998     fn bitand_assign(&mut self, rhs: Self) {
9999         self.0.bitand_assign(rhs.0)
10000     }
10001 }
10002 impl ::std::ops::Not for CMSG_KEY_AGREE_ORIGINATOR {
10003     type Output = Self;
not(self) -> Self10004     fn not(self) -> Self {
10005         Self(self.0.not())
10006     }
10007 }
10008 pub const CMSG_KEY_AGREE_RECIPIENT: u32 = 2u32;
10009 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10010 #[repr(C)]
10011 #[cfg(feature = "Win32_Foundation")]
10012 pub struct CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO {
10013     pub cbSize: u32,
10014     pub KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
10015     pub pvKeyEncryptionAuxInfo: *mut ::std::ffi::c_void,
10016     pub KeyWrapAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
10017     pub pvKeyWrapAuxInfo: *mut ::std::ffi::c_void,
10018     pub hCryptProv: usize,
10019     pub dwKeySpec: u32,
10020     pub dwKeyChoice: CMSG_KEY_AGREE_OPTION,
10021     pub Anonymous: CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO_0,
10022     pub UserKeyingMaterial: CRYPTOAPI_BLOB,
10023     pub cRecipientEncryptedKeys: u32,
10024     pub rgpRecipientEncryptedKeys: *mut *mut CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO,
10025 }
10026 #[cfg(feature = "Win32_Foundation")]
10027 impl CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO {}
10028 #[cfg(feature = "Win32_Foundation")]
10029 impl ::std::default::Default for CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO {
default() -> Self10030     fn default() -> Self {
10031         unsafe { ::std::mem::zeroed() }
10032     }
10033 }
10034 #[cfg(feature = "Win32_Foundation")]
10035 impl ::std::cmp::PartialEq for CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO {
eq(&self, _other: &Self) -> bool10036     fn eq(&self, _other: &Self) -> bool {
10037         unimplemented!()
10038     }
10039 }
10040 #[cfg(feature = "Win32_Foundation")]
10041 impl ::std::cmp::Eq for CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO {}
10042 #[cfg(feature = "Win32_Foundation")]
10043 unsafe impl ::windows::runtime::Abi for CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO {
10044     type Abi = Self;
10045     type DefaultType = Self;
10046 }
10047 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10048 #[repr(C)]
10049 #[cfg(feature = "Win32_Foundation")]
10050 pub union CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO_0 {
10051     pub pEphemeralAlgorithm: *mut CRYPT_ALGORITHM_IDENTIFIER,
10052     pub pSenderId: *mut CERT_ID,
10053 }
10054 #[cfg(feature = "Win32_Foundation")]
10055 impl CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO_0 {}
10056 #[cfg(feature = "Win32_Foundation")]
10057 impl ::std::default::Default for CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO_0 {
default() -> Self10058     fn default() -> Self {
10059         unsafe { ::std::mem::zeroed() }
10060     }
10061 }
10062 #[cfg(feature = "Win32_Foundation")]
10063 impl ::std::cmp::PartialEq for CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO_0 {
eq(&self, _other: &Self) -> bool10064     fn eq(&self, _other: &Self) -> bool {
10065         unimplemented!()
10066     }
10067 }
10068 #[cfg(feature = "Win32_Foundation")]
10069 impl ::std::cmp::Eq for CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO_0 {}
10070 #[cfg(feature = "Win32_Foundation")]
10071 unsafe impl ::windows::runtime::Abi for CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO_0 {
10072     type Abi = Self;
10073     type DefaultType = Self;
10074 }
10075 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10076 #[repr(C)]
10077 #[cfg(feature = "Win32_Foundation")]
10078 pub struct CMSG_KEY_AGREE_RECIPIENT_INFO {
10079     pub dwVersion: u32,
10080     pub dwOriginatorChoice: CMSG_KEY_AGREE_ORIGINATOR,
10081     pub Anonymous: CMSG_KEY_AGREE_RECIPIENT_INFO_0,
10082     pub UserKeyingMaterial: CRYPTOAPI_BLOB,
10083     pub KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
10084     pub cRecipientEncryptedKeys: u32,
10085     pub rgpRecipientEncryptedKeys: *mut *mut CMSG_RECIPIENT_ENCRYPTED_KEY_INFO,
10086 }
10087 #[cfg(feature = "Win32_Foundation")]
10088 impl CMSG_KEY_AGREE_RECIPIENT_INFO {}
10089 #[cfg(feature = "Win32_Foundation")]
10090 impl ::std::default::Default for CMSG_KEY_AGREE_RECIPIENT_INFO {
default() -> Self10091     fn default() -> Self {
10092         unsafe { ::std::mem::zeroed() }
10093     }
10094 }
10095 #[cfg(feature = "Win32_Foundation")]
10096 impl ::std::cmp::PartialEq for CMSG_KEY_AGREE_RECIPIENT_INFO {
eq(&self, _other: &Self) -> bool10097     fn eq(&self, _other: &Self) -> bool {
10098         unimplemented!()
10099     }
10100 }
10101 #[cfg(feature = "Win32_Foundation")]
10102 impl ::std::cmp::Eq for CMSG_KEY_AGREE_RECIPIENT_INFO {}
10103 #[cfg(feature = "Win32_Foundation")]
10104 unsafe impl ::windows::runtime::Abi for CMSG_KEY_AGREE_RECIPIENT_INFO {
10105     type Abi = Self;
10106     type DefaultType = Self;
10107 }
10108 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10109 #[repr(C)]
10110 #[cfg(feature = "Win32_Foundation")]
10111 pub union CMSG_KEY_AGREE_RECIPIENT_INFO_0 {
10112     pub OriginatorCertId: CERT_ID,
10113     pub OriginatorPublicKeyInfo: CERT_PUBLIC_KEY_INFO,
10114 }
10115 #[cfg(feature = "Win32_Foundation")]
10116 impl CMSG_KEY_AGREE_RECIPIENT_INFO_0 {}
10117 #[cfg(feature = "Win32_Foundation")]
10118 impl ::std::default::Default for CMSG_KEY_AGREE_RECIPIENT_INFO_0 {
default() -> Self10119     fn default() -> Self {
10120         unsafe { ::std::mem::zeroed() }
10121     }
10122 }
10123 #[cfg(feature = "Win32_Foundation")]
10124 impl ::std::cmp::PartialEq for CMSG_KEY_AGREE_RECIPIENT_INFO_0 {
eq(&self, _other: &Self) -> bool10125     fn eq(&self, _other: &Self) -> bool {
10126         unimplemented!()
10127     }
10128 }
10129 #[cfg(feature = "Win32_Foundation")]
10130 impl ::std::cmp::Eq for CMSG_KEY_AGREE_RECIPIENT_INFO_0 {}
10131 #[cfg(feature = "Win32_Foundation")]
10132 unsafe impl ::windows::runtime::Abi for CMSG_KEY_AGREE_RECIPIENT_INFO_0 {
10133     type Abi = Self;
10134     type DefaultType = Self;
10135 }
10136 pub const CMSG_KEY_AGREE_VERSION: u32 = 3u32;
10137 pub const CMSG_KEY_TRANS_CMS_VERSION: u32 = 2u32;
10138 pub const CMSG_KEY_TRANS_ENCRYPT_FREE_OBJID_FLAG: u32 = 2u32;
10139 pub const CMSG_KEY_TRANS_ENCRYPT_FREE_PARA_FLAG: u32 = 1u32;
10140 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10141 #[repr(C)]
10142 #[cfg(feature = "Win32_Foundation")]
10143 pub struct CMSG_KEY_TRANS_ENCRYPT_INFO {
10144     pub cbSize: u32,
10145     pub dwRecipientIndex: u32,
10146     pub KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
10147     pub EncryptedKey: CRYPTOAPI_BLOB,
10148     pub dwFlags: u32,
10149 }
10150 #[cfg(feature = "Win32_Foundation")]
10151 impl CMSG_KEY_TRANS_ENCRYPT_INFO {}
10152 #[cfg(feature = "Win32_Foundation")]
10153 impl ::std::default::Default for CMSG_KEY_TRANS_ENCRYPT_INFO {
default() -> Self10154     fn default() -> Self {
10155         unsafe { ::std::mem::zeroed() }
10156     }
10157 }
10158 #[cfg(feature = "Win32_Foundation")]
10159 impl ::std::fmt::Debug for CMSG_KEY_TRANS_ENCRYPT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10160     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10161         fmt.debug_struct("CMSG_KEY_TRANS_ENCRYPT_INFO").field("cbSize", &self.cbSize).field("dwRecipientIndex", &self.dwRecipientIndex).field("KeyEncryptionAlgorithm", &self.KeyEncryptionAlgorithm).field("EncryptedKey", &self.EncryptedKey).field("dwFlags", &self.dwFlags).finish()
10162     }
10163 }
10164 #[cfg(feature = "Win32_Foundation")]
10165 impl ::std::cmp::PartialEq for CMSG_KEY_TRANS_ENCRYPT_INFO {
eq(&self, other: &Self) -> bool10166     fn eq(&self, other: &Self) -> bool {
10167         self.cbSize == other.cbSize && self.dwRecipientIndex == other.dwRecipientIndex && self.KeyEncryptionAlgorithm == other.KeyEncryptionAlgorithm && self.EncryptedKey == other.EncryptedKey && self.dwFlags == other.dwFlags
10168     }
10169 }
10170 #[cfg(feature = "Win32_Foundation")]
10171 impl ::std::cmp::Eq for CMSG_KEY_TRANS_ENCRYPT_INFO {}
10172 #[cfg(feature = "Win32_Foundation")]
10173 unsafe impl ::windows::runtime::Abi for CMSG_KEY_TRANS_ENCRYPT_INFO {
10174     type Abi = Self;
10175     type DefaultType = Self;
10176 }
10177 pub const CMSG_KEY_TRANS_PKCS_1_5_VERSION: u32 = 0u32;
10178 pub const CMSG_KEY_TRANS_RECIPIENT: u32 = 1u32;
10179 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10180 #[repr(C)]
10181 #[cfg(feature = "Win32_Foundation")]
10182 pub struct CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO {
10183     pub cbSize: u32,
10184     pub KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
10185     pub pvKeyEncryptionAuxInfo: *mut ::std::ffi::c_void,
10186     pub hCryptProv: usize,
10187     pub RecipientPublicKey: CRYPT_BIT_BLOB,
10188     pub RecipientId: CERT_ID,
10189 }
10190 #[cfg(feature = "Win32_Foundation")]
10191 impl CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO {}
10192 #[cfg(feature = "Win32_Foundation")]
10193 impl ::std::default::Default for CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO {
default() -> Self10194     fn default() -> Self {
10195         unsafe { ::std::mem::zeroed() }
10196     }
10197 }
10198 #[cfg(feature = "Win32_Foundation")]
10199 impl ::std::cmp::PartialEq for CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO {
eq(&self, _other: &Self) -> bool10200     fn eq(&self, _other: &Self) -> bool {
10201         unimplemented!()
10202     }
10203 }
10204 #[cfg(feature = "Win32_Foundation")]
10205 impl ::std::cmp::Eq for CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO {}
10206 #[cfg(feature = "Win32_Foundation")]
10207 unsafe impl ::windows::runtime::Abi for CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO {
10208     type Abi = Self;
10209     type DefaultType = Self;
10210 }
10211 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10212 #[repr(C)]
10213 #[cfg(feature = "Win32_Foundation")]
10214 pub struct CMSG_KEY_TRANS_RECIPIENT_INFO {
10215     pub dwVersion: u32,
10216     pub RecipientId: CERT_ID,
10217     pub KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
10218     pub EncryptedKey: CRYPTOAPI_BLOB,
10219 }
10220 #[cfg(feature = "Win32_Foundation")]
10221 impl CMSG_KEY_TRANS_RECIPIENT_INFO {}
10222 #[cfg(feature = "Win32_Foundation")]
10223 impl ::std::default::Default for CMSG_KEY_TRANS_RECIPIENT_INFO {
default() -> Self10224     fn default() -> Self {
10225         unsafe { ::std::mem::zeroed() }
10226     }
10227 }
10228 #[cfg(feature = "Win32_Foundation")]
10229 impl ::std::cmp::PartialEq for CMSG_KEY_TRANS_RECIPIENT_INFO {
eq(&self, _other: &Self) -> bool10230     fn eq(&self, _other: &Self) -> bool {
10231         unimplemented!()
10232     }
10233 }
10234 #[cfg(feature = "Win32_Foundation")]
10235 impl ::std::cmp::Eq for CMSG_KEY_TRANS_RECIPIENT_INFO {}
10236 #[cfg(feature = "Win32_Foundation")]
10237 unsafe impl ::windows::runtime::Abi for CMSG_KEY_TRANS_RECIPIENT_INFO {
10238     type Abi = Self;
10239     type DefaultType = Self;
10240 }
10241 pub const CMSG_LENGTH_ONLY_FLAG: u32 = 2u32;
10242 pub const CMSG_MAIL_LIST_ENCRYPT_FREE_OBJID_FLAG: u32 = 2u32;
10243 pub const CMSG_MAIL_LIST_ENCRYPT_FREE_PARA_FLAG: u32 = 1u32;
10244 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10245 #[repr(C)]
10246 #[cfg(feature = "Win32_Foundation")]
10247 pub struct CMSG_MAIL_LIST_ENCRYPT_INFO {
10248     pub cbSize: u32,
10249     pub dwRecipientIndex: u32,
10250     pub KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
10251     pub EncryptedKey: CRYPTOAPI_BLOB,
10252     pub dwFlags: u32,
10253 }
10254 #[cfg(feature = "Win32_Foundation")]
10255 impl CMSG_MAIL_LIST_ENCRYPT_INFO {}
10256 #[cfg(feature = "Win32_Foundation")]
10257 impl ::std::default::Default for CMSG_MAIL_LIST_ENCRYPT_INFO {
default() -> Self10258     fn default() -> Self {
10259         unsafe { ::std::mem::zeroed() }
10260     }
10261 }
10262 #[cfg(feature = "Win32_Foundation")]
10263 impl ::std::fmt::Debug for CMSG_MAIL_LIST_ENCRYPT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10264     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10265         fmt.debug_struct("CMSG_MAIL_LIST_ENCRYPT_INFO").field("cbSize", &self.cbSize).field("dwRecipientIndex", &self.dwRecipientIndex).field("KeyEncryptionAlgorithm", &self.KeyEncryptionAlgorithm).field("EncryptedKey", &self.EncryptedKey).field("dwFlags", &self.dwFlags).finish()
10266     }
10267 }
10268 #[cfg(feature = "Win32_Foundation")]
10269 impl ::std::cmp::PartialEq for CMSG_MAIL_LIST_ENCRYPT_INFO {
eq(&self, other: &Self) -> bool10270     fn eq(&self, other: &Self) -> bool {
10271         self.cbSize == other.cbSize && self.dwRecipientIndex == other.dwRecipientIndex && self.KeyEncryptionAlgorithm == other.KeyEncryptionAlgorithm && self.EncryptedKey == other.EncryptedKey && self.dwFlags == other.dwFlags
10272     }
10273 }
10274 #[cfg(feature = "Win32_Foundation")]
10275 impl ::std::cmp::Eq for CMSG_MAIL_LIST_ENCRYPT_INFO {}
10276 #[cfg(feature = "Win32_Foundation")]
10277 unsafe impl ::windows::runtime::Abi for CMSG_MAIL_LIST_ENCRYPT_INFO {
10278     type Abi = Self;
10279     type DefaultType = Self;
10280 }
10281 pub const CMSG_MAIL_LIST_HANDLE_KEY_CHOICE: u32 = 1u32;
10282 pub const CMSG_MAIL_LIST_RECIPIENT: u32 = 3u32;
10283 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10284 #[repr(C)]
10285 #[cfg(feature = "Win32_Foundation")]
10286 pub struct CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO {
10287     pub cbSize: u32,
10288     pub KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
10289     pub pvKeyEncryptionAuxInfo: *mut ::std::ffi::c_void,
10290     pub hCryptProv: usize,
10291     pub dwKeyChoice: u32,
10292     pub Anonymous: CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO_0,
10293     pub KeyId: CRYPTOAPI_BLOB,
10294     pub Date: super::super::Foundation::FILETIME,
10295     pub pOtherAttr: *mut CRYPT_ATTRIBUTE_TYPE_VALUE,
10296 }
10297 #[cfg(feature = "Win32_Foundation")]
10298 impl CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO {}
10299 #[cfg(feature = "Win32_Foundation")]
10300 impl ::std::default::Default for CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO {
default() -> Self10301     fn default() -> Self {
10302         unsafe { ::std::mem::zeroed() }
10303     }
10304 }
10305 #[cfg(feature = "Win32_Foundation")]
10306 impl ::std::cmp::PartialEq for CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO {
eq(&self, _other: &Self) -> bool10307     fn eq(&self, _other: &Self) -> bool {
10308         unimplemented!()
10309     }
10310 }
10311 #[cfg(feature = "Win32_Foundation")]
10312 impl ::std::cmp::Eq for CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO {}
10313 #[cfg(feature = "Win32_Foundation")]
10314 unsafe impl ::windows::runtime::Abi for CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO {
10315     type Abi = Self;
10316     type DefaultType = Self;
10317 }
10318 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10319 #[repr(C)]
10320 pub union CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO_0 {
10321     pub hKeyEncryptionKey: usize,
10322     pub pvKeyEncryptionKey: *mut ::std::ffi::c_void,
10323 }
10324 impl CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO_0 {}
10325 impl ::std::default::Default for CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO_0 {
default() -> Self10326     fn default() -> Self {
10327         unsafe { ::std::mem::zeroed() }
10328     }
10329 }
10330 impl ::std::cmp::PartialEq for CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO_0 {
eq(&self, _other: &Self) -> bool10331     fn eq(&self, _other: &Self) -> bool {
10332         unimplemented!()
10333     }
10334 }
10335 impl ::std::cmp::Eq for CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO_0 {}
10336 unsafe impl ::windows::runtime::Abi for CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO_0 {
10337     type Abi = Self;
10338     type DefaultType = Self;
10339 }
10340 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10341 #[repr(C)]
10342 #[cfg(feature = "Win32_Foundation")]
10343 pub struct CMSG_MAIL_LIST_RECIPIENT_INFO {
10344     pub dwVersion: u32,
10345     pub KeyId: CRYPTOAPI_BLOB,
10346     pub KeyEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
10347     pub EncryptedKey: CRYPTOAPI_BLOB,
10348     pub Date: super::super::Foundation::FILETIME,
10349     pub pOtherAttr: *mut CRYPT_ATTRIBUTE_TYPE_VALUE,
10350 }
10351 #[cfg(feature = "Win32_Foundation")]
10352 impl CMSG_MAIL_LIST_RECIPIENT_INFO {}
10353 #[cfg(feature = "Win32_Foundation")]
10354 impl ::std::default::Default for CMSG_MAIL_LIST_RECIPIENT_INFO {
default() -> Self10355     fn default() -> Self {
10356         unsafe { ::std::mem::zeroed() }
10357     }
10358 }
10359 #[cfg(feature = "Win32_Foundation")]
10360 impl ::std::fmt::Debug for CMSG_MAIL_LIST_RECIPIENT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10361     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10362         fmt.debug_struct("CMSG_MAIL_LIST_RECIPIENT_INFO").field("dwVersion", &self.dwVersion).field("KeyId", &self.KeyId).field("KeyEncryptionAlgorithm", &self.KeyEncryptionAlgorithm).field("EncryptedKey", &self.EncryptedKey).field("Date", &self.Date).field("pOtherAttr", &self.pOtherAttr).finish()
10363     }
10364 }
10365 #[cfg(feature = "Win32_Foundation")]
10366 impl ::std::cmp::PartialEq for CMSG_MAIL_LIST_RECIPIENT_INFO {
eq(&self, other: &Self) -> bool10367     fn eq(&self, other: &Self) -> bool {
10368         self.dwVersion == other.dwVersion && self.KeyId == other.KeyId && self.KeyEncryptionAlgorithm == other.KeyEncryptionAlgorithm && self.EncryptedKey == other.EncryptedKey && self.Date == other.Date && self.pOtherAttr == other.pOtherAttr
10369     }
10370 }
10371 #[cfg(feature = "Win32_Foundation")]
10372 impl ::std::cmp::Eq for CMSG_MAIL_LIST_RECIPIENT_INFO {}
10373 #[cfg(feature = "Win32_Foundation")]
10374 unsafe impl ::windows::runtime::Abi for CMSG_MAIL_LIST_RECIPIENT_INFO {
10375     type Abi = Self;
10376     type DefaultType = Self;
10377 }
10378 pub const CMSG_MAIL_LIST_VERSION: u32 = 4u32;
10379 pub const CMSG_MAX_LENGTH_FLAG: u32 = 32u32;
10380 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10381 #[repr(C)]
10382 pub struct CMSG_RC2_AUX_INFO {
10383     pub cbSize: u32,
10384     pub dwBitLen: u32,
10385 }
10386 impl CMSG_RC2_AUX_INFO {}
10387 impl ::std::default::Default for CMSG_RC2_AUX_INFO {
default() -> Self10388     fn default() -> Self {
10389         unsafe { ::std::mem::zeroed() }
10390     }
10391 }
10392 impl ::std::fmt::Debug for CMSG_RC2_AUX_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10393     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10394         fmt.debug_struct("CMSG_RC2_AUX_INFO").field("cbSize", &self.cbSize).field("dwBitLen", &self.dwBitLen).finish()
10395     }
10396 }
10397 impl ::std::cmp::PartialEq for CMSG_RC2_AUX_INFO {
eq(&self, other: &Self) -> bool10398     fn eq(&self, other: &Self) -> bool {
10399         self.cbSize == other.cbSize && self.dwBitLen == other.dwBitLen
10400     }
10401 }
10402 impl ::std::cmp::Eq for CMSG_RC2_AUX_INFO {}
10403 unsafe impl ::windows::runtime::Abi for CMSG_RC2_AUX_INFO {
10404     type Abi = Self;
10405     type DefaultType = Self;
10406 }
10407 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10408 #[repr(C)]
10409 pub struct CMSG_RC4_AUX_INFO {
10410     pub cbSize: u32,
10411     pub dwBitLen: u32,
10412 }
10413 impl CMSG_RC4_AUX_INFO {}
10414 impl ::std::default::Default for CMSG_RC4_AUX_INFO {
default() -> Self10415     fn default() -> Self {
10416         unsafe { ::std::mem::zeroed() }
10417     }
10418 }
10419 impl ::std::fmt::Debug for CMSG_RC4_AUX_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10420     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10421         fmt.debug_struct("CMSG_RC4_AUX_INFO").field("cbSize", &self.cbSize).field("dwBitLen", &self.dwBitLen).finish()
10422     }
10423 }
10424 impl ::std::cmp::PartialEq for CMSG_RC4_AUX_INFO {
eq(&self, other: &Self) -> bool10425     fn eq(&self, other: &Self) -> bool {
10426         self.cbSize == other.cbSize && self.dwBitLen == other.dwBitLen
10427     }
10428 }
10429 impl ::std::cmp::Eq for CMSG_RC4_AUX_INFO {}
10430 unsafe impl ::windows::runtime::Abi for CMSG_RC4_AUX_INFO {
10431     type Abi = Self;
10432     type DefaultType = Self;
10433 }
10434 pub const CMSG_RC4_NO_SALT_FLAG: u32 = 1073741824u32;
10435 pub const CMSG_RECIPIENT_COUNT_PARAM: u32 = 17u32;
10436 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10437 #[repr(C)]
10438 #[cfg(feature = "Win32_Foundation")]
10439 pub struct CMSG_RECIPIENT_ENCODE_INFO {
10440     pub dwRecipientChoice: u32,
10441     pub Anonymous: CMSG_RECIPIENT_ENCODE_INFO_0,
10442 }
10443 #[cfg(feature = "Win32_Foundation")]
10444 impl CMSG_RECIPIENT_ENCODE_INFO {}
10445 #[cfg(feature = "Win32_Foundation")]
10446 impl ::std::default::Default for CMSG_RECIPIENT_ENCODE_INFO {
default() -> Self10447     fn default() -> Self {
10448         unsafe { ::std::mem::zeroed() }
10449     }
10450 }
10451 #[cfg(feature = "Win32_Foundation")]
10452 impl ::std::cmp::PartialEq for CMSG_RECIPIENT_ENCODE_INFO {
eq(&self, _other: &Self) -> bool10453     fn eq(&self, _other: &Self) -> bool {
10454         unimplemented!()
10455     }
10456 }
10457 #[cfg(feature = "Win32_Foundation")]
10458 impl ::std::cmp::Eq for CMSG_RECIPIENT_ENCODE_INFO {}
10459 #[cfg(feature = "Win32_Foundation")]
10460 unsafe impl ::windows::runtime::Abi for CMSG_RECIPIENT_ENCODE_INFO {
10461     type Abi = Self;
10462     type DefaultType = Self;
10463 }
10464 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10465 #[repr(C)]
10466 #[cfg(feature = "Win32_Foundation")]
10467 pub union CMSG_RECIPIENT_ENCODE_INFO_0 {
10468     pub pKeyTrans: *mut CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO,
10469     pub pKeyAgree: *mut CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO,
10470     pub pMailList: *mut CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO,
10471 }
10472 #[cfg(feature = "Win32_Foundation")]
10473 impl CMSG_RECIPIENT_ENCODE_INFO_0 {}
10474 #[cfg(feature = "Win32_Foundation")]
10475 impl ::std::default::Default for CMSG_RECIPIENT_ENCODE_INFO_0 {
default() -> Self10476     fn default() -> Self {
10477         unsafe { ::std::mem::zeroed() }
10478     }
10479 }
10480 #[cfg(feature = "Win32_Foundation")]
10481 impl ::std::cmp::PartialEq for CMSG_RECIPIENT_ENCODE_INFO_0 {
eq(&self, _other: &Self) -> bool10482     fn eq(&self, _other: &Self) -> bool {
10483         unimplemented!()
10484     }
10485 }
10486 #[cfg(feature = "Win32_Foundation")]
10487 impl ::std::cmp::Eq for CMSG_RECIPIENT_ENCODE_INFO_0 {}
10488 #[cfg(feature = "Win32_Foundation")]
10489 unsafe impl ::windows::runtime::Abi for CMSG_RECIPIENT_ENCODE_INFO_0 {
10490     type Abi = Self;
10491     type DefaultType = Self;
10492 }
10493 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10494 #[repr(C)]
10495 #[cfg(feature = "Win32_Foundation")]
10496 pub struct CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO {
10497     pub cbSize: u32,
10498     pub RecipientPublicKey: CRYPT_BIT_BLOB,
10499     pub RecipientId: CERT_ID,
10500     pub Date: super::super::Foundation::FILETIME,
10501     pub pOtherAttr: *mut CRYPT_ATTRIBUTE_TYPE_VALUE,
10502 }
10503 #[cfg(feature = "Win32_Foundation")]
10504 impl CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO {}
10505 #[cfg(feature = "Win32_Foundation")]
10506 impl ::std::default::Default for CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO {
default() -> Self10507     fn default() -> Self {
10508         unsafe { ::std::mem::zeroed() }
10509     }
10510 }
10511 #[cfg(feature = "Win32_Foundation")]
10512 impl ::std::cmp::PartialEq for CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO {
eq(&self, _other: &Self) -> bool10513     fn eq(&self, _other: &Self) -> bool {
10514         unimplemented!()
10515     }
10516 }
10517 #[cfg(feature = "Win32_Foundation")]
10518 impl ::std::cmp::Eq for CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO {}
10519 #[cfg(feature = "Win32_Foundation")]
10520 unsafe impl ::windows::runtime::Abi for CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO {
10521     type Abi = Self;
10522     type DefaultType = Self;
10523 }
10524 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10525 #[repr(C)]
10526 #[cfg(feature = "Win32_Foundation")]
10527 pub struct CMSG_RECIPIENT_ENCRYPTED_KEY_INFO {
10528     pub RecipientId: CERT_ID,
10529     pub EncryptedKey: CRYPTOAPI_BLOB,
10530     pub Date: super::super::Foundation::FILETIME,
10531     pub pOtherAttr: *mut CRYPT_ATTRIBUTE_TYPE_VALUE,
10532 }
10533 #[cfg(feature = "Win32_Foundation")]
10534 impl CMSG_RECIPIENT_ENCRYPTED_KEY_INFO {}
10535 #[cfg(feature = "Win32_Foundation")]
10536 impl ::std::default::Default for CMSG_RECIPIENT_ENCRYPTED_KEY_INFO {
default() -> Self10537     fn default() -> Self {
10538         unsafe { ::std::mem::zeroed() }
10539     }
10540 }
10541 #[cfg(feature = "Win32_Foundation")]
10542 impl ::std::cmp::PartialEq for CMSG_RECIPIENT_ENCRYPTED_KEY_INFO {
eq(&self, _other: &Self) -> bool10543     fn eq(&self, _other: &Self) -> bool {
10544         unimplemented!()
10545     }
10546 }
10547 #[cfg(feature = "Win32_Foundation")]
10548 impl ::std::cmp::Eq for CMSG_RECIPIENT_ENCRYPTED_KEY_INFO {}
10549 #[cfg(feature = "Win32_Foundation")]
10550 unsafe impl ::windows::runtime::Abi for CMSG_RECIPIENT_ENCRYPTED_KEY_INFO {
10551     type Abi = Self;
10552     type DefaultType = Self;
10553 }
10554 pub const CMSG_RECIPIENT_INDEX_PARAM: u32 = 18u32;
10555 pub const CMSG_RECIPIENT_INFO_PARAM: u32 = 19u32;
10556 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10557 #[repr(C)]
10558 #[cfg(feature = "Win32_Foundation")]
10559 pub struct CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO {
10560     pub cbSize: u32,
10561     pub SignedInfo: CMSG_SIGNED_ENCODE_INFO,
10562     pub EnvelopedInfo: CMSG_ENVELOPED_ENCODE_INFO,
10563 }
10564 #[cfg(feature = "Win32_Foundation")]
10565 impl CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO {}
10566 #[cfg(feature = "Win32_Foundation")]
10567 impl ::std::default::Default for CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO {
default() -> Self10568     fn default() -> Self {
10569         unsafe { ::std::mem::zeroed() }
10570     }
10571 }
10572 #[cfg(feature = "Win32_Foundation")]
10573 impl ::std::fmt::Debug for CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10574     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10575         fmt.debug_struct("CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO").field("cbSize", &self.cbSize).field("SignedInfo", &self.SignedInfo).field("EnvelopedInfo", &self.EnvelopedInfo).finish()
10576     }
10577 }
10578 #[cfg(feature = "Win32_Foundation")]
10579 impl ::std::cmp::PartialEq for CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO {
eq(&self, other: &Self) -> bool10580     fn eq(&self, other: &Self) -> bool {
10581         self.cbSize == other.cbSize && self.SignedInfo == other.SignedInfo && self.EnvelopedInfo == other.EnvelopedInfo
10582     }
10583 }
10584 #[cfg(feature = "Win32_Foundation")]
10585 impl ::std::cmp::Eq for CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO {}
10586 #[cfg(feature = "Win32_Foundation")]
10587 unsafe impl ::windows::runtime::Abi for CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO {
10588     type Abi = Self;
10589     type DefaultType = Self;
10590 }
10591 pub const CMSG_SIGNED_DATA_CMS_VERSION: u32 = 3u32;
10592 pub const CMSG_SIGNED_DATA_NO_SIGN_FLAG: u32 = 128u32;
10593 pub const CMSG_SIGNED_DATA_PKCS_1_5_VERSION: u32 = 1u32;
10594 pub const CMSG_SIGNED_DATA_V1: u32 = 1u32;
10595 pub const CMSG_SIGNED_DATA_V3: u32 = 3u32;
10596 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10597 #[repr(C)]
10598 #[cfg(feature = "Win32_Foundation")]
10599 pub struct CMSG_SIGNED_ENCODE_INFO {
10600     pub cbSize: u32,
10601     pub cSigners: u32,
10602     pub rgSigners: *mut CMSG_SIGNER_ENCODE_INFO,
10603     pub cCertEncoded: u32,
10604     pub rgCertEncoded: *mut CRYPTOAPI_BLOB,
10605     pub cCrlEncoded: u32,
10606     pub rgCrlEncoded: *mut CRYPTOAPI_BLOB,
10607 }
10608 #[cfg(feature = "Win32_Foundation")]
10609 impl CMSG_SIGNED_ENCODE_INFO {}
10610 #[cfg(feature = "Win32_Foundation")]
10611 impl ::std::default::Default for CMSG_SIGNED_ENCODE_INFO {
default() -> Self10612     fn default() -> Self {
10613         unsafe { ::std::mem::zeroed() }
10614     }
10615 }
10616 #[cfg(feature = "Win32_Foundation")]
10617 impl ::std::fmt::Debug for CMSG_SIGNED_ENCODE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10618     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10619         fmt.debug_struct("CMSG_SIGNED_ENCODE_INFO")
10620             .field("cbSize", &self.cbSize)
10621             .field("cSigners", &self.cSigners)
10622             .field("rgSigners", &self.rgSigners)
10623             .field("cCertEncoded", &self.cCertEncoded)
10624             .field("rgCertEncoded", &self.rgCertEncoded)
10625             .field("cCrlEncoded", &self.cCrlEncoded)
10626             .field("rgCrlEncoded", &self.rgCrlEncoded)
10627             .finish()
10628     }
10629 }
10630 #[cfg(feature = "Win32_Foundation")]
10631 impl ::std::cmp::PartialEq for CMSG_SIGNED_ENCODE_INFO {
eq(&self, other: &Self) -> bool10632     fn eq(&self, other: &Self) -> bool {
10633         self.cbSize == other.cbSize && self.cSigners == other.cSigners && self.rgSigners == other.rgSigners && self.cCertEncoded == other.cCertEncoded && self.rgCertEncoded == other.rgCertEncoded && self.cCrlEncoded == other.cCrlEncoded && self.rgCrlEncoded == other.rgCrlEncoded
10634     }
10635 }
10636 #[cfg(feature = "Win32_Foundation")]
10637 impl ::std::cmp::Eq for CMSG_SIGNED_ENCODE_INFO {}
10638 #[cfg(feature = "Win32_Foundation")]
10639 unsafe impl ::windows::runtime::Abi for CMSG_SIGNED_ENCODE_INFO {
10640     type Abi = Self;
10641     type DefaultType = Self;
10642 }
10643 pub const CMSG_SIGNER_AUTH_ATTR_PARAM: u32 = 9u32;
10644 pub const CMSG_SIGNER_CERT_ID_PARAM: u32 = 38u32;
10645 pub const CMSG_SIGNER_CERT_INFO_PARAM: u32 = 7u32;
10646 pub const CMSG_SIGNER_COUNT_PARAM: u32 = 5u32;
10647 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10648 #[repr(C)]
10649 #[cfg(feature = "Win32_Foundation")]
10650 pub struct CMSG_SIGNER_ENCODE_INFO {
10651     pub cbSize: u32,
10652     pub pCertInfo: *mut CERT_INFO,
10653     pub Anonymous: CMSG_SIGNER_ENCODE_INFO_0,
10654     pub dwKeySpec: u32,
10655     pub HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
10656     pub pvHashAuxInfo: *mut ::std::ffi::c_void,
10657     pub cAuthAttr: u32,
10658     pub rgAuthAttr: *mut CRYPT_ATTRIBUTE,
10659     pub cUnauthAttr: u32,
10660     pub rgUnauthAttr: *mut CRYPT_ATTRIBUTE,
10661 }
10662 #[cfg(feature = "Win32_Foundation")]
10663 impl CMSG_SIGNER_ENCODE_INFO {}
10664 #[cfg(feature = "Win32_Foundation")]
10665 impl ::std::default::Default for CMSG_SIGNER_ENCODE_INFO {
default() -> Self10666     fn default() -> Self {
10667         unsafe { ::std::mem::zeroed() }
10668     }
10669 }
10670 #[cfg(feature = "Win32_Foundation")]
10671 impl ::std::cmp::PartialEq for CMSG_SIGNER_ENCODE_INFO {
eq(&self, _other: &Self) -> bool10672     fn eq(&self, _other: &Self) -> bool {
10673         unimplemented!()
10674     }
10675 }
10676 #[cfg(feature = "Win32_Foundation")]
10677 impl ::std::cmp::Eq for CMSG_SIGNER_ENCODE_INFO {}
10678 #[cfg(feature = "Win32_Foundation")]
10679 unsafe impl ::windows::runtime::Abi for CMSG_SIGNER_ENCODE_INFO {
10680     type Abi = Self;
10681     type DefaultType = Self;
10682 }
10683 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10684 #[repr(C)]
10685 pub union CMSG_SIGNER_ENCODE_INFO_0 {
10686     pub hCryptProv: usize,
10687     pub hNCryptKey: usize,
10688 }
10689 impl CMSG_SIGNER_ENCODE_INFO_0 {}
10690 impl ::std::default::Default for CMSG_SIGNER_ENCODE_INFO_0 {
default() -> Self10691     fn default() -> Self {
10692         unsafe { ::std::mem::zeroed() }
10693     }
10694 }
10695 impl ::std::cmp::PartialEq for CMSG_SIGNER_ENCODE_INFO_0 {
eq(&self, _other: &Self) -> bool10696     fn eq(&self, _other: &Self) -> bool {
10697         unimplemented!()
10698     }
10699 }
10700 impl ::std::cmp::Eq for CMSG_SIGNER_ENCODE_INFO_0 {}
10701 unsafe impl ::windows::runtime::Abi for CMSG_SIGNER_ENCODE_INFO_0 {
10702     type Abi = Self;
10703     type DefaultType = Self;
10704 }
10705 pub const CMSG_SIGNER_HASH_ALGORITHM_PARAM: u32 = 8u32;
10706 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10707 #[repr(C)]
10708 #[cfg(feature = "Win32_Foundation")]
10709 pub struct CMSG_SIGNER_INFO {
10710     pub dwVersion: u32,
10711     pub Issuer: CRYPTOAPI_BLOB,
10712     pub SerialNumber: CRYPTOAPI_BLOB,
10713     pub HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
10714     pub HashEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
10715     pub EncryptedHash: CRYPTOAPI_BLOB,
10716     pub AuthAttrs: CRYPT_ATTRIBUTES,
10717     pub UnauthAttrs: CRYPT_ATTRIBUTES,
10718 }
10719 #[cfg(feature = "Win32_Foundation")]
10720 impl CMSG_SIGNER_INFO {}
10721 #[cfg(feature = "Win32_Foundation")]
10722 impl ::std::default::Default for CMSG_SIGNER_INFO {
default() -> Self10723     fn default() -> Self {
10724         unsafe { ::std::mem::zeroed() }
10725     }
10726 }
10727 #[cfg(feature = "Win32_Foundation")]
10728 impl ::std::fmt::Debug for CMSG_SIGNER_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10729     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10730         fmt.debug_struct("CMSG_SIGNER_INFO")
10731             .field("dwVersion", &self.dwVersion)
10732             .field("Issuer", &self.Issuer)
10733             .field("SerialNumber", &self.SerialNumber)
10734             .field("HashAlgorithm", &self.HashAlgorithm)
10735             .field("HashEncryptionAlgorithm", &self.HashEncryptionAlgorithm)
10736             .field("EncryptedHash", &self.EncryptedHash)
10737             .field("AuthAttrs", &self.AuthAttrs)
10738             .field("UnauthAttrs", &self.UnauthAttrs)
10739             .finish()
10740     }
10741 }
10742 #[cfg(feature = "Win32_Foundation")]
10743 impl ::std::cmp::PartialEq for CMSG_SIGNER_INFO {
eq(&self, other: &Self) -> bool10744     fn eq(&self, other: &Self) -> bool {
10745         self.dwVersion == other.dwVersion && self.Issuer == other.Issuer && self.SerialNumber == other.SerialNumber && self.HashAlgorithm == other.HashAlgorithm && self.HashEncryptionAlgorithm == other.HashEncryptionAlgorithm && self.EncryptedHash == other.EncryptedHash && self.AuthAttrs == other.AuthAttrs && self.UnauthAttrs == other.UnauthAttrs
10746     }
10747 }
10748 #[cfg(feature = "Win32_Foundation")]
10749 impl ::std::cmp::Eq for CMSG_SIGNER_INFO {}
10750 #[cfg(feature = "Win32_Foundation")]
10751 unsafe impl ::windows::runtime::Abi for CMSG_SIGNER_INFO {
10752     type Abi = Self;
10753     type DefaultType = Self;
10754 }
10755 pub const CMSG_SIGNER_INFO_CMS_VERSION: u32 = 3u32;
10756 pub const CMSG_SIGNER_INFO_PARAM: u32 = 6u32;
10757 pub const CMSG_SIGNER_INFO_PKCS_1_5_VERSION: u32 = 1u32;
10758 pub const CMSG_SIGNER_INFO_V1: u32 = 1u32;
10759 pub const CMSG_SIGNER_INFO_V3: u32 = 3u32;
10760 pub const CMSG_SIGNER_ONLY_FLAG: u32 = 2u32;
10761 pub const CMSG_SIGNER_UNAUTH_ATTR_PARAM: u32 = 10u32;
10762 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10763 #[repr(C)]
10764 pub struct CMSG_SP3_COMPATIBLE_AUX_INFO {
10765     pub cbSize: u32,
10766     pub dwFlags: u32,
10767 }
10768 impl CMSG_SP3_COMPATIBLE_AUX_INFO {}
10769 impl ::std::default::Default for CMSG_SP3_COMPATIBLE_AUX_INFO {
default() -> Self10770     fn default() -> Self {
10771         unsafe { ::std::mem::zeroed() }
10772     }
10773 }
10774 impl ::std::fmt::Debug for CMSG_SP3_COMPATIBLE_AUX_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10775     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10776         fmt.debug_struct("CMSG_SP3_COMPATIBLE_AUX_INFO").field("cbSize", &self.cbSize).field("dwFlags", &self.dwFlags).finish()
10777     }
10778 }
10779 impl ::std::cmp::PartialEq for CMSG_SP3_COMPATIBLE_AUX_INFO {
eq(&self, other: &Self) -> bool10780     fn eq(&self, other: &Self) -> bool {
10781         self.cbSize == other.cbSize && self.dwFlags == other.dwFlags
10782     }
10783 }
10784 impl ::std::cmp::Eq for CMSG_SP3_COMPATIBLE_AUX_INFO {}
10785 unsafe impl ::windows::runtime::Abi for CMSG_SP3_COMPATIBLE_AUX_INFO {
10786     type Abi = Self;
10787     type DefaultType = Self;
10788 }
10789 pub const CMSG_SP3_COMPATIBLE_ENCRYPT_FLAG: u32 = 2147483648u32;
10790 #[derive(:: std :: clone :: Clone)]
10791 #[repr(C)]
10792 #[cfg(feature = "Win32_Foundation")]
10793 pub struct CMSG_STREAM_INFO {
10794     pub cbContent: u32,
10795     pub pfnStreamOutput: ::std::option::Option<PFN_CMSG_STREAM_OUTPUT>,
10796     pub pvArg: *mut ::std::ffi::c_void,
10797 }
10798 #[cfg(feature = "Win32_Foundation")]
10799 impl CMSG_STREAM_INFO {}
10800 #[cfg(feature = "Win32_Foundation")]
10801 impl ::std::default::Default for CMSG_STREAM_INFO {
default() -> Self10802     fn default() -> Self {
10803         unsafe { ::std::mem::zeroed() }
10804     }
10805 }
10806 #[cfg(feature = "Win32_Foundation")]
10807 impl ::std::fmt::Debug for CMSG_STREAM_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10808     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10809         fmt.debug_struct("CMSG_STREAM_INFO").field("cbContent", &self.cbContent).field("pvArg", &self.pvArg).finish()
10810     }
10811 }
10812 #[cfg(feature = "Win32_Foundation")]
10813 impl ::std::cmp::PartialEq for CMSG_STREAM_INFO {
eq(&self, other: &Self) -> bool10814     fn eq(&self, other: &Self) -> bool {
10815         self.cbContent == other.cbContent && self.pfnStreamOutput.map(|f| f as usize) == other.pfnStreamOutput.map(|f| f as usize) && self.pvArg == other.pvArg
10816     }
10817 }
10818 #[cfg(feature = "Win32_Foundation")]
10819 impl ::std::cmp::Eq for CMSG_STREAM_INFO {}
10820 #[cfg(feature = "Win32_Foundation")]
10821 unsafe impl ::windows::runtime::Abi for CMSG_STREAM_INFO {
10822     type Abi = ::std::mem::ManuallyDrop<Self>;
10823     type DefaultType = Self;
10824 }
10825 pub const CMSG_TRUSTED_SIGNER_FLAG: u32 = 1u32;
10826 pub const CMSG_TYPE_PARAM: u32 = 1u32;
10827 pub const CMSG_UNPROTECTED_ATTR_PARAM: u32 = 37u32;
10828 pub const CMSG_USE_SIGNER_INDEX_FLAG: u32 = 4u32;
10829 pub const CMSG_VERIFY_COUNTER_SIGN_ENABLE_STRONG_FLAG: u32 = 1u32;
10830 pub const CMSG_VERIFY_SIGNER_CERT: u32 = 2u32;
10831 pub const CMSG_VERIFY_SIGNER_CHAIN: u32 = 3u32;
10832 pub const CMSG_VERIFY_SIGNER_NULL: u32 = 4u32;
10833 pub const CMSG_VERIFY_SIGNER_PUBKEY: u32 = 1u32;
10834 pub const CMSG_VERSION_PARAM: u32 = 30u32;
10835 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10836 #[repr(C)]
10837 #[cfg(feature = "Win32_Foundation")]
10838 pub struct CMS_DH_KEY_INFO {
10839     pub dwVersion: u32,
10840     pub Algid: u32,
10841     pub pszContentEncObjId: super::super::Foundation::PSTR,
10842     pub PubInfo: CRYPTOAPI_BLOB,
10843     pub pReserved: *mut ::std::ffi::c_void,
10844 }
10845 #[cfg(feature = "Win32_Foundation")]
10846 impl CMS_DH_KEY_INFO {}
10847 #[cfg(feature = "Win32_Foundation")]
10848 impl ::std::default::Default for CMS_DH_KEY_INFO {
default() -> Self10849     fn default() -> Self {
10850         unsafe { ::std::mem::zeroed() }
10851     }
10852 }
10853 #[cfg(feature = "Win32_Foundation")]
10854 impl ::std::fmt::Debug for CMS_DH_KEY_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10855     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10856         fmt.debug_struct("CMS_DH_KEY_INFO").field("dwVersion", &self.dwVersion).field("Algid", &self.Algid).field("pszContentEncObjId", &self.pszContentEncObjId).field("PubInfo", &self.PubInfo).field("pReserved", &self.pReserved).finish()
10857     }
10858 }
10859 #[cfg(feature = "Win32_Foundation")]
10860 impl ::std::cmp::PartialEq for CMS_DH_KEY_INFO {
eq(&self, other: &Self) -> bool10861     fn eq(&self, other: &Self) -> bool {
10862         self.dwVersion == other.dwVersion && self.Algid == other.Algid && self.pszContentEncObjId == other.pszContentEncObjId && self.PubInfo == other.PubInfo && self.pReserved == other.pReserved
10863     }
10864 }
10865 #[cfg(feature = "Win32_Foundation")]
10866 impl ::std::cmp::Eq for CMS_DH_KEY_INFO {}
10867 #[cfg(feature = "Win32_Foundation")]
10868 unsafe impl ::windows::runtime::Abi for CMS_DH_KEY_INFO {
10869     type Abi = Self;
10870     type DefaultType = Self;
10871 }
10872 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10873 #[repr(C)]
10874 pub struct CMS_KEY_INFO {
10875     pub dwVersion: u32,
10876     pub Algid: u32,
10877     pub pbOID: *mut u8,
10878     pub cbOID: u32,
10879 }
10880 impl CMS_KEY_INFO {}
10881 impl ::std::default::Default for CMS_KEY_INFO {
default() -> Self10882     fn default() -> Self {
10883         unsafe { ::std::mem::zeroed() }
10884     }
10885 }
10886 impl ::std::fmt::Debug for CMS_KEY_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10887     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10888         fmt.debug_struct("CMS_KEY_INFO").field("dwVersion", &self.dwVersion).field("Algid", &self.Algid).field("pbOID", &self.pbOID).field("cbOID", &self.cbOID).finish()
10889     }
10890 }
10891 impl ::std::cmp::PartialEq for CMS_KEY_INFO {
eq(&self, other: &Self) -> bool10892     fn eq(&self, other: &Self) -> bool {
10893         self.dwVersion == other.dwVersion && self.Algid == other.Algid && self.pbOID == other.pbOID && self.cbOID == other.cbOID
10894     }
10895 }
10896 impl ::std::cmp::Eq for CMS_KEY_INFO {}
10897 unsafe impl ::windows::runtime::Abi for CMS_KEY_INFO {
10898     type Abi = Self;
10899     type DefaultType = Self;
10900 }
10901 pub const CM_VIEWFLAGS_MASK: u32 = 16777215u32;
10902 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10903 #[repr(C)]
10904 #[cfg(feature = "Win32_Foundation")]
10905 pub struct CPS_URLS {
10906     pub pszURL: super::super::Foundation::PWSTR,
10907     pub pAlgorithm: *mut CRYPT_ALGORITHM_IDENTIFIER,
10908     pub pDigest: *mut CRYPTOAPI_BLOB,
10909 }
10910 #[cfg(feature = "Win32_Foundation")]
10911 impl CPS_URLS {}
10912 #[cfg(feature = "Win32_Foundation")]
10913 impl ::std::default::Default for CPS_URLS {
default() -> Self10914     fn default() -> Self {
10915         unsafe { ::std::mem::zeroed() }
10916     }
10917 }
10918 #[cfg(feature = "Win32_Foundation")]
10919 impl ::std::fmt::Debug for CPS_URLS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10920     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10921         fmt.debug_struct("CPS_URLS").field("pszURL", &self.pszURL).field("pAlgorithm", &self.pAlgorithm).field("pDigest", &self.pDigest).finish()
10922     }
10923 }
10924 #[cfg(feature = "Win32_Foundation")]
10925 impl ::std::cmp::PartialEq for CPS_URLS {
eq(&self, other: &Self) -> bool10926     fn eq(&self, other: &Self) -> bool {
10927         self.pszURL == other.pszURL && self.pAlgorithm == other.pAlgorithm && self.pDigest == other.pDigest
10928     }
10929 }
10930 #[cfg(feature = "Win32_Foundation")]
10931 impl ::std::cmp::Eq for CPS_URLS {}
10932 #[cfg(feature = "Win32_Foundation")]
10933 unsafe impl ::windows::runtime::Abi for CPS_URLS {
10934     type Abi = Self;
10935     type DefaultType = Self;
10936 }
10937 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10938 #[repr(C)]
10939 #[cfg(feature = "Win32_Foundation")]
10940 pub struct CRL_CONTEXT {
10941     pub dwCertEncodingType: u32,
10942     pub pbCrlEncoded: *mut u8,
10943     pub cbCrlEncoded: u32,
10944     pub pCrlInfo: *mut CRL_INFO,
10945     pub hCertStore: *mut ::std::ffi::c_void,
10946 }
10947 #[cfg(feature = "Win32_Foundation")]
10948 impl CRL_CONTEXT {}
10949 #[cfg(feature = "Win32_Foundation")]
10950 impl ::std::default::Default for CRL_CONTEXT {
default() -> Self10951     fn default() -> Self {
10952         unsafe { ::std::mem::zeroed() }
10953     }
10954 }
10955 #[cfg(feature = "Win32_Foundation")]
10956 impl ::std::fmt::Debug for CRL_CONTEXT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10957     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10958         fmt.debug_struct("CRL_CONTEXT").field("dwCertEncodingType", &self.dwCertEncodingType).field("pbCrlEncoded", &self.pbCrlEncoded).field("cbCrlEncoded", &self.cbCrlEncoded).field("pCrlInfo", &self.pCrlInfo).field("hCertStore", &self.hCertStore).finish()
10959     }
10960 }
10961 #[cfg(feature = "Win32_Foundation")]
10962 impl ::std::cmp::PartialEq for CRL_CONTEXT {
eq(&self, other: &Self) -> bool10963     fn eq(&self, other: &Self) -> bool {
10964         self.dwCertEncodingType == other.dwCertEncodingType && self.pbCrlEncoded == other.pbCrlEncoded && self.cbCrlEncoded == other.cbCrlEncoded && self.pCrlInfo == other.pCrlInfo && self.hCertStore == other.hCertStore
10965     }
10966 }
10967 #[cfg(feature = "Win32_Foundation")]
10968 impl ::std::cmp::Eq for CRL_CONTEXT {}
10969 #[cfg(feature = "Win32_Foundation")]
10970 unsafe impl ::windows::runtime::Abi for CRL_CONTEXT {
10971     type Abi = Self;
10972     type DefaultType = Self;
10973 }
10974 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10975 #[repr(C)]
10976 #[cfg(feature = "Win32_Foundation")]
10977 pub struct CRL_DIST_POINT {
10978     pub DistPointName: CRL_DIST_POINT_NAME,
10979     pub ReasonFlags: CRYPT_BIT_BLOB,
10980     pub CRLIssuer: CERT_ALT_NAME_INFO,
10981 }
10982 #[cfg(feature = "Win32_Foundation")]
10983 impl CRL_DIST_POINT {}
10984 #[cfg(feature = "Win32_Foundation")]
10985 impl ::std::default::Default for CRL_DIST_POINT {
default() -> Self10986     fn default() -> Self {
10987         unsafe { ::std::mem::zeroed() }
10988     }
10989 }
10990 #[cfg(feature = "Win32_Foundation")]
10991 impl ::std::cmp::PartialEq for CRL_DIST_POINT {
eq(&self, _other: &Self) -> bool10992     fn eq(&self, _other: &Self) -> bool {
10993         unimplemented!()
10994     }
10995 }
10996 #[cfg(feature = "Win32_Foundation")]
10997 impl ::std::cmp::Eq for CRL_DIST_POINT {}
10998 #[cfg(feature = "Win32_Foundation")]
10999 unsafe impl ::windows::runtime::Abi for CRL_DIST_POINT {
11000     type Abi = Self;
11001     type DefaultType = Self;
11002 }
11003 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11004 #[repr(C)]
11005 #[cfg(feature = "Win32_Foundation")]
11006 pub struct CRL_DIST_POINTS_INFO {
11007     pub cDistPoint: u32,
11008     pub rgDistPoint: *mut CRL_DIST_POINT,
11009 }
11010 #[cfg(feature = "Win32_Foundation")]
11011 impl CRL_DIST_POINTS_INFO {}
11012 #[cfg(feature = "Win32_Foundation")]
11013 impl ::std::default::Default for CRL_DIST_POINTS_INFO {
default() -> Self11014     fn default() -> Self {
11015         unsafe { ::std::mem::zeroed() }
11016     }
11017 }
11018 #[cfg(feature = "Win32_Foundation")]
11019 impl ::std::fmt::Debug for CRL_DIST_POINTS_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11020     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11021         fmt.debug_struct("CRL_DIST_POINTS_INFO").field("cDistPoint", &self.cDistPoint).field("rgDistPoint", &self.rgDistPoint).finish()
11022     }
11023 }
11024 #[cfg(feature = "Win32_Foundation")]
11025 impl ::std::cmp::PartialEq for CRL_DIST_POINTS_INFO {
eq(&self, other: &Self) -> bool11026     fn eq(&self, other: &Self) -> bool {
11027         self.cDistPoint == other.cDistPoint && self.rgDistPoint == other.rgDistPoint
11028     }
11029 }
11030 #[cfg(feature = "Win32_Foundation")]
11031 impl ::std::cmp::Eq for CRL_DIST_POINTS_INFO {}
11032 #[cfg(feature = "Win32_Foundation")]
11033 unsafe impl ::windows::runtime::Abi for CRL_DIST_POINTS_INFO {
11034     type Abi = Self;
11035     type DefaultType = Self;
11036 }
11037 pub const CRL_DIST_POINT_ERR_CRL_ISSUER_BIT: i32 = -2147483648i32;
11038 pub const CRL_DIST_POINT_ERR_INDEX_MASK: u32 = 127u32;
11039 pub const CRL_DIST_POINT_ERR_INDEX_SHIFT: u32 = 24u32;
11040 pub const CRL_DIST_POINT_FULL_NAME: u32 = 1u32;
11041 pub const CRL_DIST_POINT_ISSUER_RDN_NAME: u32 = 2u32;
11042 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11043 #[repr(C)]
11044 #[cfg(feature = "Win32_Foundation")]
11045 pub struct CRL_DIST_POINT_NAME {
11046     pub dwDistPointNameChoice: u32,
11047     pub Anonymous: CRL_DIST_POINT_NAME_0,
11048 }
11049 #[cfg(feature = "Win32_Foundation")]
11050 impl CRL_DIST_POINT_NAME {}
11051 #[cfg(feature = "Win32_Foundation")]
11052 impl ::std::default::Default for CRL_DIST_POINT_NAME {
default() -> Self11053     fn default() -> Self {
11054         unsafe { ::std::mem::zeroed() }
11055     }
11056 }
11057 #[cfg(feature = "Win32_Foundation")]
11058 impl ::std::cmp::PartialEq for CRL_DIST_POINT_NAME {
eq(&self, _other: &Self) -> bool11059     fn eq(&self, _other: &Self) -> bool {
11060         unimplemented!()
11061     }
11062 }
11063 #[cfg(feature = "Win32_Foundation")]
11064 impl ::std::cmp::Eq for CRL_DIST_POINT_NAME {}
11065 #[cfg(feature = "Win32_Foundation")]
11066 unsafe impl ::windows::runtime::Abi for CRL_DIST_POINT_NAME {
11067     type Abi = Self;
11068     type DefaultType = Self;
11069 }
11070 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11071 #[repr(C)]
11072 #[cfg(feature = "Win32_Foundation")]
11073 pub union CRL_DIST_POINT_NAME_0 {
11074     pub FullName: CERT_ALT_NAME_INFO,
11075 }
11076 #[cfg(feature = "Win32_Foundation")]
11077 impl CRL_DIST_POINT_NAME_0 {}
11078 #[cfg(feature = "Win32_Foundation")]
11079 impl ::std::default::Default for CRL_DIST_POINT_NAME_0 {
default() -> Self11080     fn default() -> Self {
11081         unsafe { ::std::mem::zeroed() }
11082     }
11083 }
11084 #[cfg(feature = "Win32_Foundation")]
11085 impl ::std::cmp::PartialEq for CRL_DIST_POINT_NAME_0 {
eq(&self, _other: &Self) -> bool11086     fn eq(&self, _other: &Self) -> bool {
11087         unimplemented!()
11088     }
11089 }
11090 #[cfg(feature = "Win32_Foundation")]
11091 impl ::std::cmp::Eq for CRL_DIST_POINT_NAME_0 {}
11092 #[cfg(feature = "Win32_Foundation")]
11093 unsafe impl ::windows::runtime::Abi for CRL_DIST_POINT_NAME_0 {
11094     type Abi = Self;
11095     type DefaultType = Self;
11096 }
11097 pub const CRL_DIST_POINT_NO_NAME: u32 = 0u32;
11098 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11099 #[repr(C)]
11100 #[cfg(feature = "Win32_Foundation")]
11101 pub struct CRL_ENTRY {
11102     pub SerialNumber: CRYPTOAPI_BLOB,
11103     pub RevocationDate: super::super::Foundation::FILETIME,
11104     pub cExtension: u32,
11105     pub rgExtension: *mut CERT_EXTENSION,
11106 }
11107 #[cfg(feature = "Win32_Foundation")]
11108 impl CRL_ENTRY {}
11109 #[cfg(feature = "Win32_Foundation")]
11110 impl ::std::default::Default for CRL_ENTRY {
default() -> Self11111     fn default() -> Self {
11112         unsafe { ::std::mem::zeroed() }
11113     }
11114 }
11115 #[cfg(feature = "Win32_Foundation")]
11116 impl ::std::fmt::Debug for CRL_ENTRY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11117     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11118         fmt.debug_struct("CRL_ENTRY").field("SerialNumber", &self.SerialNumber).field("RevocationDate", &self.RevocationDate).field("cExtension", &self.cExtension).field("rgExtension", &self.rgExtension).finish()
11119     }
11120 }
11121 #[cfg(feature = "Win32_Foundation")]
11122 impl ::std::cmp::PartialEq for CRL_ENTRY {
eq(&self, other: &Self) -> bool11123     fn eq(&self, other: &Self) -> bool {
11124         self.SerialNumber == other.SerialNumber && self.RevocationDate == other.RevocationDate && self.cExtension == other.cExtension && self.rgExtension == other.rgExtension
11125     }
11126 }
11127 #[cfg(feature = "Win32_Foundation")]
11128 impl ::std::cmp::Eq for CRL_ENTRY {}
11129 #[cfg(feature = "Win32_Foundation")]
11130 unsafe impl ::windows::runtime::Abi for CRL_ENTRY {
11131     type Abi = Self;
11132     type DefaultType = Self;
11133 }
11134 pub const CRL_FIND_ANY: u32 = 0u32;
11135 pub const CRL_FIND_EXISTING: u32 = 2u32;
11136 pub const CRL_FIND_ISSUED_BY: u32 = 1u32;
11137 pub const CRL_FIND_ISSUED_BY_AKI_FLAG: u32 = 1u32;
11138 pub const CRL_FIND_ISSUED_BY_BASE_FLAG: u32 = 8u32;
11139 pub const CRL_FIND_ISSUED_BY_DELTA_FLAG: u32 = 4u32;
11140 pub const CRL_FIND_ISSUED_BY_SIGNATURE_FLAG: u32 = 2u32;
11141 pub const CRL_FIND_ISSUED_FOR: u32 = 3u32;
11142 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11143 #[repr(C)]
11144 #[cfg(feature = "Win32_Foundation")]
11145 pub struct CRL_FIND_ISSUED_FOR_PARA {
11146     pub pSubjectCert: *mut CERT_CONTEXT,
11147     pub pIssuerCert: *mut CERT_CONTEXT,
11148 }
11149 #[cfg(feature = "Win32_Foundation")]
11150 impl CRL_FIND_ISSUED_FOR_PARA {}
11151 #[cfg(feature = "Win32_Foundation")]
11152 impl ::std::default::Default for CRL_FIND_ISSUED_FOR_PARA {
default() -> Self11153     fn default() -> Self {
11154         unsafe { ::std::mem::zeroed() }
11155     }
11156 }
11157 #[cfg(feature = "Win32_Foundation")]
11158 impl ::std::fmt::Debug for CRL_FIND_ISSUED_FOR_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11159     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11160         fmt.debug_struct("CRL_FIND_ISSUED_FOR_PARA").field("pSubjectCert", &self.pSubjectCert).field("pIssuerCert", &self.pIssuerCert).finish()
11161     }
11162 }
11163 #[cfg(feature = "Win32_Foundation")]
11164 impl ::std::cmp::PartialEq for CRL_FIND_ISSUED_FOR_PARA {
eq(&self, other: &Self) -> bool11165     fn eq(&self, other: &Self) -> bool {
11166         self.pSubjectCert == other.pSubjectCert && self.pIssuerCert == other.pIssuerCert
11167     }
11168 }
11169 #[cfg(feature = "Win32_Foundation")]
11170 impl ::std::cmp::Eq for CRL_FIND_ISSUED_FOR_PARA {}
11171 #[cfg(feature = "Win32_Foundation")]
11172 unsafe impl ::windows::runtime::Abi for CRL_FIND_ISSUED_FOR_PARA {
11173     type Abi = Self;
11174     type DefaultType = Self;
11175 }
11176 pub const CRL_FIND_ISSUED_FOR_SET_STRONG_PROPERTIES_FLAG: u32 = 16u32;
11177 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11178 #[repr(C)]
11179 #[cfg(feature = "Win32_Foundation")]
11180 pub struct CRL_INFO {
11181     pub dwVersion: u32,
11182     pub SignatureAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
11183     pub Issuer: CRYPTOAPI_BLOB,
11184     pub ThisUpdate: super::super::Foundation::FILETIME,
11185     pub NextUpdate: super::super::Foundation::FILETIME,
11186     pub cCRLEntry: u32,
11187     pub rgCRLEntry: *mut CRL_ENTRY,
11188     pub cExtension: u32,
11189     pub rgExtension: *mut CERT_EXTENSION,
11190 }
11191 #[cfg(feature = "Win32_Foundation")]
11192 impl CRL_INFO {}
11193 #[cfg(feature = "Win32_Foundation")]
11194 impl ::std::default::Default for CRL_INFO {
default() -> Self11195     fn default() -> Self {
11196         unsafe { ::std::mem::zeroed() }
11197     }
11198 }
11199 #[cfg(feature = "Win32_Foundation")]
11200 impl ::std::fmt::Debug for CRL_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11201     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11202         fmt.debug_struct("CRL_INFO")
11203             .field("dwVersion", &self.dwVersion)
11204             .field("SignatureAlgorithm", &self.SignatureAlgorithm)
11205             .field("Issuer", &self.Issuer)
11206             .field("ThisUpdate", &self.ThisUpdate)
11207             .field("NextUpdate", &self.NextUpdate)
11208             .field("cCRLEntry", &self.cCRLEntry)
11209             .field("rgCRLEntry", &self.rgCRLEntry)
11210             .field("cExtension", &self.cExtension)
11211             .field("rgExtension", &self.rgExtension)
11212             .finish()
11213     }
11214 }
11215 #[cfg(feature = "Win32_Foundation")]
11216 impl ::std::cmp::PartialEq for CRL_INFO {
eq(&self, other: &Self) -> bool11217     fn eq(&self, other: &Self) -> bool {
11218         self.dwVersion == other.dwVersion && self.SignatureAlgorithm == other.SignatureAlgorithm && self.Issuer == other.Issuer && self.ThisUpdate == other.ThisUpdate && self.NextUpdate == other.NextUpdate && self.cCRLEntry == other.cCRLEntry && self.rgCRLEntry == other.rgCRLEntry && self.cExtension == other.cExtension && self.rgExtension == other.rgExtension
11219     }
11220 }
11221 #[cfg(feature = "Win32_Foundation")]
11222 impl ::std::cmp::Eq for CRL_INFO {}
11223 #[cfg(feature = "Win32_Foundation")]
11224 unsafe impl ::windows::runtime::Abi for CRL_INFO {
11225     type Abi = Self;
11226     type DefaultType = Self;
11227 }
11228 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11229 #[repr(C)]
11230 #[cfg(feature = "Win32_Foundation")]
11231 pub struct CRL_ISSUING_DIST_POINT {
11232     pub DistPointName: CRL_DIST_POINT_NAME,
11233     pub fOnlyContainsUserCerts: super::super::Foundation::BOOL,
11234     pub fOnlyContainsCACerts: super::super::Foundation::BOOL,
11235     pub OnlySomeReasonFlags: CRYPT_BIT_BLOB,
11236     pub fIndirectCRL: super::super::Foundation::BOOL,
11237 }
11238 #[cfg(feature = "Win32_Foundation")]
11239 impl CRL_ISSUING_DIST_POINT {}
11240 #[cfg(feature = "Win32_Foundation")]
11241 impl ::std::default::Default for CRL_ISSUING_DIST_POINT {
default() -> Self11242     fn default() -> Self {
11243         unsafe { ::std::mem::zeroed() }
11244     }
11245 }
11246 #[cfg(feature = "Win32_Foundation")]
11247 impl ::std::cmp::PartialEq for CRL_ISSUING_DIST_POINT {
eq(&self, _other: &Self) -> bool11248     fn eq(&self, _other: &Self) -> bool {
11249         unimplemented!()
11250     }
11251 }
11252 #[cfg(feature = "Win32_Foundation")]
11253 impl ::std::cmp::Eq for CRL_ISSUING_DIST_POINT {}
11254 #[cfg(feature = "Win32_Foundation")]
11255 unsafe impl ::windows::runtime::Abi for CRL_ISSUING_DIST_POINT {
11256     type Abi = Self;
11257     type DefaultType = Self;
11258 }
11259 pub const CRL_REASON_AA_COMPROMISE: u32 = 10u32;
11260 pub const CRL_REASON_AA_COMPROMISE_FLAG: u32 = 128u32;
11261 pub const CRL_REASON_AFFILIATION_CHANGED_FLAG: u32 = 16u32;
11262 pub const CRL_REASON_CA_COMPROMISE_FLAG: u32 = 32u32;
11263 pub const CRL_REASON_CERTIFICATE_HOLD_FLAG: u32 = 2u32;
11264 pub const CRL_REASON_CESSATION_OF_OPERATION_FLAG: u32 = 4u32;
11265 pub const CRL_REASON_KEY_COMPROMISE_FLAG: u32 = 64u32;
11266 pub const CRL_REASON_PRIVILEGE_WITHDRAWN: u32 = 9u32;
11267 pub const CRL_REASON_PRIVILEGE_WITHDRAWN_FLAG: u32 = 1u32;
11268 pub const CRL_REASON_SUPERSEDED_FLAG: u32 = 8u32;
11269 pub const CRL_REASON_UNUSED_FLAG: u32 = 128u32;
11270 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11271 #[repr(C)]
11272 #[cfg(feature = "Win32_Foundation")]
11273 pub struct CRL_REVOCATION_INFO {
11274     pub pCrlEntry: *mut CRL_ENTRY,
11275     pub pCrlContext: *mut CRL_CONTEXT,
11276     pub pCrlIssuerChain: *mut CERT_CHAIN_CONTEXT,
11277 }
11278 #[cfg(feature = "Win32_Foundation")]
11279 impl CRL_REVOCATION_INFO {}
11280 #[cfg(feature = "Win32_Foundation")]
11281 impl ::std::default::Default for CRL_REVOCATION_INFO {
default() -> Self11282     fn default() -> Self {
11283         unsafe { ::std::mem::zeroed() }
11284     }
11285 }
11286 #[cfg(feature = "Win32_Foundation")]
11287 impl ::std::fmt::Debug for CRL_REVOCATION_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11288     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11289         fmt.debug_struct("CRL_REVOCATION_INFO").field("pCrlEntry", &self.pCrlEntry).field("pCrlContext", &self.pCrlContext).field("pCrlIssuerChain", &self.pCrlIssuerChain).finish()
11290     }
11291 }
11292 #[cfg(feature = "Win32_Foundation")]
11293 impl ::std::cmp::PartialEq for CRL_REVOCATION_INFO {
eq(&self, other: &Self) -> bool11294     fn eq(&self, other: &Self) -> bool {
11295         self.pCrlEntry == other.pCrlEntry && self.pCrlContext == other.pCrlContext && self.pCrlIssuerChain == other.pCrlIssuerChain
11296     }
11297 }
11298 #[cfg(feature = "Win32_Foundation")]
11299 impl ::std::cmp::Eq for CRL_REVOCATION_INFO {}
11300 #[cfg(feature = "Win32_Foundation")]
11301 unsafe impl ::windows::runtime::Abi for CRL_REVOCATION_INFO {
11302     type Abi = Self;
11303     type DefaultType = Self;
11304 }
11305 pub const CRL_V1: u32 = 0u32;
11306 pub const CRL_V2: u32 = 1u32;
11307 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11308 #[repr(C)]
11309 #[cfg(feature = "Win32_Foundation")]
11310 pub struct CROSS_CERT_DIST_POINTS_INFO {
11311     pub dwSyncDeltaTime: u32,
11312     pub cDistPoint: u32,
11313     pub rgDistPoint: *mut CERT_ALT_NAME_INFO,
11314 }
11315 #[cfg(feature = "Win32_Foundation")]
11316 impl CROSS_CERT_DIST_POINTS_INFO {}
11317 #[cfg(feature = "Win32_Foundation")]
11318 impl ::std::default::Default for CROSS_CERT_DIST_POINTS_INFO {
default() -> Self11319     fn default() -> Self {
11320         unsafe { ::std::mem::zeroed() }
11321     }
11322 }
11323 #[cfg(feature = "Win32_Foundation")]
11324 impl ::std::fmt::Debug for CROSS_CERT_DIST_POINTS_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11325     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11326         fmt.debug_struct("CROSS_CERT_DIST_POINTS_INFO").field("dwSyncDeltaTime", &self.dwSyncDeltaTime).field("cDistPoint", &self.cDistPoint).field("rgDistPoint", &self.rgDistPoint).finish()
11327     }
11328 }
11329 #[cfg(feature = "Win32_Foundation")]
11330 impl ::std::cmp::PartialEq for CROSS_CERT_DIST_POINTS_INFO {
eq(&self, other: &Self) -> bool11331     fn eq(&self, other: &Self) -> bool {
11332         self.dwSyncDeltaTime == other.dwSyncDeltaTime && self.cDistPoint == other.cDistPoint && self.rgDistPoint == other.rgDistPoint
11333     }
11334 }
11335 #[cfg(feature = "Win32_Foundation")]
11336 impl ::std::cmp::Eq for CROSS_CERT_DIST_POINTS_INFO {}
11337 #[cfg(feature = "Win32_Foundation")]
11338 unsafe impl ::windows::runtime::Abi for CROSS_CERT_DIST_POINTS_INFO {
11339     type Abi = Self;
11340     type DefaultType = Self;
11341 }
11342 pub const CROSS_CERT_DIST_POINT_ERR_INDEX_MASK: u32 = 255u32;
11343 pub const CROSS_CERT_DIST_POINT_ERR_INDEX_SHIFT: u32 = 24u32;
11344 pub const CRYPTDLG_ACTION_MASK: u32 = 4294901760u32;
11345 pub const CRYPTDLG_CACHE_ONLY_URL_RETRIEVAL: u32 = 268435456u32;
11346 pub const CRYPTDLG_DISABLE_AIA: u32 = 134217728u32;
11347 pub const CRYPTDLG_POLICY_MASK: u32 = 65535u32;
11348 pub const CRYPTDLG_REVOCATION_CACHE: u32 = 1073741824u32;
11349 pub const CRYPTDLG_REVOCATION_DEFAULT: u32 = 0u32;
11350 pub const CRYPTDLG_REVOCATION_NONE: u32 = 536870912u32;
11351 pub const CRYPTDLG_REVOCATION_ONLINE: u32 = 2147483648u32;
11352 pub const CRYPTNET_CACHED_OCSP_SWITCH_TO_CRL_COUNT_DEFAULT: u32 = 50u32;
11353 pub const CRYPTNET_CRL_BEFORE_OCSP_ENABLE: u32 = 4294967295u32;
11354 pub const CRYPTNET_MAX_CACHED_OCSP_PER_CRL_COUNT_DEFAULT: u32 = 500u32;
11355 pub const CRYPTNET_OCSP_AFTER_CRL_DISABLE: u32 = 4294967295u32;
11356 pub const CRYPTNET_PRE_FETCH_AFTER_PUBLISH_PRE_FETCH_DIVISOR_DEFAULT: u32 = 10u32;
11357 pub const CRYPTNET_PRE_FETCH_BEFORE_NEXT_UPDATE_PRE_FETCH_DIVISOR_DEFAULT: u32 = 20u32;
11358 pub const CRYPTNET_PRE_FETCH_SCAN_AFTER_TRIGGER_DELAY_SECONDS_DEFAULT: u32 = 60u32;
11359 pub const CRYPTNET_PRE_FETCH_TRIGGER_DISABLE: u32 = 4294967295u32;
11360 pub const CRYPTNET_PRE_FETCH_VALIDITY_PERIOD_AFTER_NEXT_UPDATE_PRE_FETCH_DIVISOR_DEFAULT: u32 = 10u32;
11361 pub const CRYPTNET_URL_CACHE_DEFAULT_FLUSH: u32 = 0u32;
11362 pub const CRYPTNET_URL_CACHE_DISABLE_FLUSH: u32 = 4294967295u32;
11363 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11364 #[repr(C)]
11365 #[cfg(feature = "Win32_Foundation")]
11366 pub struct CRYPTNET_URL_CACHE_FLUSH_INFO {
11367     pub cbSize: u32,
11368     pub dwExemptSeconds: u32,
11369     pub ExpireTime: super::super::Foundation::FILETIME,
11370 }
11371 #[cfg(feature = "Win32_Foundation")]
11372 impl CRYPTNET_URL_CACHE_FLUSH_INFO {}
11373 #[cfg(feature = "Win32_Foundation")]
11374 impl ::std::default::Default for CRYPTNET_URL_CACHE_FLUSH_INFO {
default() -> Self11375     fn default() -> Self {
11376         unsafe { ::std::mem::zeroed() }
11377     }
11378 }
11379 #[cfg(feature = "Win32_Foundation")]
11380 impl ::std::fmt::Debug for CRYPTNET_URL_CACHE_FLUSH_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11381     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11382         fmt.debug_struct("CRYPTNET_URL_CACHE_FLUSH_INFO").field("cbSize", &self.cbSize).field("dwExemptSeconds", &self.dwExemptSeconds).field("ExpireTime", &self.ExpireTime).finish()
11383     }
11384 }
11385 #[cfg(feature = "Win32_Foundation")]
11386 impl ::std::cmp::PartialEq for CRYPTNET_URL_CACHE_FLUSH_INFO {
eq(&self, other: &Self) -> bool11387     fn eq(&self, other: &Self) -> bool {
11388         self.cbSize == other.cbSize && self.dwExemptSeconds == other.dwExemptSeconds && self.ExpireTime == other.ExpireTime
11389     }
11390 }
11391 #[cfg(feature = "Win32_Foundation")]
11392 impl ::std::cmp::Eq for CRYPTNET_URL_CACHE_FLUSH_INFO {}
11393 #[cfg(feature = "Win32_Foundation")]
11394 unsafe impl ::windows::runtime::Abi for CRYPTNET_URL_CACHE_FLUSH_INFO {
11395     type Abi = Self;
11396     type DefaultType = Self;
11397 }
11398 pub const CRYPTNET_URL_CACHE_PRE_FETCH_AUTOROOT_CAB: u32 = 5u32;
11399 pub const CRYPTNET_URL_CACHE_PRE_FETCH_BLOB: u32 = 1u32;
11400 pub const CRYPTNET_URL_CACHE_PRE_FETCH_CRL: u32 = 2u32;
11401 pub const CRYPTNET_URL_CACHE_PRE_FETCH_DISALLOWED_CERT_CAB: u32 = 6u32;
11402 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11403 #[repr(C)]
11404 #[cfg(feature = "Win32_Foundation")]
11405 pub struct CRYPTNET_URL_CACHE_PRE_FETCH_INFO {
11406     pub cbSize: u32,
11407     pub dwObjectType: u32,
11408     pub dwError: u32,
11409     pub dwReserved: u32,
11410     pub ThisUpdateTime: super::super::Foundation::FILETIME,
11411     pub NextUpdateTime: super::super::Foundation::FILETIME,
11412     pub PublishTime: super::super::Foundation::FILETIME,
11413 }
11414 #[cfg(feature = "Win32_Foundation")]
11415 impl CRYPTNET_URL_CACHE_PRE_FETCH_INFO {}
11416 #[cfg(feature = "Win32_Foundation")]
11417 impl ::std::default::Default for CRYPTNET_URL_CACHE_PRE_FETCH_INFO {
default() -> Self11418     fn default() -> Self {
11419         unsafe { ::std::mem::zeroed() }
11420     }
11421 }
11422 #[cfg(feature = "Win32_Foundation")]
11423 impl ::std::fmt::Debug for CRYPTNET_URL_CACHE_PRE_FETCH_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11424     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11425         fmt.debug_struct("CRYPTNET_URL_CACHE_PRE_FETCH_INFO")
11426             .field("cbSize", &self.cbSize)
11427             .field("dwObjectType", &self.dwObjectType)
11428             .field("dwError", &self.dwError)
11429             .field("dwReserved", &self.dwReserved)
11430             .field("ThisUpdateTime", &self.ThisUpdateTime)
11431             .field("NextUpdateTime", &self.NextUpdateTime)
11432             .field("PublishTime", &self.PublishTime)
11433             .finish()
11434     }
11435 }
11436 #[cfg(feature = "Win32_Foundation")]
11437 impl ::std::cmp::PartialEq for CRYPTNET_URL_CACHE_PRE_FETCH_INFO {
eq(&self, other: &Self) -> bool11438     fn eq(&self, other: &Self) -> bool {
11439         self.cbSize == other.cbSize && self.dwObjectType == other.dwObjectType && self.dwError == other.dwError && self.dwReserved == other.dwReserved && self.ThisUpdateTime == other.ThisUpdateTime && self.NextUpdateTime == other.NextUpdateTime && self.PublishTime == other.PublishTime
11440     }
11441 }
11442 #[cfg(feature = "Win32_Foundation")]
11443 impl ::std::cmp::Eq for CRYPTNET_URL_CACHE_PRE_FETCH_INFO {}
11444 #[cfg(feature = "Win32_Foundation")]
11445 unsafe impl ::windows::runtime::Abi for CRYPTNET_URL_CACHE_PRE_FETCH_INFO {
11446     type Abi = Self;
11447     type DefaultType = Self;
11448 }
11449 pub const CRYPTNET_URL_CACHE_PRE_FETCH_NONE: u32 = 0u32;
11450 pub const CRYPTNET_URL_CACHE_PRE_FETCH_OCSP: u32 = 3u32;
11451 pub const CRYPTNET_URL_CACHE_PRE_FETCH_PIN_RULES_CAB: u32 = 7u32;
11452 pub const CRYPTNET_URL_CACHE_RESPONSE_HTTP: u32 = 1u32;
11453 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11454 #[repr(C)]
11455 #[cfg(feature = "Win32_Foundation")]
11456 pub struct CRYPTNET_URL_CACHE_RESPONSE_INFO {
11457     pub cbSize: u32,
11458     pub wResponseType: u16,
11459     pub wResponseFlags: u16,
11460     pub LastModifiedTime: super::super::Foundation::FILETIME,
11461     pub dwMaxAge: u32,
11462     pub pwszETag: super::super::Foundation::PWSTR,
11463     pub dwProxyId: u32,
11464 }
11465 #[cfg(feature = "Win32_Foundation")]
11466 impl CRYPTNET_URL_CACHE_RESPONSE_INFO {}
11467 #[cfg(feature = "Win32_Foundation")]
11468 impl ::std::default::Default for CRYPTNET_URL_CACHE_RESPONSE_INFO {
default() -> Self11469     fn default() -> Self {
11470         unsafe { ::std::mem::zeroed() }
11471     }
11472 }
11473 #[cfg(feature = "Win32_Foundation")]
11474 impl ::std::fmt::Debug for CRYPTNET_URL_CACHE_RESPONSE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11475     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11476         fmt.debug_struct("CRYPTNET_URL_CACHE_RESPONSE_INFO")
11477             .field("cbSize", &self.cbSize)
11478             .field("wResponseType", &self.wResponseType)
11479             .field("wResponseFlags", &self.wResponseFlags)
11480             .field("LastModifiedTime", &self.LastModifiedTime)
11481             .field("dwMaxAge", &self.dwMaxAge)
11482             .field("pwszETag", &self.pwszETag)
11483             .field("dwProxyId", &self.dwProxyId)
11484             .finish()
11485     }
11486 }
11487 #[cfg(feature = "Win32_Foundation")]
11488 impl ::std::cmp::PartialEq for CRYPTNET_URL_CACHE_RESPONSE_INFO {
eq(&self, other: &Self) -> bool11489     fn eq(&self, other: &Self) -> bool {
11490         self.cbSize == other.cbSize && self.wResponseType == other.wResponseType && self.wResponseFlags == other.wResponseFlags && self.LastModifiedTime == other.LastModifiedTime && self.dwMaxAge == other.dwMaxAge && self.pwszETag == other.pwszETag && self.dwProxyId == other.dwProxyId
11491     }
11492 }
11493 #[cfg(feature = "Win32_Foundation")]
11494 impl ::std::cmp::Eq for CRYPTNET_URL_CACHE_RESPONSE_INFO {}
11495 #[cfg(feature = "Win32_Foundation")]
11496 unsafe impl ::windows::runtime::Abi for CRYPTNET_URL_CACHE_RESPONSE_INFO {
11497     type Abi = Self;
11498     type DefaultType = Self;
11499 }
11500 pub const CRYPTNET_URL_CACHE_RESPONSE_NONE: u32 = 0u32;
11501 pub const CRYPTNET_URL_CACHE_RESPONSE_VALIDATED: u32 = 32768u32;
11502 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11503 #[repr(C)]
11504 pub struct CRYPTOAPI_BLOB {
11505     pub cbData: u32,
11506     pub pbData: *mut u8,
11507 }
11508 impl CRYPTOAPI_BLOB {}
11509 impl ::std::default::Default for CRYPTOAPI_BLOB {
default() -> Self11510     fn default() -> Self {
11511         unsafe { ::std::mem::zeroed() }
11512     }
11513 }
11514 impl ::std::fmt::Debug for CRYPTOAPI_BLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11515     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11516         fmt.debug_struct("CRYPTOAPI_BLOB").field("cbData", &self.cbData).field("pbData", &self.pbData).finish()
11517     }
11518 }
11519 impl ::std::cmp::PartialEq for CRYPTOAPI_BLOB {
eq(&self, other: &Self) -> bool11520     fn eq(&self, other: &Self) -> bool {
11521         self.cbData == other.cbData && self.pbData == other.pbData
11522     }
11523 }
11524 impl ::std::cmp::Eq for CRYPTOAPI_BLOB {}
11525 unsafe impl ::windows::runtime::Abi for CRYPTOAPI_BLOB {
11526     type Abi = Self;
11527     type DefaultType = Self;
11528 }
11529 pub const CRYPTPROTECTMEMORY_BLOCK_SIZE: u32 = 16u32;
11530 pub const CRYPTPROTECTMEMORY_CROSS_PROCESS: u32 = 1u32;
11531 pub const CRYPTPROTECTMEMORY_SAME_LOGON: u32 = 2u32;
11532 pub const CRYPTPROTECTMEMORY_SAME_PROCESS: u32 = 0u32;
11533 pub const CRYPTPROTECT_AUDIT: u32 = 16u32;
11534 pub const CRYPTPROTECT_CRED_REGENERATE: u32 = 128u32;
11535 pub const CRYPTPROTECT_CRED_SYNC: u32 = 8u32;
11536 pub const CRYPTPROTECT_FIRST_RESERVED_FLAGVAL: u32 = 268435455u32;
11537 pub const CRYPTPROTECT_LAST_RESERVED_FLAGVAL: u32 = 4294967295u32;
11538 pub const CRYPTPROTECT_LOCAL_MACHINE: u32 = 4u32;
11539 pub const CRYPTPROTECT_NO_RECOVERY: u32 = 32u32;
11540 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11541 #[repr(C)]
11542 #[cfg(feature = "Win32_Foundation")]
11543 pub struct CRYPTPROTECT_PROMPTSTRUCT {
11544     pub cbSize: u32,
11545     pub dwPromptFlags: u32,
11546     pub hwndApp: super::super::Foundation::HWND,
11547     pub szPrompt: super::super::Foundation::PWSTR,
11548 }
11549 #[cfg(feature = "Win32_Foundation")]
11550 impl CRYPTPROTECT_PROMPTSTRUCT {}
11551 #[cfg(feature = "Win32_Foundation")]
11552 impl ::std::default::Default for CRYPTPROTECT_PROMPTSTRUCT {
default() -> Self11553     fn default() -> Self {
11554         unsafe { ::std::mem::zeroed() }
11555     }
11556 }
11557 #[cfg(feature = "Win32_Foundation")]
11558 impl ::std::fmt::Debug for CRYPTPROTECT_PROMPTSTRUCT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11559     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11560         fmt.debug_struct("CRYPTPROTECT_PROMPTSTRUCT").field("cbSize", &self.cbSize).field("dwPromptFlags", &self.dwPromptFlags).field("hwndApp", &self.hwndApp).field("szPrompt", &self.szPrompt).finish()
11561     }
11562 }
11563 #[cfg(feature = "Win32_Foundation")]
11564 impl ::std::cmp::PartialEq for CRYPTPROTECT_PROMPTSTRUCT {
eq(&self, other: &Self) -> bool11565     fn eq(&self, other: &Self) -> bool {
11566         self.cbSize == other.cbSize && self.dwPromptFlags == other.dwPromptFlags && self.hwndApp == other.hwndApp && self.szPrompt == other.szPrompt
11567     }
11568 }
11569 #[cfg(feature = "Win32_Foundation")]
11570 impl ::std::cmp::Eq for CRYPTPROTECT_PROMPTSTRUCT {}
11571 #[cfg(feature = "Win32_Foundation")]
11572 unsafe impl ::windows::runtime::Abi for CRYPTPROTECT_PROMPTSTRUCT {
11573     type Abi = Self;
11574     type DefaultType = Self;
11575 }
11576 pub const CRYPTPROTECT_PROMPT_ON_PROTECT: u32 = 2u32;
11577 pub const CRYPTPROTECT_PROMPT_ON_UNPROTECT: u32 = 1u32;
11578 pub const CRYPTPROTECT_PROMPT_REQUIRE_STRONG: u32 = 16u32;
11579 pub const CRYPTPROTECT_PROMPT_RESERVED: u32 = 4u32;
11580 pub const CRYPTPROTECT_PROMPT_STRONG: u32 = 8u32;
11581 pub const CRYPTPROTECT_UI_FORBIDDEN: u32 = 1u32;
11582 pub const CRYPTPROTECT_VERIFY_PROTECTION: u32 = 64u32;
11583 pub const CRYPTUI_CERT_MGR_PUBLISHER_TAB: u32 = 4u32;
11584 pub const CRYPTUI_CERT_MGR_SINGLE_TAB_FLAG: u32 = 32768u32;
11585 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11586 #[repr(C)]
11587 #[cfg(feature = "Win32_Foundation")]
11588 pub struct CRYPTUI_CERT_MGR_STRUCT {
11589     pub dwSize: u32,
11590     pub hwndParent: super::super::Foundation::HWND,
11591     pub dwFlags: u32,
11592     pub pwszTitle: super::super::Foundation::PWSTR,
11593     pub pszInitUsageOID: super::super::Foundation::PSTR,
11594 }
11595 #[cfg(feature = "Win32_Foundation")]
11596 impl CRYPTUI_CERT_MGR_STRUCT {}
11597 #[cfg(feature = "Win32_Foundation")]
11598 impl ::std::default::Default for CRYPTUI_CERT_MGR_STRUCT {
default() -> Self11599     fn default() -> Self {
11600         unsafe { ::std::mem::zeroed() }
11601     }
11602 }
11603 #[cfg(feature = "Win32_Foundation")]
11604 impl ::std::fmt::Debug for CRYPTUI_CERT_MGR_STRUCT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11605     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11606         fmt.debug_struct("CRYPTUI_CERT_MGR_STRUCT").field("dwSize", &self.dwSize).field("hwndParent", &self.hwndParent).field("dwFlags", &self.dwFlags).field("pwszTitle", &self.pwszTitle).field("pszInitUsageOID", &self.pszInitUsageOID).finish()
11607     }
11608 }
11609 #[cfg(feature = "Win32_Foundation")]
11610 impl ::std::cmp::PartialEq for CRYPTUI_CERT_MGR_STRUCT {
eq(&self, other: &Self) -> bool11611     fn eq(&self, other: &Self) -> bool {
11612         self.dwSize == other.dwSize && self.hwndParent == other.hwndParent && self.dwFlags == other.dwFlags && self.pwszTitle == other.pwszTitle && self.pszInitUsageOID == other.pszInitUsageOID
11613     }
11614 }
11615 #[cfg(feature = "Win32_Foundation")]
11616 impl ::std::cmp::Eq for CRYPTUI_CERT_MGR_STRUCT {}
11617 #[cfg(feature = "Win32_Foundation")]
11618 unsafe impl ::windows::runtime::Abi for CRYPTUI_CERT_MGR_STRUCT {
11619     type Abi = Self;
11620     type DefaultType = Self;
11621 }
11622 pub const CRYPTUI_CERT_MGR_TAB_MASK: u32 = 15u32;
11623 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11624 #[repr(C)]
11625 #[cfg(feature = "Win32_Foundation")]
11626 pub struct CRYPTUI_INITDIALOG_STRUCT {
11627     pub lParam: super::super::Foundation::LPARAM,
11628     pub pCertContext: *mut CERT_CONTEXT,
11629 }
11630 #[cfg(feature = "Win32_Foundation")]
11631 impl CRYPTUI_INITDIALOG_STRUCT {}
11632 #[cfg(feature = "Win32_Foundation")]
11633 impl ::std::default::Default for CRYPTUI_INITDIALOG_STRUCT {
default() -> Self11634     fn default() -> Self {
11635         unsafe { ::std::mem::zeroed() }
11636     }
11637 }
11638 #[cfg(feature = "Win32_Foundation")]
11639 impl ::std::fmt::Debug for CRYPTUI_INITDIALOG_STRUCT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11640     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11641         fmt.debug_struct("CRYPTUI_INITDIALOG_STRUCT").field("lParam", &self.lParam).field("pCertContext", &self.pCertContext).finish()
11642     }
11643 }
11644 #[cfg(feature = "Win32_Foundation")]
11645 impl ::std::cmp::PartialEq for CRYPTUI_INITDIALOG_STRUCT {
eq(&self, other: &Self) -> bool11646     fn eq(&self, other: &Self) -> bool {
11647         self.lParam == other.lParam && self.pCertContext == other.pCertContext
11648     }
11649 }
11650 #[cfg(feature = "Win32_Foundation")]
11651 impl ::std::cmp::Eq for CRYPTUI_INITDIALOG_STRUCT {}
11652 #[cfg(feature = "Win32_Foundation")]
11653 unsafe impl ::windows::runtime::Abi for CRYPTUI_INITDIALOG_STRUCT {
11654     type Abi = Self;
11655     type DefaultType = Self;
11656 }
11657 pub const CRYPTUI_SELECT_EXPIRATION_COLUMN: u64 = 32u64;
11658 pub const CRYPTUI_SELECT_FRIENDLYNAME_COLUMN: u64 = 8u64;
11659 pub const CRYPTUI_SELECT_INTENDEDUSE_COLUMN: u64 = 4u64;
11660 pub const CRYPTUI_SELECT_ISSUEDBY_COLUMN: u64 = 2u64;
11661 pub const CRYPTUI_SELECT_ISSUEDTO_COLUMN: u64 = 1u64;
11662 pub const CRYPTUI_SELECT_LOCATION_COLUMN: u64 = 16u64;
11663 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11664 #[repr(transparent)]
11665 pub struct CRYPTUI_VIEWCERTIFICATE_FLAGS(pub u32);
11666 pub const CRYPTUI_HIDE_HIERARCHYPAGE: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(1u32);
11667 pub const CRYPTUI_HIDE_DETAILPAGE: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(2u32);
11668 pub const CRYPTUI_DISABLE_EDITPROPERTIES: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(4u32);
11669 pub const CRYPTUI_ENABLE_EDITPROPERTIES: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(8u32);
11670 pub const CRYPTUI_DISABLE_ADDTOSTORE: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(16u32);
11671 pub const CRYPTUI_ENABLE_ADDTOSTORE: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(32u32);
11672 pub const CRYPTUI_ACCEPT_DECLINE_STYLE: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(64u32);
11673 pub const CRYPTUI_IGNORE_UNTRUSTED_ROOT: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(128u32);
11674 pub const CRYPTUI_DONT_OPEN_STORES: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(256u32);
11675 pub const CRYPTUI_ONLY_OPEN_ROOT_STORE: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(512u32);
11676 pub const CRYPTUI_WARN_UNTRUSTED_ROOT: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(1024u32);
11677 pub const CRYPTUI_ENABLE_REVOCATION_CHECKING: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(2048u32);
11678 pub const CRYPTUI_WARN_REMOTE_TRUST: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(4096u32);
11679 pub const CRYPTUI_DISABLE_EXPORT: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(8192u32);
11680 pub const CRYPTUI_ENABLE_REVOCATION_CHECK_END_CERT: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(16384u32);
11681 pub const CRYPTUI_ENABLE_REVOCATION_CHECK_CHAIN: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(32768u32);
11682 pub const CRYPTUI_ENABLE_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(2048u32);
11683 pub const CRYPTUI_DISABLE_HTMLLINK: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(65536u32);
11684 pub const CRYPTUI_DISABLE_ISSUERSTATEMENT: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(131072u32);
11685 pub const CRYPTUI_CACHE_ONLY_URL_RETRIEVAL: CRYPTUI_VIEWCERTIFICATE_FLAGS = CRYPTUI_VIEWCERTIFICATE_FLAGS(262144u32);
11686 impl ::std::convert::From<u32> for CRYPTUI_VIEWCERTIFICATE_FLAGS {
from(value: u32) -> Self11687     fn from(value: u32) -> Self {
11688         Self(value)
11689     }
11690 }
11691 unsafe impl ::windows::runtime::Abi for CRYPTUI_VIEWCERTIFICATE_FLAGS {
11692     type Abi = Self;
11693     type DefaultType = Self;
11694 }
11695 impl ::std::ops::BitOr for CRYPTUI_VIEWCERTIFICATE_FLAGS {
11696     type Output = Self;
bitor(self, rhs: Self) -> Self11697     fn bitor(self, rhs: Self) -> Self {
11698         Self(self.0 | rhs.0)
11699     }
11700 }
11701 impl ::std::ops::BitAnd for CRYPTUI_VIEWCERTIFICATE_FLAGS {
11702     type Output = Self;
bitand(self, rhs: Self) -> Self11703     fn bitand(self, rhs: Self) -> Self {
11704         Self(self.0 & rhs.0)
11705     }
11706 }
11707 impl ::std::ops::BitOrAssign for CRYPTUI_VIEWCERTIFICATE_FLAGS {
bitor_assign(&mut self, rhs: Self)11708     fn bitor_assign(&mut self, rhs: Self) {
11709         self.0.bitor_assign(rhs.0)
11710     }
11711 }
11712 impl ::std::ops::BitAndAssign for CRYPTUI_VIEWCERTIFICATE_FLAGS {
bitand_assign(&mut self, rhs: Self)11713     fn bitand_assign(&mut self, rhs: Self) {
11714         self.0.bitand_assign(rhs.0)
11715     }
11716 }
11717 impl ::std::ops::Not for CRYPTUI_VIEWCERTIFICATE_FLAGS {
11718     type Output = Self;
not(self) -> Self11719     fn not(self) -> Self {
11720         Self(self.0.not())
11721     }
11722 }
11723 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11724 #[repr(C)]
11725 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
11726 pub struct CRYPTUI_VIEWCERTIFICATE_STRUCTA {
11727     pub dwSize: u32,
11728     pub hwndParent: super::super::Foundation::HWND,
11729     pub dwFlags: CRYPTUI_VIEWCERTIFICATE_FLAGS,
11730     pub szTitle: super::super::Foundation::PSTR,
11731     pub pCertContext: *mut CERT_CONTEXT,
11732     pub rgszPurposes: *mut super::super::Foundation::PSTR,
11733     pub cPurposes: u32,
11734     pub Anonymous: CRYPTUI_VIEWCERTIFICATE_STRUCTA_0,
11735     pub fpCryptProviderDataTrustedUsage: super::super::Foundation::BOOL,
11736     pub idxSigner: u32,
11737     pub idxCert: u32,
11738     pub fCounterSigner: super::super::Foundation::BOOL,
11739     pub idxCounterSigner: u32,
11740     pub cStores: u32,
11741     pub rghStores: *mut *mut ::std::ffi::c_void,
11742     pub cPropSheetPages: u32,
11743     pub rgPropSheetPages: *mut super::super::UI::Controls::PROPSHEETPAGEA,
11744     pub nStartPage: u32,
11745 }
11746 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
11747 impl CRYPTUI_VIEWCERTIFICATE_STRUCTA {}
11748 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
11749 impl ::std::default::Default for CRYPTUI_VIEWCERTIFICATE_STRUCTA {
default() -> Self11750     fn default() -> Self {
11751         unsafe { ::std::mem::zeroed() }
11752     }
11753 }
11754 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
11755 impl ::std::cmp::PartialEq for CRYPTUI_VIEWCERTIFICATE_STRUCTA {
eq(&self, _other: &Self) -> bool11756     fn eq(&self, _other: &Self) -> bool {
11757         unimplemented!()
11758     }
11759 }
11760 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
11761 impl ::std::cmp::Eq for CRYPTUI_VIEWCERTIFICATE_STRUCTA {}
11762 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
11763 unsafe impl ::windows::runtime::Abi for CRYPTUI_VIEWCERTIFICATE_STRUCTA {
11764     type Abi = Self;
11765     type DefaultType = Self;
11766 }
11767 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11768 #[repr(C)]
11769 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust"))]
11770 pub union CRYPTUI_VIEWCERTIFICATE_STRUCTA_0 {
11771     pub pCryptProviderData: *mut super::WinTrust::CRYPT_PROVIDER_DATA,
11772     pub hWVTStateData: super::super::Foundation::HANDLE,
11773 }
11774 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust"))]
11775 impl CRYPTUI_VIEWCERTIFICATE_STRUCTA_0 {}
11776 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust"))]
11777 impl ::std::default::Default for CRYPTUI_VIEWCERTIFICATE_STRUCTA_0 {
default() -> Self11778     fn default() -> Self {
11779         unsafe { ::std::mem::zeroed() }
11780     }
11781 }
11782 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust"))]
11783 impl ::std::cmp::PartialEq for CRYPTUI_VIEWCERTIFICATE_STRUCTA_0 {
eq(&self, _other: &Self) -> bool11784     fn eq(&self, _other: &Self) -> bool {
11785         unimplemented!()
11786     }
11787 }
11788 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust"))]
11789 impl ::std::cmp::Eq for CRYPTUI_VIEWCERTIFICATE_STRUCTA_0 {}
11790 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust"))]
11791 unsafe impl ::windows::runtime::Abi for CRYPTUI_VIEWCERTIFICATE_STRUCTA_0 {
11792     type Abi = Self;
11793     type DefaultType = Self;
11794 }
11795 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11796 #[repr(C)]
11797 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
11798 pub struct CRYPTUI_VIEWCERTIFICATE_STRUCTW {
11799     pub dwSize: u32,
11800     pub hwndParent: super::super::Foundation::HWND,
11801     pub dwFlags: CRYPTUI_VIEWCERTIFICATE_FLAGS,
11802     pub szTitle: super::super::Foundation::PWSTR,
11803     pub pCertContext: *mut CERT_CONTEXT,
11804     pub rgszPurposes: *mut super::super::Foundation::PSTR,
11805     pub cPurposes: u32,
11806     pub Anonymous: CRYPTUI_VIEWCERTIFICATE_STRUCTW_0,
11807     pub fpCryptProviderDataTrustedUsage: super::super::Foundation::BOOL,
11808     pub idxSigner: u32,
11809     pub idxCert: u32,
11810     pub fCounterSigner: super::super::Foundation::BOOL,
11811     pub idxCounterSigner: u32,
11812     pub cStores: u32,
11813     pub rghStores: *mut *mut ::std::ffi::c_void,
11814     pub cPropSheetPages: u32,
11815     pub rgPropSheetPages: *mut super::super::UI::Controls::PROPSHEETPAGEW,
11816     pub nStartPage: u32,
11817 }
11818 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
11819 impl CRYPTUI_VIEWCERTIFICATE_STRUCTW {}
11820 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
11821 impl ::std::default::Default for CRYPTUI_VIEWCERTIFICATE_STRUCTW {
default() -> Self11822     fn default() -> Self {
11823         unsafe { ::std::mem::zeroed() }
11824     }
11825 }
11826 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
11827 impl ::std::cmp::PartialEq for CRYPTUI_VIEWCERTIFICATE_STRUCTW {
eq(&self, _other: &Self) -> bool11828     fn eq(&self, _other: &Self) -> bool {
11829         unimplemented!()
11830     }
11831 }
11832 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
11833 impl ::std::cmp::Eq for CRYPTUI_VIEWCERTIFICATE_STRUCTW {}
11834 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
11835 unsafe impl ::windows::runtime::Abi for CRYPTUI_VIEWCERTIFICATE_STRUCTW {
11836     type Abi = Self;
11837     type DefaultType = Self;
11838 }
11839 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11840 #[repr(C)]
11841 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust"))]
11842 pub union CRYPTUI_VIEWCERTIFICATE_STRUCTW_0 {
11843     pub pCryptProviderData: *mut super::WinTrust::CRYPT_PROVIDER_DATA,
11844     pub hWVTStateData: super::super::Foundation::HANDLE,
11845 }
11846 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust"))]
11847 impl CRYPTUI_VIEWCERTIFICATE_STRUCTW_0 {}
11848 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust"))]
11849 impl ::std::default::Default for CRYPTUI_VIEWCERTIFICATE_STRUCTW_0 {
default() -> Self11850     fn default() -> Self {
11851         unsafe { ::std::mem::zeroed() }
11852     }
11853 }
11854 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust"))]
11855 impl ::std::cmp::PartialEq for CRYPTUI_VIEWCERTIFICATE_STRUCTW_0 {
eq(&self, _other: &Self) -> bool11856     fn eq(&self, _other: &Self) -> bool {
11857         unimplemented!()
11858     }
11859 }
11860 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust"))]
11861 impl ::std::cmp::Eq for CRYPTUI_VIEWCERTIFICATE_STRUCTW_0 {}
11862 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust"))]
11863 unsafe impl ::windows::runtime::Abi for CRYPTUI_VIEWCERTIFICATE_STRUCTW_0 {
11864     type Abi = Self;
11865     type DefaultType = Self;
11866 }
11867 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11868 #[repr(transparent)]
11869 pub struct CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE(pub u32);
11870 pub const CRYPTUI_WIZ_DIGITAL_SIGN_ADD_CHAIN: CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE = CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE(1u32);
11871 pub const CRYPTUI_WIZ_DIGITAL_SIGN_ADD_CHAIN_NO_ROOT: CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE = CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE(2u32);
11872 pub const CRYPTUI_WIZ_DIGITAL_SIGN_ADD_NONE: CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE = CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE(0u32);
11873 impl ::std::convert::From<u32> for CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE {
from(value: u32) -> Self11874     fn from(value: u32) -> Self {
11875         Self(value)
11876     }
11877 }
11878 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE {
11879     type Abi = Self;
11880     type DefaultType = Self;
11881 }
11882 impl ::std::ops::BitOr for CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE {
11883     type Output = Self;
bitor(self, rhs: Self) -> Self11884     fn bitor(self, rhs: Self) -> Self {
11885         Self(self.0 | rhs.0)
11886     }
11887 }
11888 impl ::std::ops::BitAnd for CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE {
11889     type Output = Self;
bitand(self, rhs: Self) -> Self11890     fn bitand(self, rhs: Self) -> Self {
11891         Self(self.0 & rhs.0)
11892     }
11893 }
11894 impl ::std::ops::BitOrAssign for CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE {
bitor_assign(&mut self, rhs: Self)11895     fn bitor_assign(&mut self, rhs: Self) {
11896         self.0.bitor_assign(rhs.0)
11897     }
11898 }
11899 impl ::std::ops::BitAndAssign for CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE {
bitand_assign(&mut self, rhs: Self)11900     fn bitand_assign(&mut self, rhs: Self) {
11901         self.0.bitand_assign(rhs.0)
11902     }
11903 }
11904 impl ::std::ops::Not for CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE {
11905     type Output = Self;
not(self) -> Self11906     fn not(self) -> Self {
11907         Self(self.0.not())
11908     }
11909 }
11910 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11911 #[repr(transparent)]
11912 pub struct CRYPTUI_WIZ_DIGITAL_SIGN(pub u32);
11913 pub const CRYPTUI_WIZ_DIGITAL_SIGN_CERT: CRYPTUI_WIZ_DIGITAL_SIGN = CRYPTUI_WIZ_DIGITAL_SIGN(1u32);
11914 pub const CRYPTUI_WIZ_DIGITAL_SIGN_STORE: CRYPTUI_WIZ_DIGITAL_SIGN = CRYPTUI_WIZ_DIGITAL_SIGN(2u32);
11915 pub const CRYPTUI_WIZ_DIGITAL_SIGN_PVK: CRYPTUI_WIZ_DIGITAL_SIGN = CRYPTUI_WIZ_DIGITAL_SIGN(3u32);
11916 pub const CRYPTUI_WIZ_DIGITAL_SIGN_NONE: CRYPTUI_WIZ_DIGITAL_SIGN = CRYPTUI_WIZ_DIGITAL_SIGN(0u32);
11917 impl ::std::convert::From<u32> for CRYPTUI_WIZ_DIGITAL_SIGN {
from(value: u32) -> Self11918     fn from(value: u32) -> Self {
11919         Self(value)
11920     }
11921 }
11922 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_DIGITAL_SIGN {
11923     type Abi = Self;
11924     type DefaultType = Self;
11925 }
11926 impl ::std::ops::BitOr for CRYPTUI_WIZ_DIGITAL_SIGN {
11927     type Output = Self;
bitor(self, rhs: Self) -> Self11928     fn bitor(self, rhs: Self) -> Self {
11929         Self(self.0 | rhs.0)
11930     }
11931 }
11932 impl ::std::ops::BitAnd for CRYPTUI_WIZ_DIGITAL_SIGN {
11933     type Output = Self;
bitand(self, rhs: Self) -> Self11934     fn bitand(self, rhs: Self) -> Self {
11935         Self(self.0 & rhs.0)
11936     }
11937 }
11938 impl ::std::ops::BitOrAssign for CRYPTUI_WIZ_DIGITAL_SIGN {
bitor_assign(&mut self, rhs: Self)11939     fn bitor_assign(&mut self, rhs: Self) {
11940         self.0.bitor_assign(rhs.0)
11941     }
11942 }
11943 impl ::std::ops::BitAndAssign for CRYPTUI_WIZ_DIGITAL_SIGN {
bitand_assign(&mut self, rhs: Self)11944     fn bitand_assign(&mut self, rhs: Self) {
11945         self.0.bitand_assign(rhs.0)
11946     }
11947 }
11948 impl ::std::ops::Not for CRYPTUI_WIZ_DIGITAL_SIGN {
11949     type Output = Self;
not(self) -> Self11950     fn not(self) -> Self {
11951         Self(self.0.not())
11952     }
11953 }
11954 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11955 #[repr(C)]
11956 #[cfg(feature = "Win32_Foundation")]
11957 pub struct CRYPTUI_WIZ_DIGITAL_SIGN_BLOB_INFO {
11958     pub dwSize: u32,
11959     pub pGuidSubject: *mut ::windows::runtime::GUID,
11960     pub cbBlob: u32,
11961     pub pbBlob: *mut u8,
11962     pub pwszDisplayName: super::super::Foundation::PWSTR,
11963 }
11964 #[cfg(feature = "Win32_Foundation")]
11965 impl CRYPTUI_WIZ_DIGITAL_SIGN_BLOB_INFO {}
11966 #[cfg(feature = "Win32_Foundation")]
11967 impl ::std::default::Default for CRYPTUI_WIZ_DIGITAL_SIGN_BLOB_INFO {
default() -> Self11968     fn default() -> Self {
11969         unsafe { ::std::mem::zeroed() }
11970     }
11971 }
11972 #[cfg(feature = "Win32_Foundation")]
11973 impl ::std::fmt::Debug for CRYPTUI_WIZ_DIGITAL_SIGN_BLOB_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11974     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11975         fmt.debug_struct("CRYPTUI_WIZ_DIGITAL_SIGN_BLOB_INFO").field("dwSize", &self.dwSize).field("pGuidSubject", &self.pGuidSubject).field("cbBlob", &self.cbBlob).field("pbBlob", &self.pbBlob).field("pwszDisplayName", &self.pwszDisplayName).finish()
11976     }
11977 }
11978 #[cfg(feature = "Win32_Foundation")]
11979 impl ::std::cmp::PartialEq for CRYPTUI_WIZ_DIGITAL_SIGN_BLOB_INFO {
eq(&self, other: &Self) -> bool11980     fn eq(&self, other: &Self) -> bool {
11981         self.dwSize == other.dwSize && self.pGuidSubject == other.pGuidSubject && self.cbBlob == other.cbBlob && self.pbBlob == other.pbBlob && self.pwszDisplayName == other.pwszDisplayName
11982     }
11983 }
11984 #[cfg(feature = "Win32_Foundation")]
11985 impl ::std::cmp::Eq for CRYPTUI_WIZ_DIGITAL_SIGN_BLOB_INFO {}
11986 #[cfg(feature = "Win32_Foundation")]
11987 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_DIGITAL_SIGN_BLOB_INFO {
11988     type Abi = Self;
11989     type DefaultType = Self;
11990 }
11991 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11992 #[repr(C)]
11993 #[cfg(feature = "Win32_Foundation")]
11994 pub struct CRYPTUI_WIZ_DIGITAL_SIGN_CERT_PVK_INFO {
11995     pub dwSize: u32,
11996     pub pwszSigningCertFileName: super::super::Foundation::PWSTR,
11997     pub dwPvkChoice: CRYPTUI_WIZ_DIGITAL_SIGN_PVK_OPTION,
11998     pub Anonymous: CRYPTUI_WIZ_DIGITAL_SIGN_CERT_PVK_INFO_0,
11999 }
12000 #[cfg(feature = "Win32_Foundation")]
12001 impl CRYPTUI_WIZ_DIGITAL_SIGN_CERT_PVK_INFO {}
12002 #[cfg(feature = "Win32_Foundation")]
12003 impl ::std::default::Default for CRYPTUI_WIZ_DIGITAL_SIGN_CERT_PVK_INFO {
default() -> Self12004     fn default() -> Self {
12005         unsafe { ::std::mem::zeroed() }
12006     }
12007 }
12008 #[cfg(feature = "Win32_Foundation")]
12009 impl ::std::cmp::PartialEq for CRYPTUI_WIZ_DIGITAL_SIGN_CERT_PVK_INFO {
eq(&self, _other: &Self) -> bool12010     fn eq(&self, _other: &Self) -> bool {
12011         unimplemented!()
12012     }
12013 }
12014 #[cfg(feature = "Win32_Foundation")]
12015 impl ::std::cmp::Eq for CRYPTUI_WIZ_DIGITAL_SIGN_CERT_PVK_INFO {}
12016 #[cfg(feature = "Win32_Foundation")]
12017 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_DIGITAL_SIGN_CERT_PVK_INFO {
12018     type Abi = Self;
12019     type DefaultType = Self;
12020 }
12021 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12022 #[repr(C)]
12023 #[cfg(feature = "Win32_Foundation")]
12024 pub union CRYPTUI_WIZ_DIGITAL_SIGN_CERT_PVK_INFO_0 {
12025     pub pPvkFileInfo: *mut CRYPTUI_WIZ_DIGITAL_SIGN_PVK_FILE_INFO,
12026     pub pPvkProvInfo: *mut CRYPT_KEY_PROV_INFO,
12027 }
12028 #[cfg(feature = "Win32_Foundation")]
12029 impl CRYPTUI_WIZ_DIGITAL_SIGN_CERT_PVK_INFO_0 {}
12030 #[cfg(feature = "Win32_Foundation")]
12031 impl ::std::default::Default for CRYPTUI_WIZ_DIGITAL_SIGN_CERT_PVK_INFO_0 {
default() -> Self12032     fn default() -> Self {
12033         unsafe { ::std::mem::zeroed() }
12034     }
12035 }
12036 #[cfg(feature = "Win32_Foundation")]
12037 impl ::std::cmp::PartialEq for CRYPTUI_WIZ_DIGITAL_SIGN_CERT_PVK_INFO_0 {
eq(&self, _other: &Self) -> bool12038     fn eq(&self, _other: &Self) -> bool {
12039         unimplemented!()
12040     }
12041 }
12042 #[cfg(feature = "Win32_Foundation")]
12043 impl ::std::cmp::Eq for CRYPTUI_WIZ_DIGITAL_SIGN_CERT_PVK_INFO_0 {}
12044 #[cfg(feature = "Win32_Foundation")]
12045 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_DIGITAL_SIGN_CERT_PVK_INFO_0 {
12046     type Abi = Self;
12047     type DefaultType = Self;
12048 }
12049 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12050 #[repr(C)]
12051 pub struct CRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT {
12052     pub dwSize: u32,
12053     pub cbBlob: u32,
12054     pub pbBlob: *mut u8,
12055 }
12056 impl CRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT {}
12057 impl ::std::default::Default for CRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT {
default() -> Self12058     fn default() -> Self {
12059         unsafe { ::std::mem::zeroed() }
12060     }
12061 }
12062 impl ::std::fmt::Debug for CRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12063     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12064         fmt.debug_struct("CRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT").field("dwSize", &self.dwSize).field("cbBlob", &self.cbBlob).field("pbBlob", &self.pbBlob).finish()
12065     }
12066 }
12067 impl ::std::cmp::PartialEq for CRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT {
eq(&self, other: &Self) -> bool12068     fn eq(&self, other: &Self) -> bool {
12069         self.dwSize == other.dwSize && self.cbBlob == other.cbBlob && self.pbBlob == other.pbBlob
12070     }
12071 }
12072 impl ::std::cmp::Eq for CRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT {}
12073 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT {
12074     type Abi = Self;
12075     type DefaultType = Self;
12076 }
12077 pub const CRYPTUI_WIZ_DIGITAL_SIGN_EXCLUDE_PAGE_HASHES: u32 = 2u32;
12078 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12079 #[repr(C)]
12080 #[cfg(feature = "Win32_Foundation")]
12081 pub struct CRYPTUI_WIZ_DIGITAL_SIGN_EXTENDED_INFO {
12082     pub dwSize: u32,
12083     pub dwAttrFlags: CRYPTUI_WIZ_DIGITAL_SIGN_SIG_TYPE,
12084     pub pwszDescription: super::super::Foundation::PWSTR,
12085     pub pwszMoreInfoLocation: super::super::Foundation::PWSTR,
12086     pub pszHashAlg: super::super::Foundation::PSTR,
12087     pub pwszSigningCertDisplayString: super::super::Foundation::PWSTR,
12088     pub hAdditionalCertStore: *mut ::std::ffi::c_void,
12089     pub psAuthenticated: *mut CRYPT_ATTRIBUTES,
12090     pub psUnauthenticated: *mut CRYPT_ATTRIBUTES,
12091 }
12092 #[cfg(feature = "Win32_Foundation")]
12093 impl CRYPTUI_WIZ_DIGITAL_SIGN_EXTENDED_INFO {}
12094 #[cfg(feature = "Win32_Foundation")]
12095 impl ::std::default::Default for CRYPTUI_WIZ_DIGITAL_SIGN_EXTENDED_INFO {
default() -> Self12096     fn default() -> Self {
12097         unsafe { ::std::mem::zeroed() }
12098     }
12099 }
12100 #[cfg(feature = "Win32_Foundation")]
12101 impl ::std::fmt::Debug for CRYPTUI_WIZ_DIGITAL_SIGN_EXTENDED_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12102     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12103         fmt.debug_struct("CRYPTUI_WIZ_DIGITAL_SIGN_EXTENDED_INFO")
12104             .field("dwSize", &self.dwSize)
12105             .field("dwAttrFlags", &self.dwAttrFlags)
12106             .field("pwszDescription", &self.pwszDescription)
12107             .field("pwszMoreInfoLocation", &self.pwszMoreInfoLocation)
12108             .field("pszHashAlg", &self.pszHashAlg)
12109             .field("pwszSigningCertDisplayString", &self.pwszSigningCertDisplayString)
12110             .field("hAdditionalCertStore", &self.hAdditionalCertStore)
12111             .field("psAuthenticated", &self.psAuthenticated)
12112             .field("psUnauthenticated", &self.psUnauthenticated)
12113             .finish()
12114     }
12115 }
12116 #[cfg(feature = "Win32_Foundation")]
12117 impl ::std::cmp::PartialEq for CRYPTUI_WIZ_DIGITAL_SIGN_EXTENDED_INFO {
eq(&self, other: &Self) -> bool12118     fn eq(&self, other: &Self) -> bool {
12119         self.dwSize == other.dwSize && self.dwAttrFlags == other.dwAttrFlags && self.pwszDescription == other.pwszDescription && self.pwszMoreInfoLocation == other.pwszMoreInfoLocation && self.pszHashAlg == other.pszHashAlg && self.pwszSigningCertDisplayString == other.pwszSigningCertDisplayString && self.hAdditionalCertStore == other.hAdditionalCertStore && self.psAuthenticated == other.psAuthenticated && self.psUnauthenticated == other.psUnauthenticated
12120     }
12121 }
12122 #[cfg(feature = "Win32_Foundation")]
12123 impl ::std::cmp::Eq for CRYPTUI_WIZ_DIGITAL_SIGN_EXTENDED_INFO {}
12124 #[cfg(feature = "Win32_Foundation")]
12125 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_DIGITAL_SIGN_EXTENDED_INFO {
12126     type Abi = Self;
12127     type DefaultType = Self;
12128 }
12129 pub const CRYPTUI_WIZ_DIGITAL_SIGN_INCLUDE_PAGE_HASHES: u32 = 4u32;
12130 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12131 #[repr(C)]
12132 #[cfg(feature = "Win32_Foundation")]
12133 pub struct CRYPTUI_WIZ_DIGITAL_SIGN_INFO {
12134     pub dwSize: u32,
12135     pub dwSubjectChoice: CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT,
12136     pub Anonymous1: CRYPTUI_WIZ_DIGITAL_SIGN_INFO_0,
12137     pub dwSigningCertChoice: CRYPTUI_WIZ_DIGITAL_SIGN,
12138     pub Anonymous2: CRYPTUI_WIZ_DIGITAL_SIGN_INFO_1,
12139     pub pwszTimestampURL: super::super::Foundation::PWSTR,
12140     pub dwAdditionalCertChoice: CRYPTUI_WIZ_DIGITAL_ADDITIONAL_CERT_CHOICE,
12141     pub pSignExtInfo: *mut CRYPTUI_WIZ_DIGITAL_SIGN_EXTENDED_INFO,
12142 }
12143 #[cfg(feature = "Win32_Foundation")]
12144 impl CRYPTUI_WIZ_DIGITAL_SIGN_INFO {}
12145 #[cfg(feature = "Win32_Foundation")]
12146 impl ::std::default::Default for CRYPTUI_WIZ_DIGITAL_SIGN_INFO {
default() -> Self12147     fn default() -> Self {
12148         unsafe { ::std::mem::zeroed() }
12149     }
12150 }
12151 #[cfg(feature = "Win32_Foundation")]
12152 impl ::std::cmp::PartialEq for CRYPTUI_WIZ_DIGITAL_SIGN_INFO {
eq(&self, _other: &Self) -> bool12153     fn eq(&self, _other: &Self) -> bool {
12154         unimplemented!()
12155     }
12156 }
12157 #[cfg(feature = "Win32_Foundation")]
12158 impl ::std::cmp::Eq for CRYPTUI_WIZ_DIGITAL_SIGN_INFO {}
12159 #[cfg(feature = "Win32_Foundation")]
12160 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_DIGITAL_SIGN_INFO {
12161     type Abi = Self;
12162     type DefaultType = Self;
12163 }
12164 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12165 #[repr(C)]
12166 #[cfg(feature = "Win32_Foundation")]
12167 pub union CRYPTUI_WIZ_DIGITAL_SIGN_INFO_0 {
12168     pub pwszFileName: super::super::Foundation::PWSTR,
12169     pub pSignBlobInfo: *mut CRYPTUI_WIZ_DIGITAL_SIGN_BLOB_INFO,
12170 }
12171 #[cfg(feature = "Win32_Foundation")]
12172 impl CRYPTUI_WIZ_DIGITAL_SIGN_INFO_0 {}
12173 #[cfg(feature = "Win32_Foundation")]
12174 impl ::std::default::Default for CRYPTUI_WIZ_DIGITAL_SIGN_INFO_0 {
default() -> Self12175     fn default() -> Self {
12176         unsafe { ::std::mem::zeroed() }
12177     }
12178 }
12179 #[cfg(feature = "Win32_Foundation")]
12180 impl ::std::cmp::PartialEq for CRYPTUI_WIZ_DIGITAL_SIGN_INFO_0 {
eq(&self, _other: &Self) -> bool12181     fn eq(&self, _other: &Self) -> bool {
12182         unimplemented!()
12183     }
12184 }
12185 #[cfg(feature = "Win32_Foundation")]
12186 impl ::std::cmp::Eq for CRYPTUI_WIZ_DIGITAL_SIGN_INFO_0 {}
12187 #[cfg(feature = "Win32_Foundation")]
12188 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_DIGITAL_SIGN_INFO_0 {
12189     type Abi = Self;
12190     type DefaultType = Self;
12191 }
12192 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12193 #[repr(C)]
12194 #[cfg(feature = "Win32_Foundation")]
12195 pub union CRYPTUI_WIZ_DIGITAL_SIGN_INFO_1 {
12196     pub pSigningCertContext: *mut CERT_CONTEXT,
12197     pub pSigningCertStore: *mut ::std::mem::ManuallyDrop<CRYPTUI_WIZ_DIGITAL_SIGN_STORE_INFO>,
12198     pub pSigningCertPvkInfo: *mut CRYPTUI_WIZ_DIGITAL_SIGN_CERT_PVK_INFO,
12199 }
12200 #[cfg(feature = "Win32_Foundation")]
12201 impl CRYPTUI_WIZ_DIGITAL_SIGN_INFO_1 {}
12202 #[cfg(feature = "Win32_Foundation")]
12203 impl ::std::default::Default for CRYPTUI_WIZ_DIGITAL_SIGN_INFO_1 {
default() -> Self12204     fn default() -> Self {
12205         unsafe { ::std::mem::zeroed() }
12206     }
12207 }
12208 #[cfg(feature = "Win32_Foundation")]
12209 impl ::std::cmp::PartialEq for CRYPTUI_WIZ_DIGITAL_SIGN_INFO_1 {
eq(&self, _other: &Self) -> bool12210     fn eq(&self, _other: &Self) -> bool {
12211         unimplemented!()
12212     }
12213 }
12214 #[cfg(feature = "Win32_Foundation")]
12215 impl ::std::cmp::Eq for CRYPTUI_WIZ_DIGITAL_SIGN_INFO_1 {}
12216 #[cfg(feature = "Win32_Foundation")]
12217 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_DIGITAL_SIGN_INFO_1 {
12218     type Abi = Self;
12219     type DefaultType = Self;
12220 }
12221 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12222 #[repr(C)]
12223 #[cfg(feature = "Win32_Foundation")]
12224 pub struct CRYPTUI_WIZ_DIGITAL_SIGN_PVK_FILE_INFO {
12225     pub dwSize: u32,
12226     pub pwszPvkFileName: super::super::Foundation::PWSTR,
12227     pub pwszProvName: super::super::Foundation::PWSTR,
12228     pub dwProvType: u32,
12229 }
12230 #[cfg(feature = "Win32_Foundation")]
12231 impl CRYPTUI_WIZ_DIGITAL_SIGN_PVK_FILE_INFO {}
12232 #[cfg(feature = "Win32_Foundation")]
12233 impl ::std::default::Default for CRYPTUI_WIZ_DIGITAL_SIGN_PVK_FILE_INFO {
default() -> Self12234     fn default() -> Self {
12235         unsafe { ::std::mem::zeroed() }
12236     }
12237 }
12238 #[cfg(feature = "Win32_Foundation")]
12239 impl ::std::fmt::Debug for CRYPTUI_WIZ_DIGITAL_SIGN_PVK_FILE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12240     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12241         fmt.debug_struct("CRYPTUI_WIZ_DIGITAL_SIGN_PVK_FILE_INFO").field("dwSize", &self.dwSize).field("pwszPvkFileName", &self.pwszPvkFileName).field("pwszProvName", &self.pwszProvName).field("dwProvType", &self.dwProvType).finish()
12242     }
12243 }
12244 #[cfg(feature = "Win32_Foundation")]
12245 impl ::std::cmp::PartialEq for CRYPTUI_WIZ_DIGITAL_SIGN_PVK_FILE_INFO {
eq(&self, other: &Self) -> bool12246     fn eq(&self, other: &Self) -> bool {
12247         self.dwSize == other.dwSize && self.pwszPvkFileName == other.pwszPvkFileName && self.pwszProvName == other.pwszProvName && self.dwProvType == other.dwProvType
12248     }
12249 }
12250 #[cfg(feature = "Win32_Foundation")]
12251 impl ::std::cmp::Eq for CRYPTUI_WIZ_DIGITAL_SIGN_PVK_FILE_INFO {}
12252 #[cfg(feature = "Win32_Foundation")]
12253 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_DIGITAL_SIGN_PVK_FILE_INFO {
12254     type Abi = Self;
12255     type DefaultType = Self;
12256 }
12257 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12258 #[repr(transparent)]
12259 pub struct CRYPTUI_WIZ_DIGITAL_SIGN_PVK_OPTION(pub u32);
12260 pub const CRYPTUI_WIZ_DIGITAL_SIGN_PVK_FILE: CRYPTUI_WIZ_DIGITAL_SIGN_PVK_OPTION = CRYPTUI_WIZ_DIGITAL_SIGN_PVK_OPTION(1u32);
12261 pub const CRYPTUI_WIZ_DIGITAL_SIGN_PVK_PROV: CRYPTUI_WIZ_DIGITAL_SIGN_PVK_OPTION = CRYPTUI_WIZ_DIGITAL_SIGN_PVK_OPTION(2u32);
12262 impl ::std::convert::From<u32> for CRYPTUI_WIZ_DIGITAL_SIGN_PVK_OPTION {
from(value: u32) -> Self12263     fn from(value: u32) -> Self {
12264         Self(value)
12265     }
12266 }
12267 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_DIGITAL_SIGN_PVK_OPTION {
12268     type Abi = Self;
12269     type DefaultType = Self;
12270 }
12271 impl ::std::ops::BitOr for CRYPTUI_WIZ_DIGITAL_SIGN_PVK_OPTION {
12272     type Output = Self;
bitor(self, rhs: Self) -> Self12273     fn bitor(self, rhs: Self) -> Self {
12274         Self(self.0 | rhs.0)
12275     }
12276 }
12277 impl ::std::ops::BitAnd for CRYPTUI_WIZ_DIGITAL_SIGN_PVK_OPTION {
12278     type Output = Self;
bitand(self, rhs: Self) -> Self12279     fn bitand(self, rhs: Self) -> Self {
12280         Self(self.0 & rhs.0)
12281     }
12282 }
12283 impl ::std::ops::BitOrAssign for CRYPTUI_WIZ_DIGITAL_SIGN_PVK_OPTION {
bitor_assign(&mut self, rhs: Self)12284     fn bitor_assign(&mut self, rhs: Self) {
12285         self.0.bitor_assign(rhs.0)
12286     }
12287 }
12288 impl ::std::ops::BitAndAssign for CRYPTUI_WIZ_DIGITAL_SIGN_PVK_OPTION {
bitand_assign(&mut self, rhs: Self)12289     fn bitand_assign(&mut self, rhs: Self) {
12290         self.0.bitand_assign(rhs.0)
12291     }
12292 }
12293 impl ::std::ops::Not for CRYPTUI_WIZ_DIGITAL_SIGN_PVK_OPTION {
12294     type Output = Self;
not(self) -> Self12295     fn not(self) -> Self {
12296         Self(self.0.not())
12297     }
12298 }
12299 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12300 #[repr(transparent)]
12301 pub struct CRYPTUI_WIZ_DIGITAL_SIGN_SIG_TYPE(pub u32);
12302 pub const CRYPTUI_WIZ_DIGITAL_SIGN_COMMERCIAL: CRYPTUI_WIZ_DIGITAL_SIGN_SIG_TYPE = CRYPTUI_WIZ_DIGITAL_SIGN_SIG_TYPE(1u32);
12303 pub const CRYPTUI_WIZ_DIGITAL_SIGN_INDIVIDUAL: CRYPTUI_WIZ_DIGITAL_SIGN_SIG_TYPE = CRYPTUI_WIZ_DIGITAL_SIGN_SIG_TYPE(2u32);
12304 impl ::std::convert::From<u32> for CRYPTUI_WIZ_DIGITAL_SIGN_SIG_TYPE {
from(value: u32) -> Self12305     fn from(value: u32) -> Self {
12306         Self(value)
12307     }
12308 }
12309 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_DIGITAL_SIGN_SIG_TYPE {
12310     type Abi = Self;
12311     type DefaultType = Self;
12312 }
12313 impl ::std::ops::BitOr for CRYPTUI_WIZ_DIGITAL_SIGN_SIG_TYPE {
12314     type Output = Self;
bitor(self, rhs: Self) -> Self12315     fn bitor(self, rhs: Self) -> Self {
12316         Self(self.0 | rhs.0)
12317     }
12318 }
12319 impl ::std::ops::BitAnd for CRYPTUI_WIZ_DIGITAL_SIGN_SIG_TYPE {
12320     type Output = Self;
bitand(self, rhs: Self) -> Self12321     fn bitand(self, rhs: Self) -> Self {
12322         Self(self.0 & rhs.0)
12323     }
12324 }
12325 impl ::std::ops::BitOrAssign for CRYPTUI_WIZ_DIGITAL_SIGN_SIG_TYPE {
bitor_assign(&mut self, rhs: Self)12326     fn bitor_assign(&mut self, rhs: Self) {
12327         self.0.bitor_assign(rhs.0)
12328     }
12329 }
12330 impl ::std::ops::BitAndAssign for CRYPTUI_WIZ_DIGITAL_SIGN_SIG_TYPE {
bitand_assign(&mut self, rhs: Self)12331     fn bitand_assign(&mut self, rhs: Self) {
12332         self.0.bitand_assign(rhs.0)
12333     }
12334 }
12335 impl ::std::ops::Not for CRYPTUI_WIZ_DIGITAL_SIGN_SIG_TYPE {
12336     type Output = Self;
not(self) -> Self12337     fn not(self) -> Self {
12338         Self(self.0.not())
12339     }
12340 }
12341 #[derive(:: std :: clone :: Clone)]
12342 #[repr(C)]
12343 #[cfg(feature = "Win32_Foundation")]
12344 pub struct CRYPTUI_WIZ_DIGITAL_SIGN_STORE_INFO {
12345     pub dwSize: u32,
12346     pub cCertStore: u32,
12347     pub rghCertStore: *mut *mut ::std::ffi::c_void,
12348     pub pFilterCallback: ::std::option::Option<PFNCFILTERPROC>,
12349     pub pvCallbackData: *mut ::std::ffi::c_void,
12350 }
12351 #[cfg(feature = "Win32_Foundation")]
12352 impl CRYPTUI_WIZ_DIGITAL_SIGN_STORE_INFO {}
12353 #[cfg(feature = "Win32_Foundation")]
12354 impl ::std::default::Default for CRYPTUI_WIZ_DIGITAL_SIGN_STORE_INFO {
default() -> Self12355     fn default() -> Self {
12356         unsafe { ::std::mem::zeroed() }
12357     }
12358 }
12359 #[cfg(feature = "Win32_Foundation")]
12360 impl ::std::fmt::Debug for CRYPTUI_WIZ_DIGITAL_SIGN_STORE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12361     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12362         fmt.debug_struct("CRYPTUI_WIZ_DIGITAL_SIGN_STORE_INFO").field("dwSize", &self.dwSize).field("cCertStore", &self.cCertStore).field("rghCertStore", &self.rghCertStore).field("pvCallbackData", &self.pvCallbackData).finish()
12363     }
12364 }
12365 #[cfg(feature = "Win32_Foundation")]
12366 impl ::std::cmp::PartialEq for CRYPTUI_WIZ_DIGITAL_SIGN_STORE_INFO {
eq(&self, other: &Self) -> bool12367     fn eq(&self, other: &Self) -> bool {
12368         self.dwSize == other.dwSize && self.cCertStore == other.cCertStore && self.rghCertStore == other.rghCertStore && self.pFilterCallback.map(|f| f as usize) == other.pFilterCallback.map(|f| f as usize) && self.pvCallbackData == other.pvCallbackData
12369     }
12370 }
12371 #[cfg(feature = "Win32_Foundation")]
12372 impl ::std::cmp::Eq for CRYPTUI_WIZ_DIGITAL_SIGN_STORE_INFO {}
12373 #[cfg(feature = "Win32_Foundation")]
12374 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_DIGITAL_SIGN_STORE_INFO {
12375     type Abi = ::std::mem::ManuallyDrop<Self>;
12376     type DefaultType = Self;
12377 }
12378 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12379 #[repr(transparent)]
12380 pub struct CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT(pub u32);
12381 pub const CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT_BLOB: CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT = CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT(2u32);
12382 pub const CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT_FILE: CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT = CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT(1u32);
12383 pub const CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT_NONE: CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT = CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT(0u32);
12384 impl ::std::convert::From<u32> for CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT {
from(value: u32) -> Self12385     fn from(value: u32) -> Self {
12386         Self(value)
12387     }
12388 }
12389 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT {
12390     type Abi = Self;
12391     type DefaultType = Self;
12392 }
12393 impl ::std::ops::BitOr for CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT {
12394     type Output = Self;
bitor(self, rhs: Self) -> Self12395     fn bitor(self, rhs: Self) -> Self {
12396         Self(self.0 | rhs.0)
12397     }
12398 }
12399 impl ::std::ops::BitAnd for CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT {
12400     type Output = Self;
bitand(self, rhs: Self) -> Self12401     fn bitand(self, rhs: Self) -> Self {
12402         Self(self.0 & rhs.0)
12403     }
12404 }
12405 impl ::std::ops::BitOrAssign for CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT {
bitor_assign(&mut self, rhs: Self)12406     fn bitor_assign(&mut self, rhs: Self) {
12407         self.0.bitor_assign(rhs.0)
12408     }
12409 }
12410 impl ::std::ops::BitAndAssign for CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT {
bitand_assign(&mut self, rhs: Self)12411     fn bitand_assign(&mut self, rhs: Self) {
12412         self.0.bitand_assign(rhs.0)
12413     }
12414 }
12415 impl ::std::ops::Not for CRYPTUI_WIZ_DIGITAL_SIGN_SUBJECT {
12416     type Output = Self;
not(self) -> Self12417     fn not(self) -> Self {
12418         Self(self.0.not())
12419     }
12420 }
12421 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12422 #[repr(C)]
12423 #[cfg(feature = "Win32_Foundation")]
12424 pub struct CRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO {
12425     pub dwSize: u32,
12426     pub dwExportFormat: CRYPTUI_WIZ_EXPORT_FORMAT,
12427     pub fExportChain: super::super::Foundation::BOOL,
12428     pub fExportPrivateKeys: super::super::Foundation::BOOL,
12429     pub pwszPassword: super::super::Foundation::PWSTR,
12430     pub fStrongEncryption: super::super::Foundation::BOOL,
12431 }
12432 #[cfg(feature = "Win32_Foundation")]
12433 impl CRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO {}
12434 #[cfg(feature = "Win32_Foundation")]
12435 impl ::std::default::Default for CRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO {
default() -> Self12436     fn default() -> Self {
12437         unsafe { ::std::mem::zeroed() }
12438     }
12439 }
12440 #[cfg(feature = "Win32_Foundation")]
12441 impl ::std::fmt::Debug for CRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12442     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12443         fmt.debug_struct("CRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO")
12444             .field("dwSize", &self.dwSize)
12445             .field("dwExportFormat", &self.dwExportFormat)
12446             .field("fExportChain", &self.fExportChain)
12447             .field("fExportPrivateKeys", &self.fExportPrivateKeys)
12448             .field("pwszPassword", &self.pwszPassword)
12449             .field("fStrongEncryption", &self.fStrongEncryption)
12450             .finish()
12451     }
12452 }
12453 #[cfg(feature = "Win32_Foundation")]
12454 impl ::std::cmp::PartialEq for CRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO {
eq(&self, other: &Self) -> bool12455     fn eq(&self, other: &Self) -> bool {
12456         self.dwSize == other.dwSize && self.dwExportFormat == other.dwExportFormat && self.fExportChain == other.fExportChain && self.fExportPrivateKeys == other.fExportPrivateKeys && self.pwszPassword == other.pwszPassword && self.fStrongEncryption == other.fStrongEncryption
12457     }
12458 }
12459 #[cfg(feature = "Win32_Foundation")]
12460 impl ::std::cmp::Eq for CRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO {}
12461 #[cfg(feature = "Win32_Foundation")]
12462 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO {
12463     type Abi = Self;
12464     type DefaultType = Self;
12465 }
12466 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12467 #[repr(transparent)]
12468 pub struct CRYPTUI_WIZ_EXPORT_FORMAT(pub u32);
12469 pub const CRYPTUI_WIZ_EXPORT_FORMAT_DER: CRYPTUI_WIZ_EXPORT_FORMAT = CRYPTUI_WIZ_EXPORT_FORMAT(1u32);
12470 pub const CRYPTUI_WIZ_EXPORT_FORMAT_PFX: CRYPTUI_WIZ_EXPORT_FORMAT = CRYPTUI_WIZ_EXPORT_FORMAT(2u32);
12471 pub const CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7: CRYPTUI_WIZ_EXPORT_FORMAT = CRYPTUI_WIZ_EXPORT_FORMAT(3u32);
12472 pub const CRYPTUI_WIZ_EXPORT_FORMAT_BASE64: CRYPTUI_WIZ_EXPORT_FORMAT = CRYPTUI_WIZ_EXPORT_FORMAT(4u32);
12473 pub const CRYPTUI_WIZ_EXPORT_FORMAT_CRL: CRYPTUI_WIZ_EXPORT_FORMAT = CRYPTUI_WIZ_EXPORT_FORMAT(6u32);
12474 pub const CRYPTUI_WIZ_EXPORT_FORMAT_CTL: CRYPTUI_WIZ_EXPORT_FORMAT = CRYPTUI_WIZ_EXPORT_FORMAT(7u32);
12475 impl ::std::convert::From<u32> for CRYPTUI_WIZ_EXPORT_FORMAT {
from(value: u32) -> Self12476     fn from(value: u32) -> Self {
12477         Self(value)
12478     }
12479 }
12480 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_EXPORT_FORMAT {
12481     type Abi = Self;
12482     type DefaultType = Self;
12483 }
12484 impl ::std::ops::BitOr for CRYPTUI_WIZ_EXPORT_FORMAT {
12485     type Output = Self;
bitor(self, rhs: Self) -> Self12486     fn bitor(self, rhs: Self) -> Self {
12487         Self(self.0 | rhs.0)
12488     }
12489 }
12490 impl ::std::ops::BitAnd for CRYPTUI_WIZ_EXPORT_FORMAT {
12491     type Output = Self;
bitand(self, rhs: Self) -> Self12492     fn bitand(self, rhs: Self) -> Self {
12493         Self(self.0 & rhs.0)
12494     }
12495 }
12496 impl ::std::ops::BitOrAssign for CRYPTUI_WIZ_EXPORT_FORMAT {
bitor_assign(&mut self, rhs: Self)12497     fn bitor_assign(&mut self, rhs: Self) {
12498         self.0.bitor_assign(rhs.0)
12499     }
12500 }
12501 impl ::std::ops::BitAndAssign for CRYPTUI_WIZ_EXPORT_FORMAT {
bitand_assign(&mut self, rhs: Self)12502     fn bitand_assign(&mut self, rhs: Self) {
12503         self.0.bitand_assign(rhs.0)
12504     }
12505 }
12506 impl ::std::ops::Not for CRYPTUI_WIZ_EXPORT_FORMAT {
12507     type Output = Self;
not(self) -> Self12508     fn not(self) -> Self {
12509         Self(self.0.not())
12510     }
12511 }
12512 pub const CRYPTUI_WIZ_EXPORT_FORMAT_SERIALIZED_CERT_STORE: u32 = 5u32;
12513 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12514 #[repr(C)]
12515 #[cfg(feature = "Win32_Foundation")]
12516 pub struct CRYPTUI_WIZ_EXPORT_INFO {
12517     pub dwSize: u32,
12518     pub pwszExportFileName: super::super::Foundation::PWSTR,
12519     pub dwSubjectChoice: CRYPTUI_WIZ_EXPORT_SUBJECT,
12520     pub Anonymous: CRYPTUI_WIZ_EXPORT_INFO_0,
12521     pub cStores: u32,
12522     pub rghStores: *mut *mut ::std::ffi::c_void,
12523 }
12524 #[cfg(feature = "Win32_Foundation")]
12525 impl CRYPTUI_WIZ_EXPORT_INFO {}
12526 #[cfg(feature = "Win32_Foundation")]
12527 impl ::std::default::Default for CRYPTUI_WIZ_EXPORT_INFO {
default() -> Self12528     fn default() -> Self {
12529         unsafe { ::std::mem::zeroed() }
12530     }
12531 }
12532 #[cfg(feature = "Win32_Foundation")]
12533 impl ::std::cmp::PartialEq for CRYPTUI_WIZ_EXPORT_INFO {
eq(&self, _other: &Self) -> bool12534     fn eq(&self, _other: &Self) -> bool {
12535         unimplemented!()
12536     }
12537 }
12538 #[cfg(feature = "Win32_Foundation")]
12539 impl ::std::cmp::Eq for CRYPTUI_WIZ_EXPORT_INFO {}
12540 #[cfg(feature = "Win32_Foundation")]
12541 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_EXPORT_INFO {
12542     type Abi = Self;
12543     type DefaultType = Self;
12544 }
12545 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12546 #[repr(C)]
12547 #[cfg(feature = "Win32_Foundation")]
12548 pub union CRYPTUI_WIZ_EXPORT_INFO_0 {
12549     pub pCertContext: *mut CERT_CONTEXT,
12550     pub pCTLContext: *mut CTL_CONTEXT,
12551     pub pCRLContext: *mut CRL_CONTEXT,
12552     pub hCertStore: *mut ::std::ffi::c_void,
12553 }
12554 #[cfg(feature = "Win32_Foundation")]
12555 impl CRYPTUI_WIZ_EXPORT_INFO_0 {}
12556 #[cfg(feature = "Win32_Foundation")]
12557 impl ::std::default::Default for CRYPTUI_WIZ_EXPORT_INFO_0 {
default() -> Self12558     fn default() -> Self {
12559         unsafe { ::std::mem::zeroed() }
12560     }
12561 }
12562 #[cfg(feature = "Win32_Foundation")]
12563 impl ::std::cmp::PartialEq for CRYPTUI_WIZ_EXPORT_INFO_0 {
eq(&self, _other: &Self) -> bool12564     fn eq(&self, _other: &Self) -> bool {
12565         unimplemented!()
12566     }
12567 }
12568 #[cfg(feature = "Win32_Foundation")]
12569 impl ::std::cmp::Eq for CRYPTUI_WIZ_EXPORT_INFO_0 {}
12570 #[cfg(feature = "Win32_Foundation")]
12571 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_EXPORT_INFO_0 {
12572     type Abi = Self;
12573     type DefaultType = Self;
12574 }
12575 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12576 #[repr(transparent)]
12577 pub struct CRYPTUI_WIZ_EXPORT_SUBJECT(pub u32);
12578 pub const CRYPTUI_WIZ_EXPORT_CERT_CONTEXT: CRYPTUI_WIZ_EXPORT_SUBJECT = CRYPTUI_WIZ_EXPORT_SUBJECT(1u32);
12579 pub const CRYPTUI_WIZ_EXPORT_CTL_CONTEXT: CRYPTUI_WIZ_EXPORT_SUBJECT = CRYPTUI_WIZ_EXPORT_SUBJECT(2u32);
12580 pub const CRYPTUI_WIZ_EXPORT_CRL_CONTEXT: CRYPTUI_WIZ_EXPORT_SUBJECT = CRYPTUI_WIZ_EXPORT_SUBJECT(3u32);
12581 pub const CRYPTUI_WIZ_EXPORT_CERT_STORE: CRYPTUI_WIZ_EXPORT_SUBJECT = CRYPTUI_WIZ_EXPORT_SUBJECT(4u32);
12582 pub const CRYPTUI_WIZ_EXPORT_CERT_STORE_CERTIFICATES_ONLY: CRYPTUI_WIZ_EXPORT_SUBJECT = CRYPTUI_WIZ_EXPORT_SUBJECT(5u32);
12583 impl ::std::convert::From<u32> for CRYPTUI_WIZ_EXPORT_SUBJECT {
from(value: u32) -> Self12584     fn from(value: u32) -> Self {
12585         Self(value)
12586     }
12587 }
12588 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_EXPORT_SUBJECT {
12589     type Abi = Self;
12590     type DefaultType = Self;
12591 }
12592 impl ::std::ops::BitOr for CRYPTUI_WIZ_EXPORT_SUBJECT {
12593     type Output = Self;
bitor(self, rhs: Self) -> Self12594     fn bitor(self, rhs: Self) -> Self {
12595         Self(self.0 | rhs.0)
12596     }
12597 }
12598 impl ::std::ops::BitAnd for CRYPTUI_WIZ_EXPORT_SUBJECT {
12599     type Output = Self;
bitand(self, rhs: Self) -> Self12600     fn bitand(self, rhs: Self) -> Self {
12601         Self(self.0 & rhs.0)
12602     }
12603 }
12604 impl ::std::ops::BitOrAssign for CRYPTUI_WIZ_EXPORT_SUBJECT {
bitor_assign(&mut self, rhs: Self)12605     fn bitor_assign(&mut self, rhs: Self) {
12606         self.0.bitor_assign(rhs.0)
12607     }
12608 }
12609 impl ::std::ops::BitAndAssign for CRYPTUI_WIZ_EXPORT_SUBJECT {
bitand_assign(&mut self, rhs: Self)12610     fn bitand_assign(&mut self, rhs: Self) {
12611         self.0.bitand_assign(rhs.0)
12612     }
12613 }
12614 impl ::std::ops::Not for CRYPTUI_WIZ_EXPORT_SUBJECT {
12615     type Output = Self;
not(self) -> Self12616     fn not(self) -> Self {
12617         Self(self.0.not())
12618     }
12619 }
12620 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12621 #[repr(transparent)]
12622 pub struct CRYPTUI_WIZ_FLAGS(pub u32);
12623 pub const CRYPTUI_WIZ_NO_UI: CRYPTUI_WIZ_FLAGS = CRYPTUI_WIZ_FLAGS(1u32);
12624 pub const CRYPTUI_WIZ_IGNORE_NO_UI_FLAG_FOR_CSPS: CRYPTUI_WIZ_FLAGS = CRYPTUI_WIZ_FLAGS(2u32);
12625 pub const CRYPTUI_WIZ_NO_UI_EXCEPT_CSP: CRYPTUI_WIZ_FLAGS = CRYPTUI_WIZ_FLAGS(3u32);
12626 pub const CRYPTUI_WIZ_IMPORT_ALLOW_CERT: CRYPTUI_WIZ_FLAGS = CRYPTUI_WIZ_FLAGS(131072u32);
12627 pub const CRYPTUI_WIZ_IMPORT_ALLOW_CRL: CRYPTUI_WIZ_FLAGS = CRYPTUI_WIZ_FLAGS(262144u32);
12628 pub const CRYPTUI_WIZ_IMPORT_ALLOW_CTL: CRYPTUI_WIZ_FLAGS = CRYPTUI_WIZ_FLAGS(524288u32);
12629 pub const CRYPTUI_WIZ_IMPORT_NO_CHANGE_DEST_STORE: CRYPTUI_WIZ_FLAGS = CRYPTUI_WIZ_FLAGS(65536u32);
12630 pub const CRYPTUI_WIZ_IMPORT_TO_LOCALMACHINE: CRYPTUI_WIZ_FLAGS = CRYPTUI_WIZ_FLAGS(1048576u32);
12631 pub const CRYPTUI_WIZ_IMPORT_TO_CURRENTUSER: CRYPTUI_WIZ_FLAGS = CRYPTUI_WIZ_FLAGS(2097152u32);
12632 pub const CRYPTUI_WIZ_IMPORT_REMOTE_DEST_STORE: CRYPTUI_WIZ_FLAGS = CRYPTUI_WIZ_FLAGS(4194304u32);
12633 pub const CRYPTUI_WIZ_EXPORT_PRIVATE_KEY: CRYPTUI_WIZ_FLAGS = CRYPTUI_WIZ_FLAGS(256u32);
12634 pub const CRYPTUI_WIZ_EXPORT_NO_DELETE_PRIVATE_KEY: CRYPTUI_WIZ_FLAGS = CRYPTUI_WIZ_FLAGS(512u32);
12635 impl ::std::convert::From<u32> for CRYPTUI_WIZ_FLAGS {
from(value: u32) -> Self12636     fn from(value: u32) -> Self {
12637         Self(value)
12638     }
12639 }
12640 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_FLAGS {
12641     type Abi = Self;
12642     type DefaultType = Self;
12643 }
12644 impl ::std::ops::BitOr for CRYPTUI_WIZ_FLAGS {
12645     type Output = Self;
bitor(self, rhs: Self) -> Self12646     fn bitor(self, rhs: Self) -> Self {
12647         Self(self.0 | rhs.0)
12648     }
12649 }
12650 impl ::std::ops::BitAnd for CRYPTUI_WIZ_FLAGS {
12651     type Output = Self;
bitand(self, rhs: Self) -> Self12652     fn bitand(self, rhs: Self) -> Self {
12653         Self(self.0 & rhs.0)
12654     }
12655 }
12656 impl ::std::ops::BitOrAssign for CRYPTUI_WIZ_FLAGS {
bitor_assign(&mut self, rhs: Self)12657     fn bitor_assign(&mut self, rhs: Self) {
12658         self.0.bitor_assign(rhs.0)
12659     }
12660 }
12661 impl ::std::ops::BitAndAssign for CRYPTUI_WIZ_FLAGS {
bitand_assign(&mut self, rhs: Self)12662     fn bitand_assign(&mut self, rhs: Self) {
12663         self.0.bitand_assign(rhs.0)
12664     }
12665 }
12666 impl ::std::ops::Not for CRYPTUI_WIZ_FLAGS {
12667     type Output = Self;
not(self) -> Self12668     fn not(self) -> Self {
12669         Self(self.0.not())
12670     }
12671 }
12672 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12673 #[repr(C)]
12674 #[cfg(feature = "Win32_Foundation")]
12675 pub struct CRYPTUI_WIZ_IMPORT_SRC_INFO {
12676     pub dwSize: u32,
12677     pub dwSubjectChoice: CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION,
12678     pub Anonymous: CRYPTUI_WIZ_IMPORT_SRC_INFO_0,
12679     pub dwFlags: CRYPT_KEY_FLAGS,
12680     pub pwszPassword: super::super::Foundation::PWSTR,
12681 }
12682 #[cfg(feature = "Win32_Foundation")]
12683 impl CRYPTUI_WIZ_IMPORT_SRC_INFO {}
12684 #[cfg(feature = "Win32_Foundation")]
12685 impl ::std::default::Default for CRYPTUI_WIZ_IMPORT_SRC_INFO {
default() -> Self12686     fn default() -> Self {
12687         unsafe { ::std::mem::zeroed() }
12688     }
12689 }
12690 #[cfg(feature = "Win32_Foundation")]
12691 impl ::std::cmp::PartialEq for CRYPTUI_WIZ_IMPORT_SRC_INFO {
eq(&self, _other: &Self) -> bool12692     fn eq(&self, _other: &Self) -> bool {
12693         unimplemented!()
12694     }
12695 }
12696 #[cfg(feature = "Win32_Foundation")]
12697 impl ::std::cmp::Eq for CRYPTUI_WIZ_IMPORT_SRC_INFO {}
12698 #[cfg(feature = "Win32_Foundation")]
12699 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_IMPORT_SRC_INFO {
12700     type Abi = Self;
12701     type DefaultType = Self;
12702 }
12703 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12704 #[repr(C)]
12705 #[cfg(feature = "Win32_Foundation")]
12706 pub union CRYPTUI_WIZ_IMPORT_SRC_INFO_0 {
12707     pub pwszFileName: super::super::Foundation::PWSTR,
12708     pub pCertContext: *mut CERT_CONTEXT,
12709     pub pCTLContext: *mut CTL_CONTEXT,
12710     pub pCRLContext: *mut CRL_CONTEXT,
12711     pub hCertStore: *mut ::std::ffi::c_void,
12712 }
12713 #[cfg(feature = "Win32_Foundation")]
12714 impl CRYPTUI_WIZ_IMPORT_SRC_INFO_0 {}
12715 #[cfg(feature = "Win32_Foundation")]
12716 impl ::std::default::Default for CRYPTUI_WIZ_IMPORT_SRC_INFO_0 {
default() -> Self12717     fn default() -> Self {
12718         unsafe { ::std::mem::zeroed() }
12719     }
12720 }
12721 #[cfg(feature = "Win32_Foundation")]
12722 impl ::std::cmp::PartialEq for CRYPTUI_WIZ_IMPORT_SRC_INFO_0 {
eq(&self, _other: &Self) -> bool12723     fn eq(&self, _other: &Self) -> bool {
12724         unimplemented!()
12725     }
12726 }
12727 #[cfg(feature = "Win32_Foundation")]
12728 impl ::std::cmp::Eq for CRYPTUI_WIZ_IMPORT_SRC_INFO_0 {}
12729 #[cfg(feature = "Win32_Foundation")]
12730 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_IMPORT_SRC_INFO_0 {
12731     type Abi = Self;
12732     type DefaultType = Self;
12733 }
12734 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12735 #[repr(transparent)]
12736 pub struct CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION(pub u32);
12737 pub const CRYPTUI_WIZ_IMPORT_SUBJECT_FILE: CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION = CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION(1u32);
12738 pub const CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_CONTEXT: CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION = CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION(2u32);
12739 pub const CRYPTUI_WIZ_IMPORT_SUBJECT_CTL_CONTEXT: CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION = CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION(3u32);
12740 pub const CRYPTUI_WIZ_IMPORT_SUBJECT_CRL_CONTEXT: CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION = CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION(4u32);
12741 pub const CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_STORE: CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION = CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION(5u32);
12742 impl ::std::convert::From<u32> for CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION {
from(value: u32) -> Self12743     fn from(value: u32) -> Self {
12744         Self(value)
12745     }
12746 }
12747 unsafe impl ::windows::runtime::Abi for CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION {
12748     type Abi = Self;
12749     type DefaultType = Self;
12750 }
12751 impl ::std::ops::BitOr for CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION {
12752     type Output = Self;
bitor(self, rhs: Self) -> Self12753     fn bitor(self, rhs: Self) -> Self {
12754         Self(self.0 | rhs.0)
12755     }
12756 }
12757 impl ::std::ops::BitAnd for CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION {
12758     type Output = Self;
bitand(self, rhs: Self) -> Self12759     fn bitand(self, rhs: Self) -> Self {
12760         Self(self.0 & rhs.0)
12761     }
12762 }
12763 impl ::std::ops::BitOrAssign for CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION {
bitor_assign(&mut self, rhs: Self)12764     fn bitor_assign(&mut self, rhs: Self) {
12765         self.0.bitor_assign(rhs.0)
12766     }
12767 }
12768 impl ::std::ops::BitAndAssign for CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION {
bitand_assign(&mut self, rhs: Self)12769     fn bitand_assign(&mut self, rhs: Self) {
12770         self.0.bitand_assign(rhs.0)
12771     }
12772 }
12773 impl ::std::ops::Not for CRYPTUI_WIZ_IMPORT_SUBJECT_OPTION {
12774     type Output = Self;
not(self) -> Self12775     fn not(self) -> Self {
12776         Self(self.0.not())
12777     }
12778 }
12779 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12780 #[repr(C)]
12781 pub struct CRYPT_3DES_KEY_STATE {
12782     pub Key: [u8; 24],
12783     pub IV: [u8; 8],
12784     pub Feedback: [u8; 8],
12785 }
12786 impl CRYPT_3DES_KEY_STATE {}
12787 impl ::std::default::Default for CRYPT_3DES_KEY_STATE {
default() -> Self12788     fn default() -> Self {
12789         unsafe { ::std::mem::zeroed() }
12790     }
12791 }
12792 impl ::std::fmt::Debug for CRYPT_3DES_KEY_STATE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12793     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12794         fmt.debug_struct("CRYPT_3DES_KEY_STATE").field("Key", &self.Key).field("IV", &self.IV).field("Feedback", &self.Feedback).finish()
12795     }
12796 }
12797 impl ::std::cmp::PartialEq for CRYPT_3DES_KEY_STATE {
eq(&self, other: &Self) -> bool12798     fn eq(&self, other: &Self) -> bool {
12799         self.Key == other.Key && self.IV == other.IV && self.Feedback == other.Feedback
12800     }
12801 }
12802 impl ::std::cmp::Eq for CRYPT_3DES_KEY_STATE {}
12803 unsafe impl ::windows::runtime::Abi for CRYPT_3DES_KEY_STATE {
12804     type Abi = Self;
12805     type DefaultType = Self;
12806 }
12807 pub const CRYPT_ACCUMULATIVE_TIMEOUT: u32 = 2048u32;
12808 pub const CRYPT_ACQUIRE_ALLOW_NCRYPT_KEY_FLAG: u32 = 65536u32;
12809 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12810 #[repr(transparent)]
12811 pub struct CRYPT_ACQUIRE_FLAGS(pub u32);
12812 pub const CRYPT_ACQUIRE_CACHE_FLAG: CRYPT_ACQUIRE_FLAGS = CRYPT_ACQUIRE_FLAGS(1u32);
12813 pub const CRYPT_ACQUIRE_COMPARE_KEY_FLAG: CRYPT_ACQUIRE_FLAGS = CRYPT_ACQUIRE_FLAGS(4u32);
12814 pub const CRYPT_ACQUIRE_NO_HEALING: CRYPT_ACQUIRE_FLAGS = CRYPT_ACQUIRE_FLAGS(8u32);
12815 pub const CRYPT_ACQUIRE_SILENT_FLAG: CRYPT_ACQUIRE_FLAGS = CRYPT_ACQUIRE_FLAGS(64u32);
12816 pub const CRYPT_ACQUIRE_USE_PROV_INFO_FLAG: CRYPT_ACQUIRE_FLAGS = CRYPT_ACQUIRE_FLAGS(2u32);
12817 impl ::std::convert::From<u32> for CRYPT_ACQUIRE_FLAGS {
from(value: u32) -> Self12818     fn from(value: u32) -> Self {
12819         Self(value)
12820     }
12821 }
12822 unsafe impl ::windows::runtime::Abi for CRYPT_ACQUIRE_FLAGS {
12823     type Abi = Self;
12824     type DefaultType = Self;
12825 }
12826 impl ::std::ops::BitOr for CRYPT_ACQUIRE_FLAGS {
12827     type Output = Self;
bitor(self, rhs: Self) -> Self12828     fn bitor(self, rhs: Self) -> Self {
12829         Self(self.0 | rhs.0)
12830     }
12831 }
12832 impl ::std::ops::BitAnd for CRYPT_ACQUIRE_FLAGS {
12833     type Output = Self;
bitand(self, rhs: Self) -> Self12834     fn bitand(self, rhs: Self) -> Self {
12835         Self(self.0 & rhs.0)
12836     }
12837 }
12838 impl ::std::ops::BitOrAssign for CRYPT_ACQUIRE_FLAGS {
bitor_assign(&mut self, rhs: Self)12839     fn bitor_assign(&mut self, rhs: Self) {
12840         self.0.bitor_assign(rhs.0)
12841     }
12842 }
12843 impl ::std::ops::BitAndAssign for CRYPT_ACQUIRE_FLAGS {
bitand_assign(&mut self, rhs: Self)12844     fn bitand_assign(&mut self, rhs: Self) {
12845         self.0.bitand_assign(rhs.0)
12846     }
12847 }
12848 impl ::std::ops::Not for CRYPT_ACQUIRE_FLAGS {
12849     type Output = Self;
not(self) -> Self12850     fn not(self) -> Self {
12851         Self(self.0.not())
12852     }
12853 }
12854 pub const CRYPT_ACQUIRE_NCRYPT_KEY_FLAGS_MASK: u32 = 458752u32;
12855 pub const CRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAG: u32 = 262144u32;
12856 pub const CRYPT_ACQUIRE_PREFER_NCRYPT_KEY_FLAG: u32 = 131072u32;
12857 pub const CRYPT_ACQUIRE_WINDOW_HANDLE_FLAG: u32 = 128u32;
12858 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12859 #[repr(C)]
12860 pub struct CRYPT_AES_128_KEY_STATE {
12861     pub Key: [u8; 16],
12862     pub IV: [u8; 16],
12863     pub EncryptionState: [u8; 176],
12864     pub DecryptionState: [u8; 176],
12865     pub Feedback: [u8; 16],
12866 }
12867 impl CRYPT_AES_128_KEY_STATE {}
12868 impl ::std::default::Default for CRYPT_AES_128_KEY_STATE {
default() -> Self12869     fn default() -> Self {
12870         unsafe { ::std::mem::zeroed() }
12871     }
12872 }
12873 impl ::std::fmt::Debug for CRYPT_AES_128_KEY_STATE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12874     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12875         fmt.debug_struct("CRYPT_AES_128_KEY_STATE").field("Key", &self.Key).field("IV", &self.IV).field("EncryptionState", &self.EncryptionState).field("DecryptionState", &self.DecryptionState).field("Feedback", &self.Feedback).finish()
12876     }
12877 }
12878 impl ::std::cmp::PartialEq for CRYPT_AES_128_KEY_STATE {
eq(&self, other: &Self) -> bool12879     fn eq(&self, other: &Self) -> bool {
12880         self.Key == other.Key && self.IV == other.IV && self.EncryptionState == other.EncryptionState && self.DecryptionState == other.DecryptionState && self.Feedback == other.Feedback
12881     }
12882 }
12883 impl ::std::cmp::Eq for CRYPT_AES_128_KEY_STATE {}
12884 unsafe impl ::windows::runtime::Abi for CRYPT_AES_128_KEY_STATE {
12885     type Abi = Self;
12886     type DefaultType = Self;
12887 }
12888 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12889 #[repr(C)]
12890 pub struct CRYPT_AES_256_KEY_STATE {
12891     pub Key: [u8; 32],
12892     pub IV: [u8; 16],
12893     pub EncryptionState: [u8; 240],
12894     pub DecryptionState: [u8; 240],
12895     pub Feedback: [u8; 16],
12896 }
12897 impl CRYPT_AES_256_KEY_STATE {}
12898 impl ::std::default::Default for CRYPT_AES_256_KEY_STATE {
default() -> Self12899     fn default() -> Self {
12900         unsafe { ::std::mem::zeroed() }
12901     }
12902 }
12903 impl ::std::fmt::Debug for CRYPT_AES_256_KEY_STATE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12904     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12905         fmt.debug_struct("CRYPT_AES_256_KEY_STATE").field("Key", &self.Key).field("IV", &self.IV).field("EncryptionState", &self.EncryptionState).field("DecryptionState", &self.DecryptionState).field("Feedback", &self.Feedback).finish()
12906     }
12907 }
12908 impl ::std::cmp::PartialEq for CRYPT_AES_256_KEY_STATE {
eq(&self, other: &Self) -> bool12909     fn eq(&self, other: &Self) -> bool {
12910         self.Key == other.Key && self.IV == other.IV && self.EncryptionState == other.EncryptionState && self.DecryptionState == other.DecryptionState && self.Feedback == other.Feedback
12911     }
12912 }
12913 impl ::std::cmp::Eq for CRYPT_AES_256_KEY_STATE {}
12914 unsafe impl ::windows::runtime::Abi for CRYPT_AES_256_KEY_STATE {
12915     type Abi = Self;
12916     type DefaultType = Self;
12917 }
12918 pub const CRYPT_AIA_RETRIEVAL: u32 = 524288u32;
12919 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12920 #[repr(C)]
12921 #[cfg(feature = "Win32_Foundation")]
12922 pub struct CRYPT_ALGORITHM_IDENTIFIER {
12923     pub pszObjId: super::super::Foundation::PSTR,
12924     pub Parameters: CRYPTOAPI_BLOB,
12925 }
12926 #[cfg(feature = "Win32_Foundation")]
12927 impl CRYPT_ALGORITHM_IDENTIFIER {}
12928 #[cfg(feature = "Win32_Foundation")]
12929 impl ::std::default::Default for CRYPT_ALGORITHM_IDENTIFIER {
default() -> Self12930     fn default() -> Self {
12931         unsafe { ::std::mem::zeroed() }
12932     }
12933 }
12934 #[cfg(feature = "Win32_Foundation")]
12935 impl ::std::fmt::Debug for CRYPT_ALGORITHM_IDENTIFIER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12936     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12937         fmt.debug_struct("CRYPT_ALGORITHM_IDENTIFIER").field("pszObjId", &self.pszObjId).field("Parameters", &self.Parameters).finish()
12938     }
12939 }
12940 #[cfg(feature = "Win32_Foundation")]
12941 impl ::std::cmp::PartialEq for CRYPT_ALGORITHM_IDENTIFIER {
eq(&self, other: &Self) -> bool12942     fn eq(&self, other: &Self) -> bool {
12943         self.pszObjId == other.pszObjId && self.Parameters == other.Parameters
12944     }
12945 }
12946 #[cfg(feature = "Win32_Foundation")]
12947 impl ::std::cmp::Eq for CRYPT_ALGORITHM_IDENTIFIER {}
12948 #[cfg(feature = "Win32_Foundation")]
12949 unsafe impl ::windows::runtime::Abi for CRYPT_ALGORITHM_IDENTIFIER {
12950     type Abi = Self;
12951     type DefaultType = Self;
12952 }
12953 pub const CRYPT_ARCHIVE: u32 = 256u32;
12954 pub const CRYPT_ASN_ENCODING: u32 = 1u32;
12955 pub const CRYPT_ASYNC_RETRIEVAL: u32 = 16u32;
12956 #[derive(:: std :: clone :: Clone)]
12957 #[repr(C)]
12958 #[cfg(feature = "Win32_Foundation")]
12959 pub struct CRYPT_ASYNC_RETRIEVAL_COMPLETION {
12960     pub pfnCompletion: ::std::option::Option<PFN_CRYPT_ASYNC_RETRIEVAL_COMPLETION_FUNC>,
12961     pub pvCompletion: *mut ::std::ffi::c_void,
12962 }
12963 #[cfg(feature = "Win32_Foundation")]
12964 impl CRYPT_ASYNC_RETRIEVAL_COMPLETION {}
12965 #[cfg(feature = "Win32_Foundation")]
12966 impl ::std::default::Default for CRYPT_ASYNC_RETRIEVAL_COMPLETION {
default() -> Self12967     fn default() -> Self {
12968         unsafe { ::std::mem::zeroed() }
12969     }
12970 }
12971 #[cfg(feature = "Win32_Foundation")]
12972 impl ::std::fmt::Debug for CRYPT_ASYNC_RETRIEVAL_COMPLETION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12973     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12974         fmt.debug_struct("CRYPT_ASYNC_RETRIEVAL_COMPLETION").field("pvCompletion", &self.pvCompletion).finish()
12975     }
12976 }
12977 #[cfg(feature = "Win32_Foundation")]
12978 impl ::std::cmp::PartialEq for CRYPT_ASYNC_RETRIEVAL_COMPLETION {
eq(&self, other: &Self) -> bool12979     fn eq(&self, other: &Self) -> bool {
12980         self.pfnCompletion.map(|f| f as usize) == other.pfnCompletion.map(|f| f as usize) && self.pvCompletion == other.pvCompletion
12981     }
12982 }
12983 #[cfg(feature = "Win32_Foundation")]
12984 impl ::std::cmp::Eq for CRYPT_ASYNC_RETRIEVAL_COMPLETION {}
12985 #[cfg(feature = "Win32_Foundation")]
12986 unsafe impl ::windows::runtime::Abi for CRYPT_ASYNC_RETRIEVAL_COMPLETION {
12987     type Abi = ::std::mem::ManuallyDrop<Self>;
12988     type DefaultType = Self;
12989 }
12990 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12991 #[repr(C)]
12992 #[cfg(feature = "Win32_Foundation")]
12993 pub struct CRYPT_ATTRIBUTE {
12994     pub pszObjId: super::super::Foundation::PSTR,
12995     pub cValue: u32,
12996     pub rgValue: *mut CRYPTOAPI_BLOB,
12997 }
12998 #[cfg(feature = "Win32_Foundation")]
12999 impl CRYPT_ATTRIBUTE {}
13000 #[cfg(feature = "Win32_Foundation")]
13001 impl ::std::default::Default for CRYPT_ATTRIBUTE {
default() -> Self13002     fn default() -> Self {
13003         unsafe { ::std::mem::zeroed() }
13004     }
13005 }
13006 #[cfg(feature = "Win32_Foundation")]
13007 impl ::std::fmt::Debug for CRYPT_ATTRIBUTE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13008     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13009         fmt.debug_struct("CRYPT_ATTRIBUTE").field("pszObjId", &self.pszObjId).field("cValue", &self.cValue).field("rgValue", &self.rgValue).finish()
13010     }
13011 }
13012 #[cfg(feature = "Win32_Foundation")]
13013 impl ::std::cmp::PartialEq for CRYPT_ATTRIBUTE {
eq(&self, other: &Self) -> bool13014     fn eq(&self, other: &Self) -> bool {
13015         self.pszObjId == other.pszObjId && self.cValue == other.cValue && self.rgValue == other.rgValue
13016     }
13017 }
13018 #[cfg(feature = "Win32_Foundation")]
13019 impl ::std::cmp::Eq for CRYPT_ATTRIBUTE {}
13020 #[cfg(feature = "Win32_Foundation")]
13021 unsafe impl ::windows::runtime::Abi for CRYPT_ATTRIBUTE {
13022     type Abi = Self;
13023     type DefaultType = Self;
13024 }
13025 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13026 #[repr(C)]
13027 #[cfg(feature = "Win32_Foundation")]
13028 pub struct CRYPT_ATTRIBUTES {
13029     pub cAttr: u32,
13030     pub rgAttr: *mut CRYPT_ATTRIBUTE,
13031 }
13032 #[cfg(feature = "Win32_Foundation")]
13033 impl CRYPT_ATTRIBUTES {}
13034 #[cfg(feature = "Win32_Foundation")]
13035 impl ::std::default::Default for CRYPT_ATTRIBUTES {
default() -> Self13036     fn default() -> Self {
13037         unsafe { ::std::mem::zeroed() }
13038     }
13039 }
13040 #[cfg(feature = "Win32_Foundation")]
13041 impl ::std::fmt::Debug for CRYPT_ATTRIBUTES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13042     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13043         fmt.debug_struct("CRYPT_ATTRIBUTES").field("cAttr", &self.cAttr).field("rgAttr", &self.rgAttr).finish()
13044     }
13045 }
13046 #[cfg(feature = "Win32_Foundation")]
13047 impl ::std::cmp::PartialEq for CRYPT_ATTRIBUTES {
eq(&self, other: &Self) -> bool13048     fn eq(&self, other: &Self) -> bool {
13049         self.cAttr == other.cAttr && self.rgAttr == other.rgAttr
13050     }
13051 }
13052 #[cfg(feature = "Win32_Foundation")]
13053 impl ::std::cmp::Eq for CRYPT_ATTRIBUTES {}
13054 #[cfg(feature = "Win32_Foundation")]
13055 unsafe impl ::windows::runtime::Abi for CRYPT_ATTRIBUTES {
13056     type Abi = Self;
13057     type DefaultType = Self;
13058 }
13059 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13060 #[repr(C)]
13061 #[cfg(feature = "Win32_Foundation")]
13062 pub struct CRYPT_ATTRIBUTE_TYPE_VALUE {
13063     pub pszObjId: super::super::Foundation::PSTR,
13064     pub Value: CRYPTOAPI_BLOB,
13065 }
13066 #[cfg(feature = "Win32_Foundation")]
13067 impl CRYPT_ATTRIBUTE_TYPE_VALUE {}
13068 #[cfg(feature = "Win32_Foundation")]
13069 impl ::std::default::Default for CRYPT_ATTRIBUTE_TYPE_VALUE {
default() -> Self13070     fn default() -> Self {
13071         unsafe { ::std::mem::zeroed() }
13072     }
13073 }
13074 #[cfg(feature = "Win32_Foundation")]
13075 impl ::std::fmt::Debug for CRYPT_ATTRIBUTE_TYPE_VALUE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13076     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13077         fmt.debug_struct("CRYPT_ATTRIBUTE_TYPE_VALUE").field("pszObjId", &self.pszObjId).field("Value", &self.Value).finish()
13078     }
13079 }
13080 #[cfg(feature = "Win32_Foundation")]
13081 impl ::std::cmp::PartialEq for CRYPT_ATTRIBUTE_TYPE_VALUE {
eq(&self, other: &Self) -> bool13082     fn eq(&self, other: &Self) -> bool {
13083         self.pszObjId == other.pszObjId && self.Value == other.Value
13084     }
13085 }
13086 #[cfg(feature = "Win32_Foundation")]
13087 impl ::std::cmp::Eq for CRYPT_ATTRIBUTE_TYPE_VALUE {}
13088 #[cfg(feature = "Win32_Foundation")]
13089 unsafe impl ::windows::runtime::Abi for CRYPT_ATTRIBUTE_TYPE_VALUE {
13090     type Abi = Self;
13091     type DefaultType = Self;
13092 }
13093 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13094 #[repr(C)]
13095 pub struct CRYPT_BIT_BLOB {
13096     pub cbData: u32,
13097     pub pbData: *mut u8,
13098     pub cUnusedBits: u32,
13099 }
13100 impl CRYPT_BIT_BLOB {}
13101 impl ::std::default::Default for CRYPT_BIT_BLOB {
default() -> Self13102     fn default() -> Self {
13103         unsafe { ::std::mem::zeroed() }
13104     }
13105 }
13106 impl ::std::fmt::Debug for CRYPT_BIT_BLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13107     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13108         fmt.debug_struct("CRYPT_BIT_BLOB").field("cbData", &self.cbData).field("pbData", &self.pbData).field("cUnusedBits", &self.cUnusedBits).finish()
13109     }
13110 }
13111 impl ::std::cmp::PartialEq for CRYPT_BIT_BLOB {
eq(&self, other: &Self) -> bool13112     fn eq(&self, other: &Self) -> bool {
13113         self.cbData == other.cbData && self.pbData == other.pbData && self.cUnusedBits == other.cUnusedBits
13114     }
13115 }
13116 impl ::std::cmp::Eq for CRYPT_BIT_BLOB {}
13117 unsafe impl ::windows::runtime::Abi for CRYPT_BIT_BLOB {
13118     type Abi = Self;
13119     type DefaultType = Self;
13120 }
13121 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13122 #[repr(C)]
13123 pub struct CRYPT_BLOB_ARRAY {
13124     pub cBlob: u32,
13125     pub rgBlob: *mut CRYPTOAPI_BLOB,
13126 }
13127 impl CRYPT_BLOB_ARRAY {}
13128 impl ::std::default::Default for CRYPT_BLOB_ARRAY {
default() -> Self13129     fn default() -> Self {
13130         unsafe { ::std::mem::zeroed() }
13131     }
13132 }
13133 impl ::std::fmt::Debug for CRYPT_BLOB_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13134     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13135         fmt.debug_struct("CRYPT_BLOB_ARRAY").field("cBlob", &self.cBlob).field("rgBlob", &self.rgBlob).finish()
13136     }
13137 }
13138 impl ::std::cmp::PartialEq for CRYPT_BLOB_ARRAY {
eq(&self, other: &Self) -> bool13139     fn eq(&self, other: &Self) -> bool {
13140         self.cBlob == other.cBlob && self.rgBlob == other.rgBlob
13141     }
13142 }
13143 impl ::std::cmp::Eq for CRYPT_BLOB_ARRAY {}
13144 unsafe impl ::windows::runtime::Abi for CRYPT_BLOB_ARRAY {
13145     type Abi = Self;
13146     type DefaultType = Self;
13147 }
13148 pub const CRYPT_CACHE_ONLY_RETRIEVAL: u32 = 2u32;
13149 pub const CRYPT_CHECK_FRESHNESS_TIME_VALIDITY: u32 = 1024u32;
13150 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13151 #[repr(C)]
13152 #[cfg(feature = "Win32_Foundation")]
13153 pub struct CRYPT_CONTENT_INFO {
13154     pub pszObjId: super::super::Foundation::PSTR,
13155     pub Content: CRYPTOAPI_BLOB,
13156 }
13157 #[cfg(feature = "Win32_Foundation")]
13158 impl CRYPT_CONTENT_INFO {}
13159 #[cfg(feature = "Win32_Foundation")]
13160 impl ::std::default::Default for CRYPT_CONTENT_INFO {
default() -> Self13161     fn default() -> Self {
13162         unsafe { ::std::mem::zeroed() }
13163     }
13164 }
13165 #[cfg(feature = "Win32_Foundation")]
13166 impl ::std::fmt::Debug for CRYPT_CONTENT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13167     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13168         fmt.debug_struct("CRYPT_CONTENT_INFO").field("pszObjId", &self.pszObjId).field("Content", &self.Content).finish()
13169     }
13170 }
13171 #[cfg(feature = "Win32_Foundation")]
13172 impl ::std::cmp::PartialEq for CRYPT_CONTENT_INFO {
eq(&self, other: &Self) -> bool13173     fn eq(&self, other: &Self) -> bool {
13174         self.pszObjId == other.pszObjId && self.Content == other.Content
13175     }
13176 }
13177 #[cfg(feature = "Win32_Foundation")]
13178 impl ::std::cmp::Eq for CRYPT_CONTENT_INFO {}
13179 #[cfg(feature = "Win32_Foundation")]
13180 unsafe impl ::windows::runtime::Abi for CRYPT_CONTENT_INFO {
13181     type Abi = Self;
13182     type DefaultType = Self;
13183 }
13184 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13185 #[repr(C)]
13186 #[cfg(feature = "Win32_Foundation")]
13187 pub struct CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY {
13188     pub pszObjId: super::super::Foundation::PSTR,
13189     pub cValue: u32,
13190     pub rgValue: *mut CRYPTOAPI_BLOB,
13191 }
13192 #[cfg(feature = "Win32_Foundation")]
13193 impl CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY {}
13194 #[cfg(feature = "Win32_Foundation")]
13195 impl ::std::default::Default for CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY {
default() -> Self13196     fn default() -> Self {
13197         unsafe { ::std::mem::zeroed() }
13198     }
13199 }
13200 #[cfg(feature = "Win32_Foundation")]
13201 impl ::std::fmt::Debug for CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13202     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13203         fmt.debug_struct("CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY").field("pszObjId", &self.pszObjId).field("cValue", &self.cValue).field("rgValue", &self.rgValue).finish()
13204     }
13205 }
13206 #[cfg(feature = "Win32_Foundation")]
13207 impl ::std::cmp::PartialEq for CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY {
eq(&self, other: &Self) -> bool13208     fn eq(&self, other: &Self) -> bool {
13209         self.pszObjId == other.pszObjId && self.cValue == other.cValue && self.rgValue == other.rgValue
13210     }
13211 }
13212 #[cfg(feature = "Win32_Foundation")]
13213 impl ::std::cmp::Eq for CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY {}
13214 #[cfg(feature = "Win32_Foundation")]
13215 unsafe impl ::windows::runtime::Abi for CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY {
13216     type Abi = Self;
13217     type DefaultType = Self;
13218 }
13219 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13220 #[repr(C)]
13221 #[cfg(feature = "Win32_Foundation")]
13222 pub struct CRYPT_CONTEXTS {
13223     pub cContexts: u32,
13224     pub rgpszContexts: *mut super::super::Foundation::PWSTR,
13225 }
13226 #[cfg(feature = "Win32_Foundation")]
13227 impl CRYPT_CONTEXTS {}
13228 #[cfg(feature = "Win32_Foundation")]
13229 impl ::std::default::Default for CRYPT_CONTEXTS {
default() -> Self13230     fn default() -> Self {
13231         unsafe { ::std::mem::zeroed() }
13232     }
13233 }
13234 #[cfg(feature = "Win32_Foundation")]
13235 impl ::std::fmt::Debug for CRYPT_CONTEXTS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13236     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13237         fmt.debug_struct("CRYPT_CONTEXTS").field("cContexts", &self.cContexts).field("rgpszContexts", &self.rgpszContexts).finish()
13238     }
13239 }
13240 #[cfg(feature = "Win32_Foundation")]
13241 impl ::std::cmp::PartialEq for CRYPT_CONTEXTS {
eq(&self, other: &Self) -> bool13242     fn eq(&self, other: &Self) -> bool {
13243         self.cContexts == other.cContexts && self.rgpszContexts == other.rgpszContexts
13244     }
13245 }
13246 #[cfg(feature = "Win32_Foundation")]
13247 impl ::std::cmp::Eq for CRYPT_CONTEXTS {}
13248 #[cfg(feature = "Win32_Foundation")]
13249 unsafe impl ::windows::runtime::Abi for CRYPT_CONTEXTS {
13250     type Abi = Self;
13251     type DefaultType = Self;
13252 }
13253 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13254 #[repr(C)]
13255 pub struct CRYPT_CONTEXT_CONFIG {
13256     pub dwFlags: CRYPT_CONTEXT_CONFIG_FLAGS,
13257     pub dwReserved: u32,
13258 }
13259 impl CRYPT_CONTEXT_CONFIG {}
13260 impl ::std::default::Default for CRYPT_CONTEXT_CONFIG {
default() -> Self13261     fn default() -> Self {
13262         unsafe { ::std::mem::zeroed() }
13263     }
13264 }
13265 impl ::std::fmt::Debug for CRYPT_CONTEXT_CONFIG {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13266     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13267         fmt.debug_struct("CRYPT_CONTEXT_CONFIG").field("dwFlags", &self.dwFlags).field("dwReserved", &self.dwReserved).finish()
13268     }
13269 }
13270 impl ::std::cmp::PartialEq for CRYPT_CONTEXT_CONFIG {
eq(&self, other: &Self) -> bool13271     fn eq(&self, other: &Self) -> bool {
13272         self.dwFlags == other.dwFlags && self.dwReserved == other.dwReserved
13273     }
13274 }
13275 impl ::std::cmp::Eq for CRYPT_CONTEXT_CONFIG {}
13276 unsafe impl ::windows::runtime::Abi for CRYPT_CONTEXT_CONFIG {
13277     type Abi = Self;
13278     type DefaultType = Self;
13279 }
13280 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
13281 #[repr(transparent)]
13282 pub struct CRYPT_CONTEXT_CONFIG_FLAGS(pub u32);
13283 pub const CRYPT_EXCLUSIVE: CRYPT_CONTEXT_CONFIG_FLAGS = CRYPT_CONTEXT_CONFIG_FLAGS(1u32);
13284 pub const CRYPT_OVERRIDE: CRYPT_CONTEXT_CONFIG_FLAGS = CRYPT_CONTEXT_CONFIG_FLAGS(65536u32);
13285 impl ::std::convert::From<u32> for CRYPT_CONTEXT_CONFIG_FLAGS {
from(value: u32) -> Self13286     fn from(value: u32) -> Self {
13287         Self(value)
13288     }
13289 }
13290 unsafe impl ::windows::runtime::Abi for CRYPT_CONTEXT_CONFIG_FLAGS {
13291     type Abi = Self;
13292     type DefaultType = Self;
13293 }
13294 impl ::std::ops::BitOr for CRYPT_CONTEXT_CONFIG_FLAGS {
13295     type Output = Self;
bitor(self, rhs: Self) -> Self13296     fn bitor(self, rhs: Self) -> Self {
13297         Self(self.0 | rhs.0)
13298     }
13299 }
13300 impl ::std::ops::BitAnd for CRYPT_CONTEXT_CONFIG_FLAGS {
13301     type Output = Self;
bitand(self, rhs: Self) -> Self13302     fn bitand(self, rhs: Self) -> Self {
13303         Self(self.0 & rhs.0)
13304     }
13305 }
13306 impl ::std::ops::BitOrAssign for CRYPT_CONTEXT_CONFIG_FLAGS {
bitor_assign(&mut self, rhs: Self)13307     fn bitor_assign(&mut self, rhs: Self) {
13308         self.0.bitor_assign(rhs.0)
13309     }
13310 }
13311 impl ::std::ops::BitAndAssign for CRYPT_CONTEXT_CONFIG_FLAGS {
bitand_assign(&mut self, rhs: Self)13312     fn bitand_assign(&mut self, rhs: Self) {
13313         self.0.bitand_assign(rhs.0)
13314     }
13315 }
13316 impl ::std::ops::Not for CRYPT_CONTEXT_CONFIG_FLAGS {
13317     type Output = Self;
not(self) -> Self13318     fn not(self) -> Self {
13319         Self(self.0.not())
13320     }
13321 }
13322 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13323 #[repr(C)]
13324 #[cfg(feature = "Win32_Foundation")]
13325 pub struct CRYPT_CONTEXT_FUNCTIONS {
13326     pub cFunctions: u32,
13327     pub rgpszFunctions: *mut super::super::Foundation::PWSTR,
13328 }
13329 #[cfg(feature = "Win32_Foundation")]
13330 impl CRYPT_CONTEXT_FUNCTIONS {}
13331 #[cfg(feature = "Win32_Foundation")]
13332 impl ::std::default::Default for CRYPT_CONTEXT_FUNCTIONS {
default() -> Self13333     fn default() -> Self {
13334         unsafe { ::std::mem::zeroed() }
13335     }
13336 }
13337 #[cfg(feature = "Win32_Foundation")]
13338 impl ::std::fmt::Debug for CRYPT_CONTEXT_FUNCTIONS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13339     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13340         fmt.debug_struct("CRYPT_CONTEXT_FUNCTIONS").field("cFunctions", &self.cFunctions).field("rgpszFunctions", &self.rgpszFunctions).finish()
13341     }
13342 }
13343 #[cfg(feature = "Win32_Foundation")]
13344 impl ::std::cmp::PartialEq for CRYPT_CONTEXT_FUNCTIONS {
eq(&self, other: &Self) -> bool13345     fn eq(&self, other: &Self) -> bool {
13346         self.cFunctions == other.cFunctions && self.rgpszFunctions == other.rgpszFunctions
13347     }
13348 }
13349 #[cfg(feature = "Win32_Foundation")]
13350 impl ::std::cmp::Eq for CRYPT_CONTEXT_FUNCTIONS {}
13351 #[cfg(feature = "Win32_Foundation")]
13352 unsafe impl ::windows::runtime::Abi for CRYPT_CONTEXT_FUNCTIONS {
13353     type Abi = Self;
13354     type DefaultType = Self;
13355 }
13356 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13357 #[repr(C)]
13358 pub struct CRYPT_CONTEXT_FUNCTION_CONFIG {
13359     pub dwFlags: u32,
13360     pub dwReserved: u32,
13361 }
13362 impl CRYPT_CONTEXT_FUNCTION_CONFIG {}
13363 impl ::std::default::Default for CRYPT_CONTEXT_FUNCTION_CONFIG {
default() -> Self13364     fn default() -> Self {
13365         unsafe { ::std::mem::zeroed() }
13366     }
13367 }
13368 impl ::std::fmt::Debug for CRYPT_CONTEXT_FUNCTION_CONFIG {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13369     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13370         fmt.debug_struct("CRYPT_CONTEXT_FUNCTION_CONFIG").field("dwFlags", &self.dwFlags).field("dwReserved", &self.dwReserved).finish()
13371     }
13372 }
13373 impl ::std::cmp::PartialEq for CRYPT_CONTEXT_FUNCTION_CONFIG {
eq(&self, other: &Self) -> bool13374     fn eq(&self, other: &Self) -> bool {
13375         self.dwFlags == other.dwFlags && self.dwReserved == other.dwReserved
13376     }
13377 }
13378 impl ::std::cmp::Eq for CRYPT_CONTEXT_FUNCTION_CONFIG {}
13379 unsafe impl ::windows::runtime::Abi for CRYPT_CONTEXT_FUNCTION_CONFIG {
13380     type Abi = Self;
13381     type DefaultType = Self;
13382 }
13383 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13384 #[repr(C)]
13385 #[cfg(feature = "Win32_Foundation")]
13386 pub struct CRYPT_CONTEXT_FUNCTION_PROVIDERS {
13387     pub cProviders: u32,
13388     pub rgpszProviders: *mut super::super::Foundation::PWSTR,
13389 }
13390 #[cfg(feature = "Win32_Foundation")]
13391 impl CRYPT_CONTEXT_FUNCTION_PROVIDERS {}
13392 #[cfg(feature = "Win32_Foundation")]
13393 impl ::std::default::Default for CRYPT_CONTEXT_FUNCTION_PROVIDERS {
default() -> Self13394     fn default() -> Self {
13395         unsafe { ::std::mem::zeroed() }
13396     }
13397 }
13398 #[cfg(feature = "Win32_Foundation")]
13399 impl ::std::fmt::Debug for CRYPT_CONTEXT_FUNCTION_PROVIDERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13400     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13401         fmt.debug_struct("CRYPT_CONTEXT_FUNCTION_PROVIDERS").field("cProviders", &self.cProviders).field("rgpszProviders", &self.rgpszProviders).finish()
13402     }
13403 }
13404 #[cfg(feature = "Win32_Foundation")]
13405 impl ::std::cmp::PartialEq for CRYPT_CONTEXT_FUNCTION_PROVIDERS {
eq(&self, other: &Self) -> bool13406     fn eq(&self, other: &Self) -> bool {
13407         self.cProviders == other.cProviders && self.rgpszProviders == other.rgpszProviders
13408     }
13409 }
13410 #[cfg(feature = "Win32_Foundation")]
13411 impl ::std::cmp::Eq for CRYPT_CONTEXT_FUNCTION_PROVIDERS {}
13412 #[cfg(feature = "Win32_Foundation")]
13413 unsafe impl ::windows::runtime::Abi for CRYPT_CONTEXT_FUNCTION_PROVIDERS {
13414     type Abi = Self;
13415     type DefaultType = Self;
13416 }
13417 pub const CRYPT_CREATE_NEW_FLUSH_ENTRY: u32 = 268435456u32;
13418 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13419 #[repr(C)]
13420 #[cfg(feature = "Win32_Foundation")]
13421 pub struct CRYPT_CREDENTIALS {
13422     pub cbSize: u32,
13423     pub pszCredentialsOid: super::super::Foundation::PSTR,
13424     pub pvCredentials: *mut ::std::ffi::c_void,
13425 }
13426 #[cfg(feature = "Win32_Foundation")]
13427 impl CRYPT_CREDENTIALS {}
13428 #[cfg(feature = "Win32_Foundation")]
13429 impl ::std::default::Default for CRYPT_CREDENTIALS {
default() -> Self13430     fn default() -> Self {
13431         unsafe { ::std::mem::zeroed() }
13432     }
13433 }
13434 #[cfg(feature = "Win32_Foundation")]
13435 impl ::std::fmt::Debug for CRYPT_CREDENTIALS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13436     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13437         fmt.debug_struct("CRYPT_CREDENTIALS").field("cbSize", &self.cbSize).field("pszCredentialsOid", &self.pszCredentialsOid).field("pvCredentials", &self.pvCredentials).finish()
13438     }
13439 }
13440 #[cfg(feature = "Win32_Foundation")]
13441 impl ::std::cmp::PartialEq for CRYPT_CREDENTIALS {
eq(&self, other: &Self) -> bool13442     fn eq(&self, other: &Self) -> bool {
13443         self.cbSize == other.cbSize && self.pszCredentialsOid == other.pszCredentialsOid && self.pvCredentials == other.pvCredentials
13444     }
13445 }
13446 #[cfg(feature = "Win32_Foundation")]
13447 impl ::std::cmp::Eq for CRYPT_CREDENTIALS {}
13448 #[cfg(feature = "Win32_Foundation")]
13449 unsafe impl ::windows::runtime::Abi for CRYPT_CREDENTIALS {
13450     type Abi = Self;
13451     type DefaultType = Self;
13452 }
13453 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13454 #[repr(C)]
13455 #[cfg(feature = "Win32_Foundation")]
13456 pub struct CRYPT_CSP_PROVIDER {
13457     pub dwKeySpec: u32,
13458     pub pwszProviderName: super::super::Foundation::PWSTR,
13459     pub Signature: CRYPT_BIT_BLOB,
13460 }
13461 #[cfg(feature = "Win32_Foundation")]
13462 impl CRYPT_CSP_PROVIDER {}
13463 #[cfg(feature = "Win32_Foundation")]
13464 impl ::std::default::Default for CRYPT_CSP_PROVIDER {
default() -> Self13465     fn default() -> Self {
13466         unsafe { ::std::mem::zeroed() }
13467     }
13468 }
13469 #[cfg(feature = "Win32_Foundation")]
13470 impl ::std::fmt::Debug for CRYPT_CSP_PROVIDER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13471     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13472         fmt.debug_struct("CRYPT_CSP_PROVIDER").field("dwKeySpec", &self.dwKeySpec).field("pwszProviderName", &self.pwszProviderName).field("Signature", &self.Signature).finish()
13473     }
13474 }
13475 #[cfg(feature = "Win32_Foundation")]
13476 impl ::std::cmp::PartialEq for CRYPT_CSP_PROVIDER {
eq(&self, other: &Self) -> bool13477     fn eq(&self, other: &Self) -> bool {
13478         self.dwKeySpec == other.dwKeySpec && self.pwszProviderName == other.pwszProviderName && self.Signature == other.Signature
13479     }
13480 }
13481 #[cfg(feature = "Win32_Foundation")]
13482 impl ::std::cmp::Eq for CRYPT_CSP_PROVIDER {}
13483 #[cfg(feature = "Win32_Foundation")]
13484 unsafe impl ::windows::runtime::Abi for CRYPT_CSP_PROVIDER {
13485     type Abi = Self;
13486     type DefaultType = Self;
13487 }
13488 pub const CRYPT_DECODE_ALLOC_FLAG: u32 = 32768u32;
13489 pub const CRYPT_DECODE_ENABLE_PUNYCODE_FLAG: u32 = 33554432u32;
13490 pub const CRYPT_DECODE_ENABLE_UTF8PERCENT_FLAG: u32 = 67108864u32;
13491 pub const CRYPT_DECODE_NOCOPY_FLAG: u32 = 1u32;
13492 pub const CRYPT_DECODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG: u32 = 8u32;
13493 #[derive(:: std :: clone :: Clone)]
13494 #[repr(C)]
13495 pub struct CRYPT_DECODE_PARA {
13496     pub cbSize: u32,
13497     pub pfnAlloc: ::std::option::Option<PFN_CRYPT_ALLOC>,
13498     pub pfnFree: ::std::option::Option<PFN_CRYPT_FREE>,
13499 }
13500 impl CRYPT_DECODE_PARA {}
13501 impl ::std::default::Default for CRYPT_DECODE_PARA {
default() -> Self13502     fn default() -> Self {
13503         unsafe { ::std::mem::zeroed() }
13504     }
13505 }
13506 impl ::std::fmt::Debug for CRYPT_DECODE_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13507     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13508         fmt.debug_struct("CRYPT_DECODE_PARA").field("cbSize", &self.cbSize).finish()
13509     }
13510 }
13511 impl ::std::cmp::PartialEq for CRYPT_DECODE_PARA {
eq(&self, other: &Self) -> bool13512     fn eq(&self, other: &Self) -> bool {
13513         self.cbSize == other.cbSize && self.pfnAlloc.map(|f| f as usize) == other.pfnAlloc.map(|f| f as usize) && self.pfnFree.map(|f| f as usize) == other.pfnFree.map(|f| f as usize)
13514     }
13515 }
13516 impl ::std::cmp::Eq for CRYPT_DECODE_PARA {}
13517 unsafe impl ::windows::runtime::Abi for CRYPT_DECODE_PARA {
13518     type Abi = ::std::mem::ManuallyDrop<Self>;
13519     type DefaultType = Self;
13520 }
13521 pub const CRYPT_DECODE_SHARE_OID_STRING_FLAG: u32 = 4u32;
13522 pub const CRYPT_DECODE_TO_BE_SIGNED_FLAG: u32 = 2u32;
13523 pub const CRYPT_DECRYPT: u32 = 2u32;
13524 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13525 #[repr(C)]
13526 pub struct CRYPT_DECRYPT_MESSAGE_PARA {
13527     pub cbSize: u32,
13528     pub dwMsgAndCertEncodingType: u32,
13529     pub cCertStore: u32,
13530     pub rghCertStore: *mut *mut ::std::ffi::c_void,
13531 }
13532 impl CRYPT_DECRYPT_MESSAGE_PARA {}
13533 impl ::std::default::Default for CRYPT_DECRYPT_MESSAGE_PARA {
default() -> Self13534     fn default() -> Self {
13535         unsafe { ::std::mem::zeroed() }
13536     }
13537 }
13538 impl ::std::fmt::Debug for CRYPT_DECRYPT_MESSAGE_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13539     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13540         fmt.debug_struct("CRYPT_DECRYPT_MESSAGE_PARA").field("cbSize", &self.cbSize).field("dwMsgAndCertEncodingType", &self.dwMsgAndCertEncodingType).field("cCertStore", &self.cCertStore).field("rghCertStore", &self.rghCertStore).finish()
13541     }
13542 }
13543 impl ::std::cmp::PartialEq for CRYPT_DECRYPT_MESSAGE_PARA {
eq(&self, other: &Self) -> bool13544     fn eq(&self, other: &Self) -> bool {
13545         self.cbSize == other.cbSize && self.dwMsgAndCertEncodingType == other.dwMsgAndCertEncodingType && self.cCertStore == other.cCertStore && self.rghCertStore == other.rghCertStore
13546     }
13547 }
13548 impl ::std::cmp::Eq for CRYPT_DECRYPT_MESSAGE_PARA {}
13549 unsafe impl ::windows::runtime::Abi for CRYPT_DECRYPT_MESSAGE_PARA {
13550     type Abi = Self;
13551     type DefaultType = Self;
13552 }
13553 pub const CRYPT_DECRYPT_RSA_NO_PADDING_CHECK: u32 = 32u32;
13554 pub const CRYPT_DEFAULT_CONTAINER_OPTIONAL: u32 = 128u32;
13555 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
13556 #[repr(transparent)]
13557 pub struct CRYPT_DEFAULT_CONTEXT_FLAGS(pub u32);
13558 pub const CRYPT_DEFAULT_CONTEXT_AUTO_RELEASE_FLAG: CRYPT_DEFAULT_CONTEXT_FLAGS = CRYPT_DEFAULT_CONTEXT_FLAGS(1u32);
13559 pub const CRYPT_DEFAULT_CONTEXT_PROCESS_FLAG: CRYPT_DEFAULT_CONTEXT_FLAGS = CRYPT_DEFAULT_CONTEXT_FLAGS(2u32);
13560 impl ::std::convert::From<u32> for CRYPT_DEFAULT_CONTEXT_FLAGS {
from(value: u32) -> Self13561     fn from(value: u32) -> Self {
13562         Self(value)
13563     }
13564 }
13565 unsafe impl ::windows::runtime::Abi for CRYPT_DEFAULT_CONTEXT_FLAGS {
13566     type Abi = Self;
13567     type DefaultType = Self;
13568 }
13569 impl ::std::ops::BitOr for CRYPT_DEFAULT_CONTEXT_FLAGS {
13570     type Output = Self;
bitor(self, rhs: Self) -> Self13571     fn bitor(self, rhs: Self) -> Self {
13572         Self(self.0 | rhs.0)
13573     }
13574 }
13575 impl ::std::ops::BitAnd for CRYPT_DEFAULT_CONTEXT_FLAGS {
13576     type Output = Self;
bitand(self, rhs: Self) -> Self13577     fn bitand(self, rhs: Self) -> Self {
13578         Self(self.0 & rhs.0)
13579     }
13580 }
13581 impl ::std::ops::BitOrAssign for CRYPT_DEFAULT_CONTEXT_FLAGS {
bitor_assign(&mut self, rhs: Self)13582     fn bitor_assign(&mut self, rhs: Self) {
13583         self.0.bitor_assign(rhs.0)
13584     }
13585 }
13586 impl ::std::ops::BitAndAssign for CRYPT_DEFAULT_CONTEXT_FLAGS {
bitand_assign(&mut self, rhs: Self)13587     fn bitand_assign(&mut self, rhs: Self) {
13588         self.0.bitand_assign(rhs.0)
13589     }
13590 }
13591 impl ::std::ops::Not for CRYPT_DEFAULT_CONTEXT_FLAGS {
13592     type Output = Self;
not(self) -> Self13593     fn not(self) -> Self {
13594         Self(self.0.not())
13595     }
13596 }
13597 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13598 #[repr(C)]
13599 #[cfg(feature = "Win32_Foundation")]
13600 pub struct CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA {
13601     pub cOID: u32,
13602     pub rgpszOID: *mut super::super::Foundation::PSTR,
13603 }
13604 #[cfg(feature = "Win32_Foundation")]
13605 impl CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA {}
13606 #[cfg(feature = "Win32_Foundation")]
13607 impl ::std::default::Default for CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA {
default() -> Self13608     fn default() -> Self {
13609         unsafe { ::std::mem::zeroed() }
13610     }
13611 }
13612 #[cfg(feature = "Win32_Foundation")]
13613 impl ::std::fmt::Debug for CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13614     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13615         fmt.debug_struct("CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA").field("cOID", &self.cOID).field("rgpszOID", &self.rgpszOID).finish()
13616     }
13617 }
13618 #[cfg(feature = "Win32_Foundation")]
13619 impl ::std::cmp::PartialEq for CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA {
eq(&self, other: &Self) -> bool13620     fn eq(&self, other: &Self) -> bool {
13621         self.cOID == other.cOID && self.rgpszOID == other.rgpszOID
13622     }
13623 }
13624 #[cfg(feature = "Win32_Foundation")]
13625 impl ::std::cmp::Eq for CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA {}
13626 #[cfg(feature = "Win32_Foundation")]
13627 unsafe impl ::windows::runtime::Abi for CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA {
13628     type Abi = Self;
13629     type DefaultType = Self;
13630 }
13631 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
13632 #[repr(transparent)]
13633 pub struct CRYPT_DEFAULT_CONTEXT_TYPE(pub u32);
13634 pub const CRYPT_DEFAULT_CONTEXT_CERT_SIGN_OID: CRYPT_DEFAULT_CONTEXT_TYPE = CRYPT_DEFAULT_CONTEXT_TYPE(1u32);
13635 pub const CRYPT_DEFAULT_CONTEXT_MULTI_CERT_SIGN_OID: CRYPT_DEFAULT_CONTEXT_TYPE = CRYPT_DEFAULT_CONTEXT_TYPE(2u32);
13636 impl ::std::convert::From<u32> for CRYPT_DEFAULT_CONTEXT_TYPE {
from(value: u32) -> Self13637     fn from(value: u32) -> Self {
13638         Self(value)
13639     }
13640 }
13641 unsafe impl ::windows::runtime::Abi for CRYPT_DEFAULT_CONTEXT_TYPE {
13642     type Abi = Self;
13643     type DefaultType = Self;
13644 }
13645 impl ::std::ops::BitOr for CRYPT_DEFAULT_CONTEXT_TYPE {
13646     type Output = Self;
bitor(self, rhs: Self) -> Self13647     fn bitor(self, rhs: Self) -> Self {
13648         Self(self.0 | rhs.0)
13649     }
13650 }
13651 impl ::std::ops::BitAnd for CRYPT_DEFAULT_CONTEXT_TYPE {
13652     type Output = Self;
bitand(self, rhs: Self) -> Self13653     fn bitand(self, rhs: Self) -> Self {
13654         Self(self.0 & rhs.0)
13655     }
13656 }
13657 impl ::std::ops::BitOrAssign for CRYPT_DEFAULT_CONTEXT_TYPE {
bitor_assign(&mut self, rhs: Self)13658     fn bitor_assign(&mut self, rhs: Self) {
13659         self.0.bitor_assign(rhs.0)
13660     }
13661 }
13662 impl ::std::ops::BitAndAssign for CRYPT_DEFAULT_CONTEXT_TYPE {
bitand_assign(&mut self, rhs: Self)13663     fn bitand_assign(&mut self, rhs: Self) {
13664         self.0.bitand_assign(rhs.0)
13665     }
13666 }
13667 impl ::std::ops::Not for CRYPT_DEFAULT_CONTEXT_TYPE {
13668     type Output = Self;
not(self) -> Self13669     fn not(self) -> Self {
13670         Self(self.0.not())
13671     }
13672 }
13673 pub const CRYPT_DELETEKEYSET: u32 = 16u32;
13674 pub const CRYPT_DELETE_DEFAULT: u32 = 4u32;
13675 pub const CRYPT_DELETE_KEYSET: u32 = 16u32;
13676 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13677 #[repr(C)]
13678 pub struct CRYPT_DES_KEY_STATE {
13679     pub Key: [u8; 8],
13680     pub IV: [u8; 8],
13681     pub Feedback: [u8; 8],
13682 }
13683 impl CRYPT_DES_KEY_STATE {}
13684 impl ::std::default::Default for CRYPT_DES_KEY_STATE {
default() -> Self13685     fn default() -> Self {
13686         unsafe { ::std::mem::zeroed() }
13687     }
13688 }
13689 impl ::std::fmt::Debug for CRYPT_DES_KEY_STATE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13690     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13691         fmt.debug_struct("CRYPT_DES_KEY_STATE").field("Key", &self.Key).field("IV", &self.IV).field("Feedback", &self.Feedback).finish()
13692     }
13693 }
13694 impl ::std::cmp::PartialEq for CRYPT_DES_KEY_STATE {
eq(&self, other: &Self) -> bool13695     fn eq(&self, other: &Self) -> bool {
13696         self.Key == other.Key && self.IV == other.IV && self.Feedback == other.Feedback
13697     }
13698 }
13699 impl ::std::cmp::Eq for CRYPT_DES_KEY_STATE {}
13700 unsafe impl ::windows::runtime::Abi for CRYPT_DES_KEY_STATE {
13701     type Abi = Self;
13702     type DefaultType = Self;
13703 }
13704 pub const CRYPT_DONT_CACHE_RESULT: u32 = 8u32;
13705 pub const CRYPT_DONT_CHECK_TIME_VALIDITY: u32 = 512u32;
13706 pub const CRYPT_DONT_VERIFY_SIGNATURE: u32 = 256u32;
13707 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13708 #[repr(C)]
13709 #[cfg(feature = "Win32_Foundation")]
13710 pub struct CRYPT_ECC_CMS_SHARED_INFO {
13711     pub Algorithm: CRYPT_ALGORITHM_IDENTIFIER,
13712     pub EntityUInfo: CRYPTOAPI_BLOB,
13713     pub rgbSuppPubInfo: [u8; 4],
13714 }
13715 #[cfg(feature = "Win32_Foundation")]
13716 impl CRYPT_ECC_CMS_SHARED_INFO {}
13717 #[cfg(feature = "Win32_Foundation")]
13718 impl ::std::default::Default for CRYPT_ECC_CMS_SHARED_INFO {
default() -> Self13719     fn default() -> Self {
13720         unsafe { ::std::mem::zeroed() }
13721     }
13722 }
13723 #[cfg(feature = "Win32_Foundation")]
13724 impl ::std::fmt::Debug for CRYPT_ECC_CMS_SHARED_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13725     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13726         fmt.debug_struct("CRYPT_ECC_CMS_SHARED_INFO").field("Algorithm", &self.Algorithm).field("EntityUInfo", &self.EntityUInfo).field("rgbSuppPubInfo", &self.rgbSuppPubInfo).finish()
13727     }
13728 }
13729 #[cfg(feature = "Win32_Foundation")]
13730 impl ::std::cmp::PartialEq for CRYPT_ECC_CMS_SHARED_INFO {
eq(&self, other: &Self) -> bool13731     fn eq(&self, other: &Self) -> bool {
13732         self.Algorithm == other.Algorithm && self.EntityUInfo == other.EntityUInfo && self.rgbSuppPubInfo == other.rgbSuppPubInfo
13733     }
13734 }
13735 #[cfg(feature = "Win32_Foundation")]
13736 impl ::std::cmp::Eq for CRYPT_ECC_CMS_SHARED_INFO {}
13737 #[cfg(feature = "Win32_Foundation")]
13738 unsafe impl ::windows::runtime::Abi for CRYPT_ECC_CMS_SHARED_INFO {
13739     type Abi = Self;
13740     type DefaultType = Self;
13741 }
13742 pub const CRYPT_ECC_CMS_SHARED_INFO_SUPPPUBINFO_BYTE_LENGTH: u32 = 4u32;
13743 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13744 #[repr(C)]
13745 #[cfg(feature = "Win32_Foundation")]
13746 pub struct CRYPT_ECC_PRIVATE_KEY_INFO {
13747     pub dwVersion: u32,
13748     pub PrivateKey: CRYPTOAPI_BLOB,
13749     pub szCurveOid: super::super::Foundation::PSTR,
13750     pub PublicKey: CRYPT_BIT_BLOB,
13751 }
13752 #[cfg(feature = "Win32_Foundation")]
13753 impl CRYPT_ECC_PRIVATE_KEY_INFO {}
13754 #[cfg(feature = "Win32_Foundation")]
13755 impl ::std::default::Default for CRYPT_ECC_PRIVATE_KEY_INFO {
default() -> Self13756     fn default() -> Self {
13757         unsafe { ::std::mem::zeroed() }
13758     }
13759 }
13760 #[cfg(feature = "Win32_Foundation")]
13761 impl ::std::fmt::Debug for CRYPT_ECC_PRIVATE_KEY_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13762     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13763         fmt.debug_struct("CRYPT_ECC_PRIVATE_KEY_INFO").field("dwVersion", &self.dwVersion).field("PrivateKey", &self.PrivateKey).field("szCurveOid", &self.szCurveOid).field("PublicKey", &self.PublicKey).finish()
13764     }
13765 }
13766 #[cfg(feature = "Win32_Foundation")]
13767 impl ::std::cmp::PartialEq for CRYPT_ECC_PRIVATE_KEY_INFO {
eq(&self, other: &Self) -> bool13768     fn eq(&self, other: &Self) -> bool {
13769         self.dwVersion == other.dwVersion && self.PrivateKey == other.PrivateKey && self.szCurveOid == other.szCurveOid && self.PublicKey == other.PublicKey
13770     }
13771 }
13772 #[cfg(feature = "Win32_Foundation")]
13773 impl ::std::cmp::Eq for CRYPT_ECC_PRIVATE_KEY_INFO {}
13774 #[cfg(feature = "Win32_Foundation")]
13775 unsafe impl ::windows::runtime::Abi for CRYPT_ECC_PRIVATE_KEY_INFO {
13776     type Abi = Self;
13777     type DefaultType = Self;
13778 }
13779 pub const CRYPT_ECC_PRIVATE_KEY_INFO_v1: u32 = 1u32;
13780 pub const CRYPT_ENABLE_FILE_RETRIEVAL: u32 = 134217728u32;
13781 pub const CRYPT_ENABLE_SSL_REVOCATION_RETRIEVAL: u32 = 8388608u32;
13782 pub const CRYPT_ENCODE_DECODE_NONE: u32 = 0u32;
13783 pub const CRYPT_ENCODE_ENABLE_UTF8PERCENT_FLAG: u32 = 262144u32;
13784 pub const CRYPT_ENCODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG: u32 = 8u32;
13785 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
13786 #[repr(transparent)]
13787 pub struct CRYPT_ENCODE_OBJECT_FLAGS(pub u32);
13788 pub const CRYPT_ENCODE_ALLOC_FLAG: CRYPT_ENCODE_OBJECT_FLAGS = CRYPT_ENCODE_OBJECT_FLAGS(32768u32);
13789 pub const CRYPT_ENCODE_ENABLE_PUNYCODE_FLAG: CRYPT_ENCODE_OBJECT_FLAGS = CRYPT_ENCODE_OBJECT_FLAGS(131072u32);
13790 pub const CRYPT_UNICODE_NAME_ENCODE_DISABLE_CHECK_TYPE_FLAG: CRYPT_ENCODE_OBJECT_FLAGS = CRYPT_ENCODE_OBJECT_FLAGS(1073741824u32);
13791 pub const CRYPT_UNICODE_NAME_ENCODE_ENABLE_T61_UNICODE_FLAG: CRYPT_ENCODE_OBJECT_FLAGS = CRYPT_ENCODE_OBJECT_FLAGS(2147483648u32);
13792 pub const CRYPT_UNICODE_NAME_ENCODE_ENABLE_UTF8_UNICODE_FLAG: CRYPT_ENCODE_OBJECT_FLAGS = CRYPT_ENCODE_OBJECT_FLAGS(536870912u32);
13793 impl ::std::convert::From<u32> for CRYPT_ENCODE_OBJECT_FLAGS {
from(value: u32) -> Self13794     fn from(value: u32) -> Self {
13795         Self(value)
13796     }
13797 }
13798 unsafe impl ::windows::runtime::Abi for CRYPT_ENCODE_OBJECT_FLAGS {
13799     type Abi = Self;
13800     type DefaultType = Self;
13801 }
13802 impl ::std::ops::BitOr for CRYPT_ENCODE_OBJECT_FLAGS {
13803     type Output = Self;
bitor(self, rhs: Self) -> Self13804     fn bitor(self, rhs: Self) -> Self {
13805         Self(self.0 | rhs.0)
13806     }
13807 }
13808 impl ::std::ops::BitAnd for CRYPT_ENCODE_OBJECT_FLAGS {
13809     type Output = Self;
bitand(self, rhs: Self) -> Self13810     fn bitand(self, rhs: Self) -> Self {
13811         Self(self.0 & rhs.0)
13812     }
13813 }
13814 impl ::std::ops::BitOrAssign for CRYPT_ENCODE_OBJECT_FLAGS {
bitor_assign(&mut self, rhs: Self)13815     fn bitor_assign(&mut self, rhs: Self) {
13816         self.0.bitor_assign(rhs.0)
13817     }
13818 }
13819 impl ::std::ops::BitAndAssign for CRYPT_ENCODE_OBJECT_FLAGS {
bitand_assign(&mut self, rhs: Self)13820     fn bitand_assign(&mut self, rhs: Self) {
13821         self.0.bitand_assign(rhs.0)
13822     }
13823 }
13824 impl ::std::ops::Not for CRYPT_ENCODE_OBJECT_FLAGS {
13825     type Output = Self;
not(self) -> Self13826     fn not(self) -> Self {
13827         Self(self.0.not())
13828     }
13829 }
13830 #[derive(:: std :: clone :: Clone)]
13831 #[repr(C)]
13832 pub struct CRYPT_ENCODE_PARA {
13833     pub cbSize: u32,
13834     pub pfnAlloc: ::std::option::Option<PFN_CRYPT_ALLOC>,
13835     pub pfnFree: ::std::option::Option<PFN_CRYPT_FREE>,
13836 }
13837 impl CRYPT_ENCODE_PARA {}
13838 impl ::std::default::Default for CRYPT_ENCODE_PARA {
default() -> Self13839     fn default() -> Self {
13840         unsafe { ::std::mem::zeroed() }
13841     }
13842 }
13843 impl ::std::fmt::Debug for CRYPT_ENCODE_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13844     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13845         fmt.debug_struct("CRYPT_ENCODE_PARA").field("cbSize", &self.cbSize).finish()
13846     }
13847 }
13848 impl ::std::cmp::PartialEq for CRYPT_ENCODE_PARA {
eq(&self, other: &Self) -> bool13849     fn eq(&self, other: &Self) -> bool {
13850         self.cbSize == other.cbSize && self.pfnAlloc.map(|f| f as usize) == other.pfnAlloc.map(|f| f as usize) && self.pfnFree.map(|f| f as usize) == other.pfnFree.map(|f| f as usize)
13851     }
13852 }
13853 impl ::std::cmp::Eq for CRYPT_ENCODE_PARA {}
13854 unsafe impl ::windows::runtime::Abi for CRYPT_ENCODE_PARA {
13855     type Abi = ::std::mem::ManuallyDrop<Self>;
13856     type DefaultType = Self;
13857 }
13858 pub const CRYPT_ENCRYPT: u32 = 1u32;
13859 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13860 #[repr(C)]
13861 #[cfg(feature = "Win32_Foundation")]
13862 pub struct CRYPT_ENCRYPTED_PRIVATE_KEY_INFO {
13863     pub EncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
13864     pub EncryptedPrivateKey: CRYPTOAPI_BLOB,
13865 }
13866 #[cfg(feature = "Win32_Foundation")]
13867 impl CRYPT_ENCRYPTED_PRIVATE_KEY_INFO {}
13868 #[cfg(feature = "Win32_Foundation")]
13869 impl ::std::default::Default for CRYPT_ENCRYPTED_PRIVATE_KEY_INFO {
default() -> Self13870     fn default() -> Self {
13871         unsafe { ::std::mem::zeroed() }
13872     }
13873 }
13874 #[cfg(feature = "Win32_Foundation")]
13875 impl ::std::fmt::Debug for CRYPT_ENCRYPTED_PRIVATE_KEY_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13876     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13877         fmt.debug_struct("CRYPT_ENCRYPTED_PRIVATE_KEY_INFO").field("EncryptionAlgorithm", &self.EncryptionAlgorithm).field("EncryptedPrivateKey", &self.EncryptedPrivateKey).finish()
13878     }
13879 }
13880 #[cfg(feature = "Win32_Foundation")]
13881 impl ::std::cmp::PartialEq for CRYPT_ENCRYPTED_PRIVATE_KEY_INFO {
eq(&self, other: &Self) -> bool13882     fn eq(&self, other: &Self) -> bool {
13883         self.EncryptionAlgorithm == other.EncryptionAlgorithm && self.EncryptedPrivateKey == other.EncryptedPrivateKey
13884     }
13885 }
13886 #[cfg(feature = "Win32_Foundation")]
13887 impl ::std::cmp::Eq for CRYPT_ENCRYPTED_PRIVATE_KEY_INFO {}
13888 #[cfg(feature = "Win32_Foundation")]
13889 unsafe impl ::windows::runtime::Abi for CRYPT_ENCRYPTED_PRIVATE_KEY_INFO {
13890     type Abi = Self;
13891     type DefaultType = Self;
13892 }
13893 pub const CRYPT_ENCRYPT_ALG_OID_GROUP_ID: u32 = 2u32;
13894 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13895 #[repr(C)]
13896 #[cfg(feature = "Win32_Foundation")]
13897 pub struct CRYPT_ENCRYPT_MESSAGE_PARA {
13898     pub cbSize: u32,
13899     pub dwMsgEncodingType: u32,
13900     pub hCryptProv: usize,
13901     pub ContentEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
13902     pub pvEncryptionAuxInfo: *mut ::std::ffi::c_void,
13903     pub dwFlags: u32,
13904     pub dwInnerContentType: u32,
13905 }
13906 #[cfg(feature = "Win32_Foundation")]
13907 impl CRYPT_ENCRYPT_MESSAGE_PARA {}
13908 #[cfg(feature = "Win32_Foundation")]
13909 impl ::std::default::Default for CRYPT_ENCRYPT_MESSAGE_PARA {
default() -> Self13910     fn default() -> Self {
13911         unsafe { ::std::mem::zeroed() }
13912     }
13913 }
13914 #[cfg(feature = "Win32_Foundation")]
13915 impl ::std::fmt::Debug for CRYPT_ENCRYPT_MESSAGE_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13916     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13917         fmt.debug_struct("CRYPT_ENCRYPT_MESSAGE_PARA")
13918             .field("cbSize", &self.cbSize)
13919             .field("dwMsgEncodingType", &self.dwMsgEncodingType)
13920             .field("hCryptProv", &self.hCryptProv)
13921             .field("ContentEncryptionAlgorithm", &self.ContentEncryptionAlgorithm)
13922             .field("pvEncryptionAuxInfo", &self.pvEncryptionAuxInfo)
13923             .field("dwFlags", &self.dwFlags)
13924             .field("dwInnerContentType", &self.dwInnerContentType)
13925             .finish()
13926     }
13927 }
13928 #[cfg(feature = "Win32_Foundation")]
13929 impl ::std::cmp::PartialEq for CRYPT_ENCRYPT_MESSAGE_PARA {
eq(&self, other: &Self) -> bool13930     fn eq(&self, other: &Self) -> bool {
13931         self.cbSize == other.cbSize && self.dwMsgEncodingType == other.dwMsgEncodingType && self.hCryptProv == other.hCryptProv && self.ContentEncryptionAlgorithm == other.ContentEncryptionAlgorithm && self.pvEncryptionAuxInfo == other.pvEncryptionAuxInfo && self.dwFlags == other.dwFlags && self.dwInnerContentType == other.dwInnerContentType
13932     }
13933 }
13934 #[cfg(feature = "Win32_Foundation")]
13935 impl ::std::cmp::Eq for CRYPT_ENCRYPT_MESSAGE_PARA {}
13936 #[cfg(feature = "Win32_Foundation")]
13937 unsafe impl ::windows::runtime::Abi for CRYPT_ENCRYPT_MESSAGE_PARA {
13938     type Abi = Self;
13939     type DefaultType = Self;
13940 }
13941 pub const CRYPT_ENHKEY_USAGE_OID_GROUP_ID: u32 = 7u32;
13942 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13943 #[repr(C)]
13944 #[cfg(feature = "Win32_Foundation")]
13945 pub struct CRYPT_ENROLLMENT_NAME_VALUE_PAIR {
13946     pub pwszName: super::super::Foundation::PWSTR,
13947     pub pwszValue: super::super::Foundation::PWSTR,
13948 }
13949 #[cfg(feature = "Win32_Foundation")]
13950 impl CRYPT_ENROLLMENT_NAME_VALUE_PAIR {}
13951 #[cfg(feature = "Win32_Foundation")]
13952 impl ::std::default::Default for CRYPT_ENROLLMENT_NAME_VALUE_PAIR {
default() -> Self13953     fn default() -> Self {
13954         unsafe { ::std::mem::zeroed() }
13955     }
13956 }
13957 #[cfg(feature = "Win32_Foundation")]
13958 impl ::std::fmt::Debug for CRYPT_ENROLLMENT_NAME_VALUE_PAIR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13959     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13960         fmt.debug_struct("CRYPT_ENROLLMENT_NAME_VALUE_PAIR").field("pwszName", &self.pwszName).field("pwszValue", &self.pwszValue).finish()
13961     }
13962 }
13963 #[cfg(feature = "Win32_Foundation")]
13964 impl ::std::cmp::PartialEq for CRYPT_ENROLLMENT_NAME_VALUE_PAIR {
eq(&self, other: &Self) -> bool13965     fn eq(&self, other: &Self) -> bool {
13966         self.pwszName == other.pwszName && self.pwszValue == other.pwszValue
13967     }
13968 }
13969 #[cfg(feature = "Win32_Foundation")]
13970 impl ::std::cmp::Eq for CRYPT_ENROLLMENT_NAME_VALUE_PAIR {}
13971 #[cfg(feature = "Win32_Foundation")]
13972 unsafe impl ::windows::runtime::Abi for CRYPT_ENROLLMENT_NAME_VALUE_PAIR {
13973     type Abi = Self;
13974     type DefaultType = Self;
13975 }
13976 pub const CRYPT_EXPORT: u32 = 4u32;
13977 pub const CRYPT_EXPORT_KEY: u32 = 64u32;
13978 pub const CRYPT_EXT_OR_ATTR_OID_GROUP_ID: u32 = 6u32;
13979 pub const CRYPT_FAILED: u32 = 0u32;
13980 pub const CRYPT_FASTSGC: u32 = 2u32;
13981 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
13982 #[repr(transparent)]
13983 pub struct CRYPT_FIND_FLAGS(pub u32);
13984 pub const CRYPT_FIND_USER_KEYSET_FLAG: CRYPT_FIND_FLAGS = CRYPT_FIND_FLAGS(1u32);
13985 pub const CRYPT_FIND_MACHINE_KEYSET_FLAG: CRYPT_FIND_FLAGS = CRYPT_FIND_FLAGS(2u32);
13986 pub const CRYPT_FIND_SILENT_KEYSET_FLAG: CRYPT_FIND_FLAGS = CRYPT_FIND_FLAGS(64u32);
13987 impl ::std::convert::From<u32> for CRYPT_FIND_FLAGS {
from(value: u32) -> Self13988     fn from(value: u32) -> Self {
13989         Self(value)
13990     }
13991 }
13992 unsafe impl ::windows::runtime::Abi for CRYPT_FIND_FLAGS {
13993     type Abi = Self;
13994     type DefaultType = Self;
13995 }
13996 impl ::std::ops::BitOr for CRYPT_FIND_FLAGS {
13997     type Output = Self;
bitor(self, rhs: Self) -> Self13998     fn bitor(self, rhs: Self) -> Self {
13999         Self(self.0 | rhs.0)
14000     }
14001 }
14002 impl ::std::ops::BitAnd for CRYPT_FIND_FLAGS {
14003     type Output = Self;
bitand(self, rhs: Self) -> Self14004     fn bitand(self, rhs: Self) -> Self {
14005         Self(self.0 & rhs.0)
14006     }
14007 }
14008 impl ::std::ops::BitOrAssign for CRYPT_FIND_FLAGS {
bitor_assign(&mut self, rhs: Self)14009     fn bitor_assign(&mut self, rhs: Self) {
14010         self.0.bitor_assign(rhs.0)
14011     }
14012 }
14013 impl ::std::ops::BitAndAssign for CRYPT_FIND_FLAGS {
bitand_assign(&mut self, rhs: Self)14014     fn bitand_assign(&mut self, rhs: Self) {
14015         self.0.bitand_assign(rhs.0)
14016     }
14017 }
14018 impl ::std::ops::Not for CRYPT_FIND_FLAGS {
14019     type Output = Self;
not(self) -> Self14020     fn not(self) -> Self {
14021         Self(self.0.not())
14022     }
14023 }
14024 pub const CRYPT_FIRST: u32 = 1u32;
14025 pub const CRYPT_FIRST_ALG_OID_GROUP_ID: u32 = 1u32;
14026 pub const CRYPT_FLAG_IPSEC: u32 = 16u32;
14027 pub const CRYPT_FLAG_PCT1: u32 = 1u32;
14028 pub const CRYPT_FLAG_SIGNING: u32 = 32u32;
14029 pub const CRYPT_FLAG_SSL2: u32 = 2u32;
14030 pub const CRYPT_FLAG_SSL3: u32 = 4u32;
14031 pub const CRYPT_FLAG_TLS1: u32 = 8u32;
14032 pub const CRYPT_FORMAT_COMMA: u32 = 4096u32;
14033 pub const CRYPT_FORMAT_CRLF: u32 = 512u32;
14034 pub const CRYPT_FORMAT_OID: u32 = 4u32;
14035 pub const CRYPT_FORMAT_RDN_CRLF: u32 = 512u32;
14036 pub const CRYPT_FORMAT_RDN_REVERSE: u32 = 2048u32;
14037 pub const CRYPT_FORMAT_RDN_SEMICOLON: u32 = 256u32;
14038 pub const CRYPT_FORMAT_RDN_UNQUOTE: u32 = 1024u32;
14039 pub const CRYPT_FORMAT_SEMICOLON: u32 = 256u32;
14040 pub const CRYPT_FORMAT_SIMPLE: u32 = 1u32;
14041 pub const CRYPT_FORMAT_STR_MULTI_LINE: u32 = 1u32;
14042 pub const CRYPT_FORMAT_STR_NO_HEX: u32 = 16u32;
14043 pub const CRYPT_FORMAT_X509: u32 = 2u32;
14044 pub const CRYPT_GET_INSTALLED_OID_FUNC_FLAG: u32 = 1u32;
14045 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14046 #[repr(C)]
14047 #[cfg(feature = "Win32_Foundation")]
14048 pub struct CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO {
14049     pub cbSize: u32,
14050     pub iDeltaCrlIndicator: i32,
14051     pub pftCacheResync: *mut super::super::Foundation::FILETIME,
14052     pub pLastSyncTime: *mut super::super::Foundation::FILETIME,
14053     pub pMaxAgeTime: *mut super::super::Foundation::FILETIME,
14054     pub pChainPara: *mut CERT_REVOCATION_CHAIN_PARA,
14055     pub pDeltaCrlIndicator: *mut CRYPTOAPI_BLOB,
14056 }
14057 #[cfg(feature = "Win32_Foundation")]
14058 impl CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO {}
14059 #[cfg(feature = "Win32_Foundation")]
14060 impl ::std::default::Default for CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO {
default() -> Self14061     fn default() -> Self {
14062         unsafe { ::std::mem::zeroed() }
14063     }
14064 }
14065 #[cfg(feature = "Win32_Foundation")]
14066 impl ::std::fmt::Debug for CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result14067     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14068         fmt.debug_struct("CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO")
14069             .field("cbSize", &self.cbSize)
14070             .field("iDeltaCrlIndicator", &self.iDeltaCrlIndicator)
14071             .field("pftCacheResync", &self.pftCacheResync)
14072             .field("pLastSyncTime", &self.pLastSyncTime)
14073             .field("pMaxAgeTime", &self.pMaxAgeTime)
14074             .field("pChainPara", &self.pChainPara)
14075             .field("pDeltaCrlIndicator", &self.pDeltaCrlIndicator)
14076             .finish()
14077     }
14078 }
14079 #[cfg(feature = "Win32_Foundation")]
14080 impl ::std::cmp::PartialEq for CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO {
eq(&self, other: &Self) -> bool14081     fn eq(&self, other: &Self) -> bool {
14082         self.cbSize == other.cbSize && self.iDeltaCrlIndicator == other.iDeltaCrlIndicator && self.pftCacheResync == other.pftCacheResync && self.pLastSyncTime == other.pLastSyncTime && self.pMaxAgeTime == other.pMaxAgeTime && self.pChainPara == other.pChainPara && self.pDeltaCrlIndicator == other.pDeltaCrlIndicator
14083     }
14084 }
14085 #[cfg(feature = "Win32_Foundation")]
14086 impl ::std::cmp::Eq for CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO {}
14087 #[cfg(feature = "Win32_Foundation")]
14088 unsafe impl ::windows::runtime::Abi for CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO {
14089     type Abi = Self;
14090     type DefaultType = Self;
14091 }
14092 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
14093 #[repr(transparent)]
14094 pub struct CRYPT_GET_URL_FLAGS(pub u32);
14095 pub const CRYPT_GET_URL_FROM_PROPERTY: CRYPT_GET_URL_FLAGS = CRYPT_GET_URL_FLAGS(1u32);
14096 pub const CRYPT_GET_URL_FROM_EXTENSION: CRYPT_GET_URL_FLAGS = CRYPT_GET_URL_FLAGS(2u32);
14097 pub const CRYPT_GET_URL_FROM_UNAUTH_ATTRIBUTE: CRYPT_GET_URL_FLAGS = CRYPT_GET_URL_FLAGS(4u32);
14098 pub const CRYPT_GET_URL_FROM_AUTH_ATTRIBUTE: CRYPT_GET_URL_FLAGS = CRYPT_GET_URL_FLAGS(8u32);
14099 impl ::std::convert::From<u32> for CRYPT_GET_URL_FLAGS {
from(value: u32) -> Self14100     fn from(value: u32) -> Self {
14101         Self(value)
14102     }
14103 }
14104 unsafe impl ::windows::runtime::Abi for CRYPT_GET_URL_FLAGS {
14105     type Abi = Self;
14106     type DefaultType = Self;
14107 }
14108 impl ::std::ops::BitOr for CRYPT_GET_URL_FLAGS {
14109     type Output = Self;
bitor(self, rhs: Self) -> Self14110     fn bitor(self, rhs: Self) -> Self {
14111         Self(self.0 | rhs.0)
14112     }
14113 }
14114 impl ::std::ops::BitAnd for CRYPT_GET_URL_FLAGS {
14115     type Output = Self;
bitand(self, rhs: Self) -> Self14116     fn bitand(self, rhs: Self) -> Self {
14117         Self(self.0 & rhs.0)
14118     }
14119 }
14120 impl ::std::ops::BitOrAssign for CRYPT_GET_URL_FLAGS {
bitor_assign(&mut self, rhs: Self)14121     fn bitor_assign(&mut self, rhs: Self) {
14122         self.0.bitor_assign(rhs.0)
14123     }
14124 }
14125 impl ::std::ops::BitAndAssign for CRYPT_GET_URL_FLAGS {
bitand_assign(&mut self, rhs: Self)14126     fn bitand_assign(&mut self, rhs: Self) {
14127         self.0.bitand_assign(rhs.0)
14128     }
14129 }
14130 impl ::std::ops::Not for CRYPT_GET_URL_FLAGS {
14131     type Output = Self;
not(self) -> Self14132     fn not(self) -> Self {
14133         Self(self.0.not())
14134     }
14135 }
14136 pub const CRYPT_HASH_ALG_OID_GROUP_ID: u32 = 1u32;
14137 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14138 #[repr(C)]
14139 #[cfg(feature = "Win32_Foundation")]
14140 pub struct CRYPT_HASH_INFO {
14141     pub HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
14142     pub Hash: CRYPTOAPI_BLOB,
14143 }
14144 #[cfg(feature = "Win32_Foundation")]
14145 impl CRYPT_HASH_INFO {}
14146 #[cfg(feature = "Win32_Foundation")]
14147 impl ::std::default::Default for CRYPT_HASH_INFO {
default() -> Self14148     fn default() -> Self {
14149         unsafe { ::std::mem::zeroed() }
14150     }
14151 }
14152 #[cfg(feature = "Win32_Foundation")]
14153 impl ::std::fmt::Debug for CRYPT_HASH_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result14154     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14155         fmt.debug_struct("CRYPT_HASH_INFO").field("HashAlgorithm", &self.HashAlgorithm).field("Hash", &self.Hash).finish()
14156     }
14157 }
14158 #[cfg(feature = "Win32_Foundation")]
14159 impl ::std::cmp::PartialEq for CRYPT_HASH_INFO {
eq(&self, other: &Self) -> bool14160     fn eq(&self, other: &Self) -> bool {
14161         self.HashAlgorithm == other.HashAlgorithm && self.Hash == other.Hash
14162     }
14163 }
14164 #[cfg(feature = "Win32_Foundation")]
14165 impl ::std::cmp::Eq for CRYPT_HASH_INFO {}
14166 #[cfg(feature = "Win32_Foundation")]
14167 unsafe impl ::windows::runtime::Abi for CRYPT_HASH_INFO {
14168     type Abi = Self;
14169     type DefaultType = Self;
14170 }
14171 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14172 #[repr(C)]
14173 #[cfg(feature = "Win32_Foundation")]
14174 pub struct CRYPT_HASH_MESSAGE_PARA {
14175     pub cbSize: u32,
14176     pub dwMsgEncodingType: u32,
14177     pub hCryptProv: usize,
14178     pub HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
14179     pub pvHashAuxInfo: *mut ::std::ffi::c_void,
14180 }
14181 #[cfg(feature = "Win32_Foundation")]
14182 impl CRYPT_HASH_MESSAGE_PARA {}
14183 #[cfg(feature = "Win32_Foundation")]
14184 impl ::std::default::Default for CRYPT_HASH_MESSAGE_PARA {
default() -> Self14185     fn default() -> Self {
14186         unsafe { ::std::mem::zeroed() }
14187     }
14188 }
14189 #[cfg(feature = "Win32_Foundation")]
14190 impl ::std::fmt::Debug for CRYPT_HASH_MESSAGE_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result14191     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14192         fmt.debug_struct("CRYPT_HASH_MESSAGE_PARA").field("cbSize", &self.cbSize).field("dwMsgEncodingType", &self.dwMsgEncodingType).field("hCryptProv", &self.hCryptProv).field("HashAlgorithm", &self.HashAlgorithm).field("pvHashAuxInfo", &self.pvHashAuxInfo).finish()
14193     }
14194 }
14195 #[cfg(feature = "Win32_Foundation")]
14196 impl ::std::cmp::PartialEq for CRYPT_HASH_MESSAGE_PARA {
eq(&self, other: &Self) -> bool14197     fn eq(&self, other: &Self) -> bool {
14198         self.cbSize == other.cbSize && self.dwMsgEncodingType == other.dwMsgEncodingType && self.hCryptProv == other.hCryptProv && self.HashAlgorithm == other.HashAlgorithm && self.pvHashAuxInfo == other.pvHashAuxInfo
14199     }
14200 }
14201 #[cfg(feature = "Win32_Foundation")]
14202 impl ::std::cmp::Eq for CRYPT_HASH_MESSAGE_PARA {}
14203 #[cfg(feature = "Win32_Foundation")]
14204 unsafe impl ::windows::runtime::Abi for CRYPT_HASH_MESSAGE_PARA {
14205     type Abi = Self;
14206     type DefaultType = Self;
14207 }
14208 pub const CRYPT_HTTP_POST_RETRIEVAL: u32 = 1048576u32;
14209 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14210 #[repr(C)]
14211 #[cfg(feature = "Win32_Foundation")]
14212 pub struct CRYPT_IMAGE_REF {
14213     pub pszImage: super::super::Foundation::PWSTR,
14214     pub dwFlags: CRYPT_IMAGE_REF_FLAGS,
14215 }
14216 #[cfg(feature = "Win32_Foundation")]
14217 impl CRYPT_IMAGE_REF {}
14218 #[cfg(feature = "Win32_Foundation")]
14219 impl ::std::default::Default for CRYPT_IMAGE_REF {
default() -> Self14220     fn default() -> Self {
14221         unsafe { ::std::mem::zeroed() }
14222     }
14223 }
14224 #[cfg(feature = "Win32_Foundation")]
14225 impl ::std::fmt::Debug for CRYPT_IMAGE_REF {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result14226     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14227         fmt.debug_struct("CRYPT_IMAGE_REF").field("pszImage", &self.pszImage).field("dwFlags", &self.dwFlags).finish()
14228     }
14229 }
14230 #[cfg(feature = "Win32_Foundation")]
14231 impl ::std::cmp::PartialEq for CRYPT_IMAGE_REF {
eq(&self, other: &Self) -> bool14232     fn eq(&self, other: &Self) -> bool {
14233         self.pszImage == other.pszImage && self.dwFlags == other.dwFlags
14234     }
14235 }
14236 #[cfg(feature = "Win32_Foundation")]
14237 impl ::std::cmp::Eq for CRYPT_IMAGE_REF {}
14238 #[cfg(feature = "Win32_Foundation")]
14239 unsafe impl ::windows::runtime::Abi for CRYPT_IMAGE_REF {
14240     type Abi = Self;
14241     type DefaultType = Self;
14242 }
14243 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
14244 #[repr(transparent)]
14245 pub struct CRYPT_IMAGE_REF_FLAGS(pub u32);
14246 pub const CRYPT_MIN_DEPENDENCIES: CRYPT_IMAGE_REF_FLAGS = CRYPT_IMAGE_REF_FLAGS(1u32);
14247 pub const CRYPT_PROCESS_ISOLATE: CRYPT_IMAGE_REF_FLAGS = CRYPT_IMAGE_REF_FLAGS(65536u32);
14248 impl ::std::convert::From<u32> for CRYPT_IMAGE_REF_FLAGS {
from(value: u32) -> Self14249     fn from(value: u32) -> Self {
14250         Self(value)
14251     }
14252 }
14253 unsafe impl ::windows::runtime::Abi for CRYPT_IMAGE_REF_FLAGS {
14254     type Abi = Self;
14255     type DefaultType = Self;
14256 }
14257 impl ::std::ops::BitOr for CRYPT_IMAGE_REF_FLAGS {
14258     type Output = Self;
bitor(self, rhs: Self) -> Self14259     fn bitor(self, rhs: Self) -> Self {
14260         Self(self.0 | rhs.0)
14261     }
14262 }
14263 impl ::std::ops::BitAnd for CRYPT_IMAGE_REF_FLAGS {
14264     type Output = Self;
bitand(self, rhs: Self) -> Self14265     fn bitand(self, rhs: Self) -> Self {
14266         Self(self.0 & rhs.0)
14267     }
14268 }
14269 impl ::std::ops::BitOrAssign for CRYPT_IMAGE_REF_FLAGS {
bitor_assign(&mut self, rhs: Self)14270     fn bitor_assign(&mut self, rhs: Self) {
14271         self.0.bitor_assign(rhs.0)
14272     }
14273 }
14274 impl ::std::ops::BitAndAssign for CRYPT_IMAGE_REF_FLAGS {
bitand_assign(&mut self, rhs: Self)14275     fn bitand_assign(&mut self, rhs: Self) {
14276         self.0.bitand_assign(rhs.0)
14277     }
14278 }
14279 impl ::std::ops::Not for CRYPT_IMAGE_REF_FLAGS {
14280     type Output = Self;
not(self) -> Self14281     fn not(self) -> Self {
14282         Self(self.0.not())
14283     }
14284 }
14285 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14286 #[repr(C)]
14287 #[cfg(feature = "Win32_Foundation")]
14288 pub struct CRYPT_IMAGE_REG {
14289     pub pszImage: super::super::Foundation::PWSTR,
14290     pub cInterfaces: u32,
14291     pub rgpInterfaces: *mut *mut CRYPT_INTERFACE_REG,
14292 }
14293 #[cfg(feature = "Win32_Foundation")]
14294 impl CRYPT_IMAGE_REG {}
14295 #[cfg(feature = "Win32_Foundation")]
14296 impl ::std::default::Default for CRYPT_IMAGE_REG {
default() -> Self14297     fn default() -> Self {
14298         unsafe { ::std::mem::zeroed() }
14299     }
14300 }
14301 #[cfg(feature = "Win32_Foundation")]
14302 impl ::std::fmt::Debug for CRYPT_IMAGE_REG {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result14303     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14304         fmt.debug_struct("CRYPT_IMAGE_REG").field("pszImage", &self.pszImage).field("cInterfaces", &self.cInterfaces).field("rgpInterfaces", &self.rgpInterfaces).finish()
14305     }
14306 }
14307 #[cfg(feature = "Win32_Foundation")]
14308 impl ::std::cmp::PartialEq for CRYPT_IMAGE_REG {
eq(&self, other: &Self) -> bool14309     fn eq(&self, other: &Self) -> bool {
14310         self.pszImage == other.pszImage && self.cInterfaces == other.cInterfaces && self.rgpInterfaces == other.rgpInterfaces
14311     }
14312 }
14313 #[cfg(feature = "Win32_Foundation")]
14314 impl ::std::cmp::Eq for CRYPT_IMAGE_REG {}
14315 #[cfg(feature = "Win32_Foundation")]
14316 unsafe impl ::windows::runtime::Abi for CRYPT_IMAGE_REG {
14317     type Abi = Self;
14318     type DefaultType = Self;
14319 }
14320 pub const CRYPT_IMPL_HARDWARE: u32 = 1u32;
14321 pub const CRYPT_IMPL_MIXED: u32 = 3u32;
14322 pub const CRYPT_IMPL_REMOVABLE: u32 = 8u32;
14323 pub const CRYPT_IMPL_SOFTWARE: u32 = 2u32;
14324 pub const CRYPT_IMPL_UNKNOWN: u32 = 4u32;
14325 pub const CRYPT_IMPORT_KEY: u32 = 128u32;
14326 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
14327 #[repr(transparent)]
14328 pub struct CRYPT_IMPORT_PUBLIC_KEY_FLAGS(pub u32);
14329 pub const CRYPT_OID_INFO_PUBKEY_SIGN_KEY_FLAG: CRYPT_IMPORT_PUBLIC_KEY_FLAGS = CRYPT_IMPORT_PUBLIC_KEY_FLAGS(2147483648u32);
14330 pub const CRYPT_OID_INFO_PUBKEY_ENCRYPT_KEY_FLAG: CRYPT_IMPORT_PUBLIC_KEY_FLAGS = CRYPT_IMPORT_PUBLIC_KEY_FLAGS(1073741824u32);
14331 impl ::std::convert::From<u32> for CRYPT_IMPORT_PUBLIC_KEY_FLAGS {
from(value: u32) -> Self14332     fn from(value: u32) -> Self {
14333         Self(value)
14334     }
14335 }
14336 unsafe impl ::windows::runtime::Abi for CRYPT_IMPORT_PUBLIC_KEY_FLAGS {
14337     type Abi = Self;
14338     type DefaultType = Self;
14339 }
14340 impl ::std::ops::BitOr for CRYPT_IMPORT_PUBLIC_KEY_FLAGS {
14341     type Output = Self;
bitor(self, rhs: Self) -> Self14342     fn bitor(self, rhs: Self) -> Self {
14343         Self(self.0 | rhs.0)
14344     }
14345 }
14346 impl ::std::ops::BitAnd for CRYPT_IMPORT_PUBLIC_KEY_FLAGS {
14347     type Output = Self;
bitand(self, rhs: Self) -> Self14348     fn bitand(self, rhs: Self) -> Self {
14349         Self(self.0 & rhs.0)
14350     }
14351 }
14352 impl ::std::ops::BitOrAssign for CRYPT_IMPORT_PUBLIC_KEY_FLAGS {
bitor_assign(&mut self, rhs: Self)14353     fn bitor_assign(&mut self, rhs: Self) {
14354         self.0.bitor_assign(rhs.0)
14355     }
14356 }
14357 impl ::std::ops::BitAndAssign for CRYPT_IMPORT_PUBLIC_KEY_FLAGS {
bitand_assign(&mut self, rhs: Self)14358     fn bitand_assign(&mut self, rhs: Self) {
14359         self.0.bitand_assign(rhs.0)
14360     }
14361 }
14362 impl ::std::ops::Not for CRYPT_IMPORT_PUBLIC_KEY_FLAGS {
14363     type Output = Self;
not(self) -> Self14364     fn not(self) -> Self {
14365         Self(self.0.not())
14366     }
14367 }
14368 pub const CRYPT_INSTALL_OID_FUNC_BEFORE_FLAG: u32 = 1u32;
14369 pub const CRYPT_INSTALL_OID_INFO_BEFORE_FLAG: u32 = 1u32;
14370 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14371 #[repr(C)]
14372 #[cfg(feature = "Win32_Foundation")]
14373 pub struct CRYPT_INTERFACE_REG {
14374     pub dwInterface: BCRYPT_INTERFACE,
14375     pub dwFlags: BCRYPT_TABLE,
14376     pub cFunctions: u32,
14377     pub rgpszFunctions: *mut super::super::Foundation::PWSTR,
14378 }
14379 #[cfg(feature = "Win32_Foundation")]
14380 impl CRYPT_INTERFACE_REG {}
14381 #[cfg(feature = "Win32_Foundation")]
14382 impl ::std::default::Default for CRYPT_INTERFACE_REG {
default() -> Self14383     fn default() -> Self {
14384         unsafe { ::std::mem::zeroed() }
14385     }
14386 }
14387 #[cfg(feature = "Win32_Foundation")]
14388 impl ::std::fmt::Debug for CRYPT_INTERFACE_REG {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result14389     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14390         fmt.debug_struct("CRYPT_INTERFACE_REG").field("dwInterface", &self.dwInterface).field("dwFlags", &self.dwFlags).field("cFunctions", &self.cFunctions).field("rgpszFunctions", &self.rgpszFunctions).finish()
14391     }
14392 }
14393 #[cfg(feature = "Win32_Foundation")]
14394 impl ::std::cmp::PartialEq for CRYPT_INTERFACE_REG {
eq(&self, other: &Self) -> bool14395     fn eq(&self, other: &Self) -> bool {
14396         self.dwInterface == other.dwInterface && self.dwFlags == other.dwFlags && self.cFunctions == other.cFunctions && self.rgpszFunctions == other.rgpszFunctions
14397     }
14398 }
14399 #[cfg(feature = "Win32_Foundation")]
14400 impl ::std::cmp::Eq for CRYPT_INTERFACE_REG {}
14401 #[cfg(feature = "Win32_Foundation")]
14402 unsafe impl ::windows::runtime::Abi for CRYPT_INTERFACE_REG {
14403     type Abi = Self;
14404     type DefaultType = Self;
14405 }
14406 pub const CRYPT_KDF_OID_GROUP_ID: u32 = 10u32;
14407 pub const CRYPT_KEEP_TIME_VALID: u32 = 128u32;
14408 pub const CRYPT_KEYID_ALLOC_FLAG: u32 = 32768u32;
14409 pub const CRYPT_KEYID_DELETE_FLAG: u32 = 16u32;
14410 pub const CRYPT_KEYID_MACHINE_FLAG: u32 = 32u32;
14411 pub const CRYPT_KEYID_SET_NEW_FLAG: u32 = 8192u32;
14412 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
14413 #[repr(transparent)]
14414 pub struct CRYPT_KEY_FLAGS(pub u32);
14415 pub const CRYPT_EXPORTABLE: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(1u32);
14416 pub const CRYPT_USER_PROTECTED: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(2u32);
14417 pub const CRYPT_ARCHIVABLE: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(16384u32);
14418 pub const CRYPT_CREATE_IV: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(512u32);
14419 pub const CRYPT_CREATE_SALT: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(4u32);
14420 pub const CRYPT_DATA_KEY: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(2048u32);
14421 pub const CRYPT_FORCE_KEY_PROTECTION_HIGH: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(32768u32);
14422 pub const CRYPT_KEK: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(1024u32);
14423 pub const CRYPT_INITIATOR: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(64u32);
14424 pub const CRYPT_NO_SALT: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(16u32);
14425 pub const CRYPT_ONLINE: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(128u32);
14426 pub const CRYPT_PREGEN: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(64u32);
14427 pub const CRYPT_RECIPIENT: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(16u32);
14428 pub const CRYPT_SF: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(256u32);
14429 pub const CRYPT_SGCKEY: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(8192u32);
14430 pub const CRYPT_VOLATILE: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(4096u32);
14431 pub const CRYPT_MACHINE_KEYSET: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(32u32);
14432 pub const CRYPT_USER_KEYSET: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(4096u32);
14433 pub const PKCS12_PREFER_CNG_KSP: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(256u32);
14434 pub const PKCS12_ALWAYS_CNG_KSP: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(512u32);
14435 pub const PKCS12_ALLOW_OVERWRITE_KEY: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(16384u32);
14436 pub const PKCS12_NO_PERSIST_KEY: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(32768u32);
14437 pub const PKCS12_INCLUDE_EXTENDED_PROPERTIES: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(16u32);
14438 pub const CRYPT_OAEP: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(64u32);
14439 pub const CRYPT_BLOB_VER3: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(128u32);
14440 pub const CRYPT_DESTROYKEY: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(4u32);
14441 pub const CRYPT_SSL2_FALLBACK: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(2u32);
14442 pub const CRYPT_Y_ONLY: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(1u32);
14443 pub const CRYPT_IPSEC_HMAC_KEY: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(256u32);
14444 pub const CERT_SET_KEY_PROV_HANDLE_PROP_ID: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(1u32);
14445 pub const CERT_SET_KEY_CONTEXT_PROP_ID: CRYPT_KEY_FLAGS = CRYPT_KEY_FLAGS(1u32);
14446 impl ::std::convert::From<u32> for CRYPT_KEY_FLAGS {
from(value: u32) -> Self14447     fn from(value: u32) -> Self {
14448         Self(value)
14449     }
14450 }
14451 unsafe impl ::windows::runtime::Abi for CRYPT_KEY_FLAGS {
14452     type Abi = Self;
14453     type DefaultType = Self;
14454 }
14455 impl ::std::ops::BitOr for CRYPT_KEY_FLAGS {
14456     type Output = Self;
bitor(self, rhs: Self) -> Self14457     fn bitor(self, rhs: Self) -> Self {
14458         Self(self.0 | rhs.0)
14459     }
14460 }
14461 impl ::std::ops::BitAnd for CRYPT_KEY_FLAGS {
14462     type Output = Self;
bitand(self, rhs: Self) -> Self14463     fn bitand(self, rhs: Self) -> Self {
14464         Self(self.0 & rhs.0)
14465     }
14466 }
14467 impl ::std::ops::BitOrAssign for CRYPT_KEY_FLAGS {
bitor_assign(&mut self, rhs: Self)14468     fn bitor_assign(&mut self, rhs: Self) {
14469         self.0.bitor_assign(rhs.0)
14470     }
14471 }
14472 impl ::std::ops::BitAndAssign for CRYPT_KEY_FLAGS {
bitand_assign(&mut self, rhs: Self)14473     fn bitand_assign(&mut self, rhs: Self) {
14474         self.0.bitand_assign(rhs.0)
14475     }
14476 }
14477 impl ::std::ops::Not for CRYPT_KEY_FLAGS {
14478     type Output = Self;
not(self) -> Self14479     fn not(self) -> Self {
14480         Self(self.0.not())
14481     }
14482 }
14483 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
14484 #[repr(transparent)]
14485 pub struct CRYPT_KEY_PARAM_ID(pub u32);
14486 pub const KP_ALGID: CRYPT_KEY_PARAM_ID = CRYPT_KEY_PARAM_ID(7u32);
14487 pub const KP_CERTIFICATE: CRYPT_KEY_PARAM_ID = CRYPT_KEY_PARAM_ID(26u32);
14488 pub const KP_PERMISSIONS: CRYPT_KEY_PARAM_ID = CRYPT_KEY_PARAM_ID(6u32);
14489 pub const KP_SALT: CRYPT_KEY_PARAM_ID = CRYPT_KEY_PARAM_ID(2u32);
14490 pub const KP_SALT_EX: CRYPT_KEY_PARAM_ID = CRYPT_KEY_PARAM_ID(10u32);
14491 pub const KP_BLOCKLEN: CRYPT_KEY_PARAM_ID = CRYPT_KEY_PARAM_ID(8u32);
14492 pub const KP_GET_USE_COUNT: CRYPT_KEY_PARAM_ID = CRYPT_KEY_PARAM_ID(42u32);
14493 pub const KP_KEYLEN: CRYPT_KEY_PARAM_ID = CRYPT_KEY_PARAM_ID(9u32);
14494 impl ::std::convert::From<u32> for CRYPT_KEY_PARAM_ID {
from(value: u32) -> Self14495     fn from(value: u32) -> Self {
14496         Self(value)
14497     }
14498 }
14499 unsafe impl ::windows::runtime::Abi for CRYPT_KEY_PARAM_ID {
14500     type Abi = Self;
14501     type DefaultType = Self;
14502 }
14503 impl ::std::ops::BitOr for CRYPT_KEY_PARAM_ID {
14504     type Output = Self;
bitor(self, rhs: Self) -> Self14505     fn bitor(self, rhs: Self) -> Self {
14506         Self(self.0 | rhs.0)
14507     }
14508 }
14509 impl ::std::ops::BitAnd for CRYPT_KEY_PARAM_ID {
14510     type Output = Self;
bitand(self, rhs: Self) -> Self14511     fn bitand(self, rhs: Self) -> Self {
14512         Self(self.0 & rhs.0)
14513     }
14514 }
14515 impl ::std::ops::BitOrAssign for CRYPT_KEY_PARAM_ID {
bitor_assign(&mut self, rhs: Self)14516     fn bitor_assign(&mut self, rhs: Self) {
14517         self.0.bitor_assign(rhs.0)
14518     }
14519 }
14520 impl ::std::ops::BitAndAssign for CRYPT_KEY_PARAM_ID {
bitand_assign(&mut self, rhs: Self)14521     fn bitand_assign(&mut self, rhs: Self) {
14522         self.0.bitand_assign(rhs.0)
14523     }
14524 }
14525 impl ::std::ops::Not for CRYPT_KEY_PARAM_ID {
14526     type Output = Self;
not(self) -> Self14527     fn not(self) -> Self {
14528         Self(self.0.not())
14529     }
14530 }
14531 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14532 #[repr(C)]
14533 #[cfg(feature = "Win32_Foundation")]
14534 pub struct CRYPT_KEY_PROV_INFO {
14535     pub pwszContainerName: super::super::Foundation::PWSTR,
14536     pub pwszProvName: super::super::Foundation::PWSTR,
14537     pub dwProvType: u32,
14538     pub dwFlags: CRYPT_KEY_FLAGS,
14539     pub cProvParam: u32,
14540     pub rgProvParam: *mut CRYPT_KEY_PROV_PARAM,
14541     pub dwKeySpec: u32,
14542 }
14543 #[cfg(feature = "Win32_Foundation")]
14544 impl CRYPT_KEY_PROV_INFO {}
14545 #[cfg(feature = "Win32_Foundation")]
14546 impl ::std::default::Default for CRYPT_KEY_PROV_INFO {
default() -> Self14547     fn default() -> Self {
14548         unsafe { ::std::mem::zeroed() }
14549     }
14550 }
14551 #[cfg(feature = "Win32_Foundation")]
14552 impl ::std::fmt::Debug for CRYPT_KEY_PROV_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result14553     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14554         fmt.debug_struct("CRYPT_KEY_PROV_INFO")
14555             .field("pwszContainerName", &self.pwszContainerName)
14556             .field("pwszProvName", &self.pwszProvName)
14557             .field("dwProvType", &self.dwProvType)
14558             .field("dwFlags", &self.dwFlags)
14559             .field("cProvParam", &self.cProvParam)
14560             .field("rgProvParam", &self.rgProvParam)
14561             .field("dwKeySpec", &self.dwKeySpec)
14562             .finish()
14563     }
14564 }
14565 #[cfg(feature = "Win32_Foundation")]
14566 impl ::std::cmp::PartialEq for CRYPT_KEY_PROV_INFO {
eq(&self, other: &Self) -> bool14567     fn eq(&self, other: &Self) -> bool {
14568         self.pwszContainerName == other.pwszContainerName && self.pwszProvName == other.pwszProvName && self.dwProvType == other.dwProvType && self.dwFlags == other.dwFlags && self.cProvParam == other.cProvParam && self.rgProvParam == other.rgProvParam && self.dwKeySpec == other.dwKeySpec
14569     }
14570 }
14571 #[cfg(feature = "Win32_Foundation")]
14572 impl ::std::cmp::Eq for CRYPT_KEY_PROV_INFO {}
14573 #[cfg(feature = "Win32_Foundation")]
14574 unsafe impl ::windows::runtime::Abi for CRYPT_KEY_PROV_INFO {
14575     type Abi = Self;
14576     type DefaultType = Self;
14577 }
14578 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14579 #[repr(C)]
14580 pub struct CRYPT_KEY_PROV_PARAM {
14581     pub dwParam: u32,
14582     pub pbData: *mut u8,
14583     pub cbData: u32,
14584     pub dwFlags: u32,
14585 }
14586 impl CRYPT_KEY_PROV_PARAM {}
14587 impl ::std::default::Default for CRYPT_KEY_PROV_PARAM {
default() -> Self14588     fn default() -> Self {
14589         unsafe { ::std::mem::zeroed() }
14590     }
14591 }
14592 impl ::std::fmt::Debug for CRYPT_KEY_PROV_PARAM {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result14593     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14594         fmt.debug_struct("CRYPT_KEY_PROV_PARAM").field("dwParam", &self.dwParam).field("pbData", &self.pbData).field("cbData", &self.cbData).field("dwFlags", &self.dwFlags).finish()
14595     }
14596 }
14597 impl ::std::cmp::PartialEq for CRYPT_KEY_PROV_PARAM {
eq(&self, other: &Self) -> bool14598     fn eq(&self, other: &Self) -> bool {
14599         self.dwParam == other.dwParam && self.pbData == other.pbData && self.cbData == other.cbData && self.dwFlags == other.dwFlags
14600     }
14601 }
14602 impl ::std::cmp::Eq for CRYPT_KEY_PROV_PARAM {}
14603 unsafe impl ::windows::runtime::Abi for CRYPT_KEY_PROV_PARAM {
14604     type Abi = Self;
14605     type DefaultType = Self;
14606 }
14607 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14608 #[repr(C)]
14609 #[cfg(feature = "Win32_Foundation")]
14610 pub struct CRYPT_KEY_SIGN_MESSAGE_PARA {
14611     pub cbSize: u32,
14612     pub dwMsgAndCertEncodingType: CERT_QUERY_ENCODING_TYPE,
14613     pub Anonymous: CRYPT_KEY_SIGN_MESSAGE_PARA_0,
14614     pub dwKeySpec: CERT_KEY_SPEC,
14615     pub HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
14616     pub pvHashAuxInfo: *mut ::std::ffi::c_void,
14617     pub PubKeyAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
14618 }
14619 #[cfg(feature = "Win32_Foundation")]
14620 impl CRYPT_KEY_SIGN_MESSAGE_PARA {}
14621 #[cfg(feature = "Win32_Foundation")]
14622 impl ::std::default::Default for CRYPT_KEY_SIGN_MESSAGE_PARA {
default() -> Self14623     fn default() -> Self {
14624         unsafe { ::std::mem::zeroed() }
14625     }
14626 }
14627 #[cfg(feature = "Win32_Foundation")]
14628 impl ::std::cmp::PartialEq for CRYPT_KEY_SIGN_MESSAGE_PARA {
eq(&self, _other: &Self) -> bool14629     fn eq(&self, _other: &Self) -> bool {
14630         unimplemented!()
14631     }
14632 }
14633 #[cfg(feature = "Win32_Foundation")]
14634 impl ::std::cmp::Eq for CRYPT_KEY_SIGN_MESSAGE_PARA {}
14635 #[cfg(feature = "Win32_Foundation")]
14636 unsafe impl ::windows::runtime::Abi for CRYPT_KEY_SIGN_MESSAGE_PARA {
14637     type Abi = Self;
14638     type DefaultType = Self;
14639 }
14640 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14641 #[repr(C)]
14642 pub union CRYPT_KEY_SIGN_MESSAGE_PARA_0 {
14643     pub hCryptProv: usize,
14644     pub hNCryptKey: usize,
14645 }
14646 impl CRYPT_KEY_SIGN_MESSAGE_PARA_0 {}
14647 impl ::std::default::Default for CRYPT_KEY_SIGN_MESSAGE_PARA_0 {
default() -> Self14648     fn default() -> Self {
14649         unsafe { ::std::mem::zeroed() }
14650     }
14651 }
14652 impl ::std::cmp::PartialEq for CRYPT_KEY_SIGN_MESSAGE_PARA_0 {
eq(&self, _other: &Self) -> bool14653     fn eq(&self, _other: &Self) -> bool {
14654         unimplemented!()
14655     }
14656 }
14657 impl ::std::cmp::Eq for CRYPT_KEY_SIGN_MESSAGE_PARA_0 {}
14658 unsafe impl ::windows::runtime::Abi for CRYPT_KEY_SIGN_MESSAGE_PARA_0 {
14659     type Abi = Self;
14660     type DefaultType = Self;
14661 }
14662 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14663 #[repr(C)]
14664 pub struct CRYPT_KEY_VERIFY_MESSAGE_PARA {
14665     pub cbSize: u32,
14666     pub dwMsgEncodingType: u32,
14667     pub hCryptProv: usize,
14668 }
14669 impl CRYPT_KEY_VERIFY_MESSAGE_PARA {}
14670 impl ::std::default::Default for CRYPT_KEY_VERIFY_MESSAGE_PARA {
default() -> Self14671     fn default() -> Self {
14672         unsafe { ::std::mem::zeroed() }
14673     }
14674 }
14675 impl ::std::fmt::Debug for CRYPT_KEY_VERIFY_MESSAGE_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result14676     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14677         fmt.debug_struct("CRYPT_KEY_VERIFY_MESSAGE_PARA").field("cbSize", &self.cbSize).field("dwMsgEncodingType", &self.dwMsgEncodingType).field("hCryptProv", &self.hCryptProv).finish()
14678     }
14679 }
14680 impl ::std::cmp::PartialEq for CRYPT_KEY_VERIFY_MESSAGE_PARA {
eq(&self, other: &Self) -> bool14681     fn eq(&self, other: &Self) -> bool {
14682         self.cbSize == other.cbSize && self.dwMsgEncodingType == other.dwMsgEncodingType && self.hCryptProv == other.hCryptProv
14683     }
14684 }
14685 impl ::std::cmp::Eq for CRYPT_KEY_VERIFY_MESSAGE_PARA {}
14686 unsafe impl ::windows::runtime::Abi for CRYPT_KEY_VERIFY_MESSAGE_PARA {
14687     type Abi = Self;
14688     type DefaultType = Self;
14689 }
14690 pub const CRYPT_LAST_ALG_OID_GROUP_ID: u32 = 4u32;
14691 pub const CRYPT_LAST_OID_GROUP_ID: u32 = 10u32;
14692 pub const CRYPT_LDAP_AREC_EXCLUSIVE_RETRIEVAL: u32 = 262144u32;
14693 pub const CRYPT_LDAP_INSERT_ENTRY_ATTRIBUTE: u32 = 32768u32;
14694 pub const CRYPT_LDAP_SCOPE_BASE_ONLY_RETRIEVAL: u32 = 8192u32;
14695 pub const CRYPT_LDAP_SIGN_RETRIEVAL: u32 = 65536u32;
14696 pub const CRYPT_LITTLE_ENDIAN: u32 = 1u32;
14697 pub const CRYPT_LOCALIZED_NAME_ENCODING_TYPE: u32 = 0u32;
14698 pub const CRYPT_MAC: u32 = 32u32;
14699 pub const CRYPT_MACHINE_DEFAULT: u32 = 1u32;
14700 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14701 #[repr(C)]
14702 #[cfg(feature = "Win32_Foundation")]
14703 pub struct CRYPT_MASK_GEN_ALGORITHM {
14704     pub pszObjId: super::super::Foundation::PSTR,
14705     pub HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
14706 }
14707 #[cfg(feature = "Win32_Foundation")]
14708 impl CRYPT_MASK_GEN_ALGORITHM {}
14709 #[cfg(feature = "Win32_Foundation")]
14710 impl ::std::default::Default for CRYPT_MASK_GEN_ALGORITHM {
default() -> Self14711     fn default() -> Self {
14712         unsafe { ::std::mem::zeroed() }
14713     }
14714 }
14715 #[cfg(feature = "Win32_Foundation")]
14716 impl ::std::fmt::Debug for CRYPT_MASK_GEN_ALGORITHM {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result14717     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14718         fmt.debug_struct("CRYPT_MASK_GEN_ALGORITHM").field("pszObjId", &self.pszObjId).field("HashAlgorithm", &self.HashAlgorithm).finish()
14719     }
14720 }
14721 #[cfg(feature = "Win32_Foundation")]
14722 impl ::std::cmp::PartialEq for CRYPT_MASK_GEN_ALGORITHM {
eq(&self, other: &Self) -> bool14723     fn eq(&self, other: &Self) -> bool {
14724         self.pszObjId == other.pszObjId && self.HashAlgorithm == other.HashAlgorithm
14725     }
14726 }
14727 #[cfg(feature = "Win32_Foundation")]
14728 impl ::std::cmp::Eq for CRYPT_MASK_GEN_ALGORITHM {}
14729 #[cfg(feature = "Win32_Foundation")]
14730 unsafe impl ::windows::runtime::Abi for CRYPT_MASK_GEN_ALGORITHM {
14731     type Abi = Self;
14732     type DefaultType = Self;
14733 }
14734 pub const CRYPT_MATCH_ANY_ENCODING_TYPE: u32 = 4294967295u32;
14735 pub const CRYPT_MESSAGE_BARE_CONTENT_OUT_FLAG: u32 = 1u32;
14736 pub const CRYPT_MESSAGE_ENCAPSULATED_CONTENT_OUT_FLAG: u32 = 2u32;
14737 pub const CRYPT_MESSAGE_KEYID_RECIPIENT_FLAG: u32 = 4u32;
14738 pub const CRYPT_MESSAGE_KEYID_SIGNER_FLAG: u32 = 4u32;
14739 pub const CRYPT_MESSAGE_SILENT_KEYSET_FLAG: u32 = 64u32;
14740 pub const CRYPT_MODE_CBC: u32 = 1u32;
14741 pub const CRYPT_MODE_CBCI: u32 = 6u32;
14742 pub const CRYPT_MODE_CBCOFM: u32 = 9u32;
14743 pub const CRYPT_MODE_CBCOFMI: u32 = 10u32;
14744 pub const CRYPT_MODE_CFB: u32 = 4u32;
14745 pub const CRYPT_MODE_CFBP: u32 = 7u32;
14746 pub const CRYPT_MODE_CTS: u32 = 5u32;
14747 pub const CRYPT_MODE_ECB: u32 = 2u32;
14748 pub const CRYPT_MODE_OFB: u32 = 3u32;
14749 pub const CRYPT_MODE_OFBP: u32 = 8u32;
14750 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
14751 #[repr(transparent)]
14752 pub struct CRYPT_MSG_TYPE(pub u32);
14753 pub const CMSG_DATA: CRYPT_MSG_TYPE = CRYPT_MSG_TYPE(1u32);
14754 pub const CMSG_SIGNED: CRYPT_MSG_TYPE = CRYPT_MSG_TYPE(2u32);
14755 pub const CMSG_ENVELOPED: CRYPT_MSG_TYPE = CRYPT_MSG_TYPE(3u32);
14756 pub const CMSG_SIGNED_AND_ENVELOPED: CRYPT_MSG_TYPE = CRYPT_MSG_TYPE(4u32);
14757 pub const CMSG_HASHED: CRYPT_MSG_TYPE = CRYPT_MSG_TYPE(5u32);
14758 impl ::std::convert::From<u32> for CRYPT_MSG_TYPE {
from(value: u32) -> Self14759     fn from(value: u32) -> Self {
14760         Self(value)
14761     }
14762 }
14763 unsafe impl ::windows::runtime::Abi for CRYPT_MSG_TYPE {
14764     type Abi = Self;
14765     type DefaultType = Self;
14766 }
14767 impl ::std::ops::BitOr for CRYPT_MSG_TYPE {
14768     type Output = Self;
bitor(self, rhs: Self) -> Self14769     fn bitor(self, rhs: Self) -> Self {
14770         Self(self.0 | rhs.0)
14771     }
14772 }
14773 impl ::std::ops::BitAnd for CRYPT_MSG_TYPE {
14774     type Output = Self;
bitand(self, rhs: Self) -> Self14775     fn bitand(self, rhs: Self) -> Self {
14776         Self(self.0 & rhs.0)
14777     }
14778 }
14779 impl ::std::ops::BitOrAssign for CRYPT_MSG_TYPE {
bitor_assign(&mut self, rhs: Self)14780     fn bitor_assign(&mut self, rhs: Self) {
14781         self.0.bitor_assign(rhs.0)
14782     }
14783 }
14784 impl ::std::ops::BitAndAssign for CRYPT_MSG_TYPE {
bitand_assign(&mut self, rhs: Self)14785     fn bitand_assign(&mut self, rhs: Self) {
14786         self.0.bitand_assign(rhs.0)
14787     }
14788 }
14789 impl ::std::ops::Not for CRYPT_MSG_TYPE {
14790     type Output = Self;
not(self) -> Self14791     fn not(self) -> Self {
14792         Self(self.0.not())
14793     }
14794 }
14795 pub const CRYPT_NDR_ENCODING: u32 = 2u32;
14796 pub const CRYPT_NEWKEYSET: u32 = 8u32;
14797 pub const CRYPT_NEXT: u32 = 2u32;
14798 pub const CRYPT_NOHASHOID: u32 = 1u32;
14799 pub const CRYPT_NOT_MODIFIED_RETRIEVAL: u32 = 4194304u32;
14800 pub const CRYPT_NO_AUTH_RETRIEVAL: u32 = 131072u32;
14801 pub const CRYPT_NO_OCSP_FAILOVER_TO_CRL_RETRIEVAL: u32 = 33554432u32;
14802 pub const CRYPT_OBJECT_LOCATOR_FIRST_RESERVED_USER_NAME_TYPE: u32 = 33u32;
14803 pub const CRYPT_OBJECT_LOCATOR_LAST_RESERVED_NAME_TYPE: u32 = 32u32;
14804 pub const CRYPT_OBJECT_LOCATOR_LAST_RESERVED_USER_NAME_TYPE: u32 = 65535u32;
14805 #[derive(:: std :: clone :: Clone)]
14806 #[repr(C)]
14807 #[cfg(feature = "Win32_Foundation")]
14808 pub struct CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE {
14809     pub cbSize: u32,
14810     pub pfnGet: ::std::option::Option<PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_GET>,
14811     pub pfnRelease: ::std::option::Option<PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_RELEASE>,
14812     pub pfnFreePassword: ::std::option::Option<PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_PASSWORD>,
14813     pub pfnFree: ::std::option::Option<PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE>,
14814     pub pfnFreeIdentifier: ::std::option::Option<PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_IDENTIFIER>,
14815 }
14816 #[cfg(feature = "Win32_Foundation")]
14817 impl CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE {}
14818 #[cfg(feature = "Win32_Foundation")]
14819 impl ::std::default::Default for CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE {
default() -> Self14820     fn default() -> Self {
14821         unsafe { ::std::mem::zeroed() }
14822     }
14823 }
14824 #[cfg(feature = "Win32_Foundation")]
14825 impl ::std::fmt::Debug for CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result14826     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14827         fmt.debug_struct("CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE").field("cbSize", &self.cbSize).finish()
14828     }
14829 }
14830 #[cfg(feature = "Win32_Foundation")]
14831 impl ::std::cmp::PartialEq for CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE {
eq(&self, other: &Self) -> bool14832     fn eq(&self, other: &Self) -> bool {
14833         self.cbSize == other.cbSize && self.pfnGet.map(|f| f as usize) == other.pfnGet.map(|f| f as usize) && self.pfnRelease.map(|f| f as usize) == other.pfnRelease.map(|f| f as usize) && self.pfnFreePassword.map(|f| f as usize) == other.pfnFreePassword.map(|f| f as usize) && self.pfnFree.map(|f| f as usize) == other.pfnFree.map(|f| f as usize) && self.pfnFreeIdentifier.map(|f| f as usize) == other.pfnFreeIdentifier.map(|f| f as usize)
14834     }
14835 }
14836 #[cfg(feature = "Win32_Foundation")]
14837 impl ::std::cmp::Eq for CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE {}
14838 #[cfg(feature = "Win32_Foundation")]
14839 unsafe impl ::windows::runtime::Abi for CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE {
14840     type Abi = ::std::mem::ManuallyDrop<Self>;
14841     type DefaultType = Self;
14842 }
14843 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
14844 #[repr(transparent)]
14845 pub struct CRYPT_OBJECT_LOCATOR_RELEASE_REASON(pub u32);
14846 pub const CRYPT_OBJECT_LOCATOR_RELEASE_SYSTEM_SHUTDOWN: CRYPT_OBJECT_LOCATOR_RELEASE_REASON = CRYPT_OBJECT_LOCATOR_RELEASE_REASON(1u32);
14847 pub const CRYPT_OBJECT_LOCATOR_RELEASE_SERVICE_STOP: CRYPT_OBJECT_LOCATOR_RELEASE_REASON = CRYPT_OBJECT_LOCATOR_RELEASE_REASON(2u32);
14848 pub const CRYPT_OBJECT_LOCATOR_RELEASE_PROCESS_EXIT: CRYPT_OBJECT_LOCATOR_RELEASE_REASON = CRYPT_OBJECT_LOCATOR_RELEASE_REASON(3u32);
14849 pub const CRYPT_OBJECT_LOCATOR_RELEASE_DLL_UNLOAD: CRYPT_OBJECT_LOCATOR_RELEASE_REASON = CRYPT_OBJECT_LOCATOR_RELEASE_REASON(4u32);
14850 impl ::std::convert::From<u32> for CRYPT_OBJECT_LOCATOR_RELEASE_REASON {
from(value: u32) -> Self14851     fn from(value: u32) -> Self {
14852         Self(value)
14853     }
14854 }
14855 unsafe impl ::windows::runtime::Abi for CRYPT_OBJECT_LOCATOR_RELEASE_REASON {
14856     type Abi = Self;
14857     type DefaultType = Self;
14858 }
14859 impl ::std::ops::BitOr for CRYPT_OBJECT_LOCATOR_RELEASE_REASON {
14860     type Output = Self;
bitor(self, rhs: Self) -> Self14861     fn bitor(self, rhs: Self) -> Self {
14862         Self(self.0 | rhs.0)
14863     }
14864 }
14865 impl ::std::ops::BitAnd for CRYPT_OBJECT_LOCATOR_RELEASE_REASON {
14866     type Output = Self;
bitand(self, rhs: Self) -> Self14867     fn bitand(self, rhs: Self) -> Self {
14868         Self(self.0 & rhs.0)
14869     }
14870 }
14871 impl ::std::ops::BitOrAssign for CRYPT_OBJECT_LOCATOR_RELEASE_REASON {
bitor_assign(&mut self, rhs: Self)14872     fn bitor_assign(&mut self, rhs: Self) {
14873         self.0.bitor_assign(rhs.0)
14874     }
14875 }
14876 impl ::std::ops::BitAndAssign for CRYPT_OBJECT_LOCATOR_RELEASE_REASON {
bitand_assign(&mut self, rhs: Self)14877     fn bitand_assign(&mut self, rhs: Self) {
14878         self.0.bitand_assign(rhs.0)
14879     }
14880 }
14881 impl ::std::ops::Not for CRYPT_OBJECT_LOCATOR_RELEASE_REASON {
14882     type Output = Self;
not(self) -> Self14883     fn not(self) -> Self {
14884         Self(self.0.not())
14885     }
14886 }
14887 pub const CRYPT_OBJECT_LOCATOR_SPN_NAME_TYPE: u32 = 1u32;
14888 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14889 #[repr(C)]
14890 #[cfg(feature = "Win32_Foundation")]
14891 pub struct CRYPT_OBJID_TABLE {
14892     pub dwAlgId: u32,
14893     pub pszObjId: super::super::Foundation::PSTR,
14894 }
14895 #[cfg(feature = "Win32_Foundation")]
14896 impl CRYPT_OBJID_TABLE {}
14897 #[cfg(feature = "Win32_Foundation")]
14898 impl ::std::default::Default for CRYPT_OBJID_TABLE {
default() -> Self14899     fn default() -> Self {
14900         unsafe { ::std::mem::zeroed() }
14901     }
14902 }
14903 #[cfg(feature = "Win32_Foundation")]
14904 impl ::std::fmt::Debug for CRYPT_OBJID_TABLE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result14905     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14906         fmt.debug_struct("CRYPT_OBJID_TABLE").field("dwAlgId", &self.dwAlgId).field("pszObjId", &self.pszObjId).finish()
14907     }
14908 }
14909 #[cfg(feature = "Win32_Foundation")]
14910 impl ::std::cmp::PartialEq for CRYPT_OBJID_TABLE {
eq(&self, other: &Self) -> bool14911     fn eq(&self, other: &Self) -> bool {
14912         self.dwAlgId == other.dwAlgId && self.pszObjId == other.pszObjId
14913     }
14914 }
14915 #[cfg(feature = "Win32_Foundation")]
14916 impl ::std::cmp::Eq for CRYPT_OBJID_TABLE {}
14917 #[cfg(feature = "Win32_Foundation")]
14918 unsafe impl ::windows::runtime::Abi for CRYPT_OBJID_TABLE {
14919     type Abi = Self;
14920     type DefaultType = Self;
14921 }
14922 pub const CRYPT_OCSP_ONLY_RETRIEVAL: u32 = 16777216u32;
14923 pub const CRYPT_OFFLINE_CHECK_RETRIEVAL: u32 = 16384u32;
14924 pub const CRYPT_OID_DISABLE_SEARCH_DS_FLAG: u32 = 2147483648u32;
14925 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14926 #[repr(C)]
14927 #[cfg(feature = "Win32_Foundation")]
14928 pub struct CRYPT_OID_FUNC_ENTRY {
14929     pub pszOID: super::super::Foundation::PSTR,
14930     pub pvFuncAddr: *mut ::std::ffi::c_void,
14931 }
14932 #[cfg(feature = "Win32_Foundation")]
14933 impl CRYPT_OID_FUNC_ENTRY {}
14934 #[cfg(feature = "Win32_Foundation")]
14935 impl ::std::default::Default for CRYPT_OID_FUNC_ENTRY {
default() -> Self14936     fn default() -> Self {
14937         unsafe { ::std::mem::zeroed() }
14938     }
14939 }
14940 #[cfg(feature = "Win32_Foundation")]
14941 impl ::std::fmt::Debug for CRYPT_OID_FUNC_ENTRY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result14942     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14943         fmt.debug_struct("CRYPT_OID_FUNC_ENTRY").field("pszOID", &self.pszOID).field("pvFuncAddr", &self.pvFuncAddr).finish()
14944     }
14945 }
14946 #[cfg(feature = "Win32_Foundation")]
14947 impl ::std::cmp::PartialEq for CRYPT_OID_FUNC_ENTRY {
eq(&self, other: &Self) -> bool14948     fn eq(&self, other: &Self) -> bool {
14949         self.pszOID == other.pszOID && self.pvFuncAddr == other.pvFuncAddr
14950     }
14951 }
14952 #[cfg(feature = "Win32_Foundation")]
14953 impl ::std::cmp::Eq for CRYPT_OID_FUNC_ENTRY {}
14954 #[cfg(feature = "Win32_Foundation")]
14955 unsafe impl ::windows::runtime::Abi for CRYPT_OID_FUNC_ENTRY {
14956     type Abi = Self;
14957     type DefaultType = Self;
14958 }
14959 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14960 #[repr(C)]
14961 #[cfg(feature = "Win32_Foundation")]
14962 pub struct CRYPT_OID_INFO {
14963     pub cbSize: u32,
14964     pub pszOID: super::super::Foundation::PSTR,
14965     pub pwszName: super::super::Foundation::PWSTR,
14966     pub dwGroupId: u32,
14967     pub Anonymous: CRYPT_OID_INFO_0,
14968     pub ExtraInfo: CRYPTOAPI_BLOB,
14969 }
14970 #[cfg(feature = "Win32_Foundation")]
14971 impl CRYPT_OID_INFO {}
14972 #[cfg(feature = "Win32_Foundation")]
14973 impl ::std::default::Default for CRYPT_OID_INFO {
default() -> Self14974     fn default() -> Self {
14975         unsafe { ::std::mem::zeroed() }
14976     }
14977 }
14978 #[cfg(feature = "Win32_Foundation")]
14979 impl ::std::cmp::PartialEq for CRYPT_OID_INFO {
eq(&self, _other: &Self) -> bool14980     fn eq(&self, _other: &Self) -> bool {
14981         unimplemented!()
14982     }
14983 }
14984 #[cfg(feature = "Win32_Foundation")]
14985 impl ::std::cmp::Eq for CRYPT_OID_INFO {}
14986 #[cfg(feature = "Win32_Foundation")]
14987 unsafe impl ::windows::runtime::Abi for CRYPT_OID_INFO {
14988     type Abi = Self;
14989     type DefaultType = Self;
14990 }
14991 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14992 #[repr(C)]
14993 pub union CRYPT_OID_INFO_0 {
14994     pub dwValue: u32,
14995     pub Algid: u32,
14996     pub dwLength: u32,
14997 }
14998 impl CRYPT_OID_INFO_0 {}
14999 impl ::std::default::Default for CRYPT_OID_INFO_0 {
default() -> Self15000     fn default() -> Self {
15001         unsafe { ::std::mem::zeroed() }
15002     }
15003 }
15004 impl ::std::cmp::PartialEq for CRYPT_OID_INFO_0 {
eq(&self, _other: &Self) -> bool15005     fn eq(&self, _other: &Self) -> bool {
15006         unimplemented!()
15007     }
15008 }
15009 impl ::std::cmp::Eq for CRYPT_OID_INFO_0 {}
15010 unsafe impl ::windows::runtime::Abi for CRYPT_OID_INFO_0 {
15011     type Abi = Self;
15012     type DefaultType = Self;
15013 }
15014 pub const CRYPT_OID_INFO_ALGID_KEY: u32 = 3u32;
15015 pub const CRYPT_OID_INFO_CNG_ALGID_KEY: u32 = 5u32;
15016 pub const CRYPT_OID_INFO_CNG_SIGN_KEY: u32 = 6u32;
15017 pub const CRYPT_OID_INFO_NAME_KEY: u32 = 2u32;
15018 pub const CRYPT_OID_INFO_OID_GROUP_BIT_LEN_MASK: u32 = 268369920u32;
15019 pub const CRYPT_OID_INFO_OID_GROUP_BIT_LEN_SHIFT: u32 = 16u32;
15020 pub const CRYPT_OID_INFO_OID_KEY: u32 = 1u32;
15021 pub const CRYPT_OID_INFO_OID_KEY_FLAGS_MASK: u32 = 4294901760u32;
15022 pub const CRYPT_OID_INFO_SIGN_KEY: u32 = 4u32;
15023 pub const CRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAG: u32 = 1u32;
15024 pub const CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG: u32 = 4u32;
15025 pub const CRYPT_OID_PREFER_CNG_ALGID_FLAG: u32 = 1073741824u32;
15026 pub const CRYPT_OID_PUBKEY_ENCRYPT_ONLY_FLAG: u32 = 1073741824u32;
15027 pub const CRYPT_OID_PUBKEY_SIGN_ONLY_FLAG: u32 = 2147483648u32;
15028 pub const CRYPT_OID_USE_CURVE_NAME_FOR_ENCODE_FLAG: u32 = 536870912u32;
15029 pub const CRYPT_OID_USE_CURVE_PARAMETERS_FOR_ENCODE_FLAG: u32 = 268435456u32;
15030 pub const CRYPT_OID_USE_PUBKEY_PARA_FOR_PKCS7_FLAG: u32 = 2u32;
15031 pub const CRYPT_OVERWRITE: u32 = 1u32;
15032 pub const CRYPT_OWF_REPL_LM_HASH: u32 = 1u32;
15033 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15034 #[repr(C)]
15035 #[cfg(feature = "Win32_Foundation")]
15036 pub struct CRYPT_PASSWORD_CREDENTIALSA {
15037     pub cbSize: u32,
15038     pub pszUsername: super::super::Foundation::PSTR,
15039     pub pszPassword: super::super::Foundation::PSTR,
15040 }
15041 #[cfg(feature = "Win32_Foundation")]
15042 impl CRYPT_PASSWORD_CREDENTIALSA {}
15043 #[cfg(feature = "Win32_Foundation")]
15044 impl ::std::default::Default for CRYPT_PASSWORD_CREDENTIALSA {
default() -> Self15045     fn default() -> Self {
15046         unsafe { ::std::mem::zeroed() }
15047     }
15048 }
15049 #[cfg(feature = "Win32_Foundation")]
15050 impl ::std::fmt::Debug for CRYPT_PASSWORD_CREDENTIALSA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15051     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15052         fmt.debug_struct("CRYPT_PASSWORD_CREDENTIALSA").field("cbSize", &self.cbSize).field("pszUsername", &self.pszUsername).field("pszPassword", &self.pszPassword).finish()
15053     }
15054 }
15055 #[cfg(feature = "Win32_Foundation")]
15056 impl ::std::cmp::PartialEq for CRYPT_PASSWORD_CREDENTIALSA {
eq(&self, other: &Self) -> bool15057     fn eq(&self, other: &Self) -> bool {
15058         self.cbSize == other.cbSize && self.pszUsername == other.pszUsername && self.pszPassword == other.pszPassword
15059     }
15060 }
15061 #[cfg(feature = "Win32_Foundation")]
15062 impl ::std::cmp::Eq for CRYPT_PASSWORD_CREDENTIALSA {}
15063 #[cfg(feature = "Win32_Foundation")]
15064 unsafe impl ::windows::runtime::Abi for CRYPT_PASSWORD_CREDENTIALSA {
15065     type Abi = Self;
15066     type DefaultType = Self;
15067 }
15068 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15069 #[repr(C)]
15070 #[cfg(feature = "Win32_Foundation")]
15071 pub struct CRYPT_PASSWORD_CREDENTIALSW {
15072     pub cbSize: u32,
15073     pub pszUsername: super::super::Foundation::PWSTR,
15074     pub pszPassword: super::super::Foundation::PWSTR,
15075 }
15076 #[cfg(feature = "Win32_Foundation")]
15077 impl CRYPT_PASSWORD_CREDENTIALSW {}
15078 #[cfg(feature = "Win32_Foundation")]
15079 impl ::std::default::Default for CRYPT_PASSWORD_CREDENTIALSW {
default() -> Self15080     fn default() -> Self {
15081         unsafe { ::std::mem::zeroed() }
15082     }
15083 }
15084 #[cfg(feature = "Win32_Foundation")]
15085 impl ::std::fmt::Debug for CRYPT_PASSWORD_CREDENTIALSW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15086     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15087         fmt.debug_struct("CRYPT_PASSWORD_CREDENTIALSW").field("cbSize", &self.cbSize).field("pszUsername", &self.pszUsername).field("pszPassword", &self.pszPassword).finish()
15088     }
15089 }
15090 #[cfg(feature = "Win32_Foundation")]
15091 impl ::std::cmp::PartialEq for CRYPT_PASSWORD_CREDENTIALSW {
eq(&self, other: &Self) -> bool15092     fn eq(&self, other: &Self) -> bool {
15093         self.cbSize == other.cbSize && self.pszUsername == other.pszUsername && self.pszPassword == other.pszPassword
15094     }
15095 }
15096 #[cfg(feature = "Win32_Foundation")]
15097 impl ::std::cmp::Eq for CRYPT_PASSWORD_CREDENTIALSW {}
15098 #[cfg(feature = "Win32_Foundation")]
15099 unsafe impl ::windows::runtime::Abi for CRYPT_PASSWORD_CREDENTIALSW {
15100     type Abi = Self;
15101     type DefaultType = Self;
15102 }
15103 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15104 #[repr(C)]
15105 pub struct CRYPT_PKCS12_PBE_PARAMS {
15106     pub iIterations: i32,
15107     pub cbSalt: u32,
15108 }
15109 impl CRYPT_PKCS12_PBE_PARAMS {}
15110 impl ::std::default::Default for CRYPT_PKCS12_PBE_PARAMS {
default() -> Self15111     fn default() -> Self {
15112         unsafe { ::std::mem::zeroed() }
15113     }
15114 }
15115 impl ::std::fmt::Debug for CRYPT_PKCS12_PBE_PARAMS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15116     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15117         fmt.debug_struct("CRYPT_PKCS12_PBE_PARAMS").field("iIterations", &self.iIterations).field("cbSalt", &self.cbSalt).finish()
15118     }
15119 }
15120 impl ::std::cmp::PartialEq for CRYPT_PKCS12_PBE_PARAMS {
eq(&self, other: &Self) -> bool15121     fn eq(&self, other: &Self) -> bool {
15122         self.iIterations == other.iIterations && self.cbSalt == other.cbSalt
15123     }
15124 }
15125 impl ::std::cmp::Eq for CRYPT_PKCS12_PBE_PARAMS {}
15126 unsafe impl ::windows::runtime::Abi for CRYPT_PKCS12_PBE_PARAMS {
15127     type Abi = Self;
15128     type DefaultType = Self;
15129 }
15130 #[derive(:: std :: clone :: Clone)]
15131 #[repr(C)]
15132 #[cfg(feature = "Win32_Foundation")]
15133 pub struct CRYPT_PKCS8_EXPORT_PARAMS {
15134     pub hCryptProv: usize,
15135     pub dwKeySpec: u32,
15136     pub pszPrivateKeyObjId: super::super::Foundation::PSTR,
15137     pub pEncryptPrivateKeyFunc: ::std::option::Option<PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC>,
15138     pub pVoidEncryptFunc: *mut ::std::ffi::c_void,
15139 }
15140 #[cfg(feature = "Win32_Foundation")]
15141 impl CRYPT_PKCS8_EXPORT_PARAMS {}
15142 #[cfg(feature = "Win32_Foundation")]
15143 impl ::std::default::Default for CRYPT_PKCS8_EXPORT_PARAMS {
default() -> Self15144     fn default() -> Self {
15145         unsafe { ::std::mem::zeroed() }
15146     }
15147 }
15148 #[cfg(feature = "Win32_Foundation")]
15149 impl ::std::fmt::Debug for CRYPT_PKCS8_EXPORT_PARAMS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15150     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15151         fmt.debug_struct("CRYPT_PKCS8_EXPORT_PARAMS").field("hCryptProv", &self.hCryptProv).field("dwKeySpec", &self.dwKeySpec).field("pszPrivateKeyObjId", &self.pszPrivateKeyObjId).field("pVoidEncryptFunc", &self.pVoidEncryptFunc).finish()
15152     }
15153 }
15154 #[cfg(feature = "Win32_Foundation")]
15155 impl ::std::cmp::PartialEq for CRYPT_PKCS8_EXPORT_PARAMS {
eq(&self, other: &Self) -> bool15156     fn eq(&self, other: &Self) -> bool {
15157         self.hCryptProv == other.hCryptProv && self.dwKeySpec == other.dwKeySpec && self.pszPrivateKeyObjId == other.pszPrivateKeyObjId && self.pEncryptPrivateKeyFunc.map(|f| f as usize) == other.pEncryptPrivateKeyFunc.map(|f| f as usize) && self.pVoidEncryptFunc == other.pVoidEncryptFunc
15158     }
15159 }
15160 #[cfg(feature = "Win32_Foundation")]
15161 impl ::std::cmp::Eq for CRYPT_PKCS8_EXPORT_PARAMS {}
15162 #[cfg(feature = "Win32_Foundation")]
15163 unsafe impl ::windows::runtime::Abi for CRYPT_PKCS8_EXPORT_PARAMS {
15164     type Abi = ::std::mem::ManuallyDrop<Self>;
15165     type DefaultType = Self;
15166 }
15167 #[derive(:: std :: clone :: Clone)]
15168 #[repr(C)]
15169 #[cfg(feature = "Win32_Foundation")]
15170 pub struct CRYPT_PKCS8_IMPORT_PARAMS {
15171     pub PrivateKey: CRYPTOAPI_BLOB,
15172     pub pResolvehCryptProvFunc: ::std::option::Option<PCRYPT_RESOLVE_HCRYPTPROV_FUNC>,
15173     pub pVoidResolveFunc: *mut ::std::ffi::c_void,
15174     pub pDecryptPrivateKeyFunc: ::std::option::Option<PCRYPT_DECRYPT_PRIVATE_KEY_FUNC>,
15175     pub pVoidDecryptFunc: *mut ::std::ffi::c_void,
15176 }
15177 #[cfg(feature = "Win32_Foundation")]
15178 impl CRYPT_PKCS8_IMPORT_PARAMS {}
15179 #[cfg(feature = "Win32_Foundation")]
15180 impl ::std::default::Default for CRYPT_PKCS8_IMPORT_PARAMS {
default() -> Self15181     fn default() -> Self {
15182         unsafe { ::std::mem::zeroed() }
15183     }
15184 }
15185 #[cfg(feature = "Win32_Foundation")]
15186 impl ::std::fmt::Debug for CRYPT_PKCS8_IMPORT_PARAMS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15187     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15188         fmt.debug_struct("CRYPT_PKCS8_IMPORT_PARAMS").field("PrivateKey", &self.PrivateKey).field("pVoidResolveFunc", &self.pVoidResolveFunc).field("pVoidDecryptFunc", &self.pVoidDecryptFunc).finish()
15189     }
15190 }
15191 #[cfg(feature = "Win32_Foundation")]
15192 impl ::std::cmp::PartialEq for CRYPT_PKCS8_IMPORT_PARAMS {
eq(&self, other: &Self) -> bool15193     fn eq(&self, other: &Self) -> bool {
15194         self.PrivateKey == other.PrivateKey && self.pResolvehCryptProvFunc.map(|f| f as usize) == other.pResolvehCryptProvFunc.map(|f| f as usize) && self.pVoidResolveFunc == other.pVoidResolveFunc && self.pDecryptPrivateKeyFunc.map(|f| f as usize) == other.pDecryptPrivateKeyFunc.map(|f| f as usize) && self.pVoidDecryptFunc == other.pVoidDecryptFunc
15195     }
15196 }
15197 #[cfg(feature = "Win32_Foundation")]
15198 impl ::std::cmp::Eq for CRYPT_PKCS8_IMPORT_PARAMS {}
15199 #[cfg(feature = "Win32_Foundation")]
15200 unsafe impl ::windows::runtime::Abi for CRYPT_PKCS8_IMPORT_PARAMS {
15201     type Abi = ::std::mem::ManuallyDrop<Self>;
15202     type DefaultType = Self;
15203 }
15204 pub const CRYPT_POLICY_OID_GROUP_ID: u32 = 8u32;
15205 pub const CRYPT_PRIORITY_BOTTOM: u32 = 4294967295u32;
15206 pub const CRYPT_PRIORITY_TOP: u32 = 0u32;
15207 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15208 #[repr(C)]
15209 #[cfg(feature = "Win32_Foundation")]
15210 pub struct CRYPT_PRIVATE_KEY_INFO {
15211     pub Version: u32,
15212     pub Algorithm: CRYPT_ALGORITHM_IDENTIFIER,
15213     pub PrivateKey: CRYPTOAPI_BLOB,
15214     pub pAttributes: *mut CRYPT_ATTRIBUTES,
15215 }
15216 #[cfg(feature = "Win32_Foundation")]
15217 impl CRYPT_PRIVATE_KEY_INFO {}
15218 #[cfg(feature = "Win32_Foundation")]
15219 impl ::std::default::Default for CRYPT_PRIVATE_KEY_INFO {
default() -> Self15220     fn default() -> Self {
15221         unsafe { ::std::mem::zeroed() }
15222     }
15223 }
15224 #[cfg(feature = "Win32_Foundation")]
15225 impl ::std::fmt::Debug for CRYPT_PRIVATE_KEY_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15226     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15227         fmt.debug_struct("CRYPT_PRIVATE_KEY_INFO").field("Version", &self.Version).field("Algorithm", &self.Algorithm).field("PrivateKey", &self.PrivateKey).field("pAttributes", &self.pAttributes).finish()
15228     }
15229 }
15230 #[cfg(feature = "Win32_Foundation")]
15231 impl ::std::cmp::PartialEq for CRYPT_PRIVATE_KEY_INFO {
eq(&self, other: &Self) -> bool15232     fn eq(&self, other: &Self) -> bool {
15233         self.Version == other.Version && self.Algorithm == other.Algorithm && self.PrivateKey == other.PrivateKey && self.pAttributes == other.pAttributes
15234     }
15235 }
15236 #[cfg(feature = "Win32_Foundation")]
15237 impl ::std::cmp::Eq for CRYPT_PRIVATE_KEY_INFO {}
15238 #[cfg(feature = "Win32_Foundation")]
15239 unsafe impl ::windows::runtime::Abi for CRYPT_PRIVATE_KEY_INFO {
15240     type Abi = Self;
15241     type DefaultType = Self;
15242 }
15243 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15244 #[repr(C)]
15245 #[cfg(feature = "Win32_Foundation")]
15246 pub struct CRYPT_PROPERTY_REF {
15247     pub pszProperty: super::super::Foundation::PWSTR,
15248     pub cbValue: u32,
15249     pub pbValue: *mut u8,
15250 }
15251 #[cfg(feature = "Win32_Foundation")]
15252 impl CRYPT_PROPERTY_REF {}
15253 #[cfg(feature = "Win32_Foundation")]
15254 impl ::std::default::Default for CRYPT_PROPERTY_REF {
default() -> Self15255     fn default() -> Self {
15256         unsafe { ::std::mem::zeroed() }
15257     }
15258 }
15259 #[cfg(feature = "Win32_Foundation")]
15260 impl ::std::fmt::Debug for CRYPT_PROPERTY_REF {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15261     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15262         fmt.debug_struct("CRYPT_PROPERTY_REF").field("pszProperty", &self.pszProperty).field("cbValue", &self.cbValue).field("pbValue", &self.pbValue).finish()
15263     }
15264 }
15265 #[cfg(feature = "Win32_Foundation")]
15266 impl ::std::cmp::PartialEq for CRYPT_PROPERTY_REF {
eq(&self, other: &Self) -> bool15267     fn eq(&self, other: &Self) -> bool {
15268         self.pszProperty == other.pszProperty && self.cbValue == other.cbValue && self.pbValue == other.pbValue
15269     }
15270 }
15271 #[cfg(feature = "Win32_Foundation")]
15272 impl ::std::cmp::Eq for CRYPT_PROPERTY_REF {}
15273 #[cfg(feature = "Win32_Foundation")]
15274 unsafe impl ::windows::runtime::Abi for CRYPT_PROPERTY_REF {
15275     type Abi = Self;
15276     type DefaultType = Self;
15277 }
15278 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15279 #[repr(C)]
15280 #[cfg(feature = "Win32_Foundation")]
15281 pub struct CRYPT_PROVIDERS {
15282     pub cProviders: u32,
15283     pub rgpszProviders: *mut super::super::Foundation::PWSTR,
15284 }
15285 #[cfg(feature = "Win32_Foundation")]
15286 impl CRYPT_PROVIDERS {}
15287 #[cfg(feature = "Win32_Foundation")]
15288 impl ::std::default::Default for CRYPT_PROVIDERS {
default() -> Self15289     fn default() -> Self {
15290         unsafe { ::std::mem::zeroed() }
15291     }
15292 }
15293 #[cfg(feature = "Win32_Foundation")]
15294 impl ::std::fmt::Debug for CRYPT_PROVIDERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15295     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15296         fmt.debug_struct("CRYPT_PROVIDERS").field("cProviders", &self.cProviders).field("rgpszProviders", &self.rgpszProviders).finish()
15297     }
15298 }
15299 #[cfg(feature = "Win32_Foundation")]
15300 impl ::std::cmp::PartialEq for CRYPT_PROVIDERS {
eq(&self, other: &Self) -> bool15301     fn eq(&self, other: &Self) -> bool {
15302         self.cProviders == other.cProviders && self.rgpszProviders == other.rgpszProviders
15303     }
15304 }
15305 #[cfg(feature = "Win32_Foundation")]
15306 impl ::std::cmp::Eq for CRYPT_PROVIDERS {}
15307 #[cfg(feature = "Win32_Foundation")]
15308 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDERS {
15309     type Abi = Self;
15310     type DefaultType = Self;
15311 }
15312 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15313 #[repr(C)]
15314 #[cfg(feature = "Win32_Foundation")]
15315 pub struct CRYPT_PROVIDER_REF {
15316     pub dwInterface: u32,
15317     pub pszFunction: super::super::Foundation::PWSTR,
15318     pub pszProvider: super::super::Foundation::PWSTR,
15319     pub cProperties: u32,
15320     pub rgpProperties: *mut *mut CRYPT_PROPERTY_REF,
15321     pub pUM: *mut CRYPT_IMAGE_REF,
15322     pub pKM: *mut CRYPT_IMAGE_REF,
15323 }
15324 #[cfg(feature = "Win32_Foundation")]
15325 impl CRYPT_PROVIDER_REF {}
15326 #[cfg(feature = "Win32_Foundation")]
15327 impl ::std::default::Default for CRYPT_PROVIDER_REF {
default() -> Self15328     fn default() -> Self {
15329         unsafe { ::std::mem::zeroed() }
15330     }
15331 }
15332 #[cfg(feature = "Win32_Foundation")]
15333 impl ::std::fmt::Debug for CRYPT_PROVIDER_REF {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15334     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15335         fmt.debug_struct("CRYPT_PROVIDER_REF").field("dwInterface", &self.dwInterface).field("pszFunction", &self.pszFunction).field("pszProvider", &self.pszProvider).field("cProperties", &self.cProperties).field("rgpProperties", &self.rgpProperties).field("pUM", &self.pUM).field("pKM", &self.pKM).finish()
15336     }
15337 }
15338 #[cfg(feature = "Win32_Foundation")]
15339 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_REF {
eq(&self, other: &Self) -> bool15340     fn eq(&self, other: &Self) -> bool {
15341         self.dwInterface == other.dwInterface && self.pszFunction == other.pszFunction && self.pszProvider == other.pszProvider && self.cProperties == other.cProperties && self.rgpProperties == other.rgpProperties && self.pUM == other.pUM && self.pKM == other.pKM
15342     }
15343 }
15344 #[cfg(feature = "Win32_Foundation")]
15345 impl ::std::cmp::Eq for CRYPT_PROVIDER_REF {}
15346 #[cfg(feature = "Win32_Foundation")]
15347 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_REF {
15348     type Abi = Self;
15349     type DefaultType = Self;
15350 }
15351 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15352 #[repr(C)]
15353 #[cfg(feature = "Win32_Foundation")]
15354 pub struct CRYPT_PROVIDER_REFS {
15355     pub cProviders: u32,
15356     pub rgpProviders: *mut *mut CRYPT_PROVIDER_REF,
15357 }
15358 #[cfg(feature = "Win32_Foundation")]
15359 impl CRYPT_PROVIDER_REFS {}
15360 #[cfg(feature = "Win32_Foundation")]
15361 impl ::std::default::Default for CRYPT_PROVIDER_REFS {
default() -> Self15362     fn default() -> Self {
15363         unsafe { ::std::mem::zeroed() }
15364     }
15365 }
15366 #[cfg(feature = "Win32_Foundation")]
15367 impl ::std::fmt::Debug for CRYPT_PROVIDER_REFS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15368     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15369         fmt.debug_struct("CRYPT_PROVIDER_REFS").field("cProviders", &self.cProviders).field("rgpProviders", &self.rgpProviders).finish()
15370     }
15371 }
15372 #[cfg(feature = "Win32_Foundation")]
15373 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_REFS {
eq(&self, other: &Self) -> bool15374     fn eq(&self, other: &Self) -> bool {
15375         self.cProviders == other.cProviders && self.rgpProviders == other.rgpProviders
15376     }
15377 }
15378 #[cfg(feature = "Win32_Foundation")]
15379 impl ::std::cmp::Eq for CRYPT_PROVIDER_REFS {}
15380 #[cfg(feature = "Win32_Foundation")]
15381 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_REFS {
15382     type Abi = Self;
15383     type DefaultType = Self;
15384 }
15385 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15386 #[repr(C)]
15387 #[cfg(feature = "Win32_Foundation")]
15388 pub struct CRYPT_PROVIDER_REG {
15389     pub cAliases: u32,
15390     pub rgpszAliases: *mut super::super::Foundation::PWSTR,
15391     pub pUM: *mut CRYPT_IMAGE_REG,
15392     pub pKM: *mut CRYPT_IMAGE_REG,
15393 }
15394 #[cfg(feature = "Win32_Foundation")]
15395 impl CRYPT_PROVIDER_REG {}
15396 #[cfg(feature = "Win32_Foundation")]
15397 impl ::std::default::Default for CRYPT_PROVIDER_REG {
default() -> Self15398     fn default() -> Self {
15399         unsafe { ::std::mem::zeroed() }
15400     }
15401 }
15402 #[cfg(feature = "Win32_Foundation")]
15403 impl ::std::fmt::Debug for CRYPT_PROVIDER_REG {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15404     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15405         fmt.debug_struct("CRYPT_PROVIDER_REG").field("cAliases", &self.cAliases).field("rgpszAliases", &self.rgpszAliases).field("pUM", &self.pUM).field("pKM", &self.pKM).finish()
15406     }
15407 }
15408 #[cfg(feature = "Win32_Foundation")]
15409 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_REG {
eq(&self, other: &Self) -> bool15410     fn eq(&self, other: &Self) -> bool {
15411         self.cAliases == other.cAliases && self.rgpszAliases == other.rgpszAliases && self.pUM == other.pUM && self.pKM == other.pKM
15412     }
15413 }
15414 #[cfg(feature = "Win32_Foundation")]
15415 impl ::std::cmp::Eq for CRYPT_PROVIDER_REG {}
15416 #[cfg(feature = "Win32_Foundation")]
15417 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_REG {
15418     type Abi = Self;
15419     type DefaultType = Self;
15420 }
15421 pub const CRYPT_PROXY_CACHE_RETRIEVAL: u32 = 2097152u32;
15422 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15423 #[repr(C)]
15424 #[cfg(feature = "Win32_Foundation")]
15425 pub struct CRYPT_PSOURCE_ALGORITHM {
15426     pub pszObjId: super::super::Foundation::PSTR,
15427     pub EncodingParameters: CRYPTOAPI_BLOB,
15428 }
15429 #[cfg(feature = "Win32_Foundation")]
15430 impl CRYPT_PSOURCE_ALGORITHM {}
15431 #[cfg(feature = "Win32_Foundation")]
15432 impl ::std::default::Default for CRYPT_PSOURCE_ALGORITHM {
default() -> Self15433     fn default() -> Self {
15434         unsafe { ::std::mem::zeroed() }
15435     }
15436 }
15437 #[cfg(feature = "Win32_Foundation")]
15438 impl ::std::fmt::Debug for CRYPT_PSOURCE_ALGORITHM {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15439     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15440         fmt.debug_struct("CRYPT_PSOURCE_ALGORITHM").field("pszObjId", &self.pszObjId).field("EncodingParameters", &self.EncodingParameters).finish()
15441     }
15442 }
15443 #[cfg(feature = "Win32_Foundation")]
15444 impl ::std::cmp::PartialEq for CRYPT_PSOURCE_ALGORITHM {
eq(&self, other: &Self) -> bool15445     fn eq(&self, other: &Self) -> bool {
15446         self.pszObjId == other.pszObjId && self.EncodingParameters == other.EncodingParameters
15447     }
15448 }
15449 #[cfg(feature = "Win32_Foundation")]
15450 impl ::std::cmp::Eq for CRYPT_PSOURCE_ALGORITHM {}
15451 #[cfg(feature = "Win32_Foundation")]
15452 unsafe impl ::windows::runtime::Abi for CRYPT_PSOURCE_ALGORITHM {
15453     type Abi = Self;
15454     type DefaultType = Self;
15455 }
15456 pub const CRYPT_PSTORE: u32 = 2u32;
15457 pub const CRYPT_PUBKEY_ALG_OID_GROUP_ID: u32 = 3u32;
15458 pub const CRYPT_RANDOM_QUERY_STRING_RETRIEVAL: u32 = 67108864u32;
15459 pub const CRYPT_RC2_128BIT_VERSION: u32 = 58u32;
15460 pub const CRYPT_RC2_40BIT_VERSION: u32 = 160u32;
15461 pub const CRYPT_RC2_56BIT_VERSION: u32 = 52u32;
15462 pub const CRYPT_RC2_64BIT_VERSION: u32 = 120u32;
15463 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15464 #[repr(C)]
15465 #[cfg(feature = "Win32_Foundation")]
15466 pub struct CRYPT_RC2_CBC_PARAMETERS {
15467     pub dwVersion: u32,
15468     pub fIV: super::super::Foundation::BOOL,
15469     pub rgbIV: [u8; 8],
15470 }
15471 #[cfg(feature = "Win32_Foundation")]
15472 impl CRYPT_RC2_CBC_PARAMETERS {}
15473 #[cfg(feature = "Win32_Foundation")]
15474 impl ::std::default::Default for CRYPT_RC2_CBC_PARAMETERS {
default() -> Self15475     fn default() -> Self {
15476         unsafe { ::std::mem::zeroed() }
15477     }
15478 }
15479 #[cfg(feature = "Win32_Foundation")]
15480 impl ::std::fmt::Debug for CRYPT_RC2_CBC_PARAMETERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15481     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15482         fmt.debug_struct("CRYPT_RC2_CBC_PARAMETERS").field("dwVersion", &self.dwVersion).field("fIV", &self.fIV).field("rgbIV", &self.rgbIV).finish()
15483     }
15484 }
15485 #[cfg(feature = "Win32_Foundation")]
15486 impl ::std::cmp::PartialEq for CRYPT_RC2_CBC_PARAMETERS {
eq(&self, other: &Self) -> bool15487     fn eq(&self, other: &Self) -> bool {
15488         self.dwVersion == other.dwVersion && self.fIV == other.fIV && self.rgbIV == other.rgbIV
15489     }
15490 }
15491 #[cfg(feature = "Win32_Foundation")]
15492 impl ::std::cmp::Eq for CRYPT_RC2_CBC_PARAMETERS {}
15493 #[cfg(feature = "Win32_Foundation")]
15494 unsafe impl ::windows::runtime::Abi for CRYPT_RC2_CBC_PARAMETERS {
15495     type Abi = Self;
15496     type DefaultType = Self;
15497 }
15498 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15499 #[repr(C)]
15500 pub struct CRYPT_RC4_KEY_STATE {
15501     pub Key: [u8; 16],
15502     pub SBox: [u8; 256],
15503     pub i: u8,
15504     pub j: u8,
15505 }
15506 impl CRYPT_RC4_KEY_STATE {}
15507 impl ::std::default::Default for CRYPT_RC4_KEY_STATE {
default() -> Self15508     fn default() -> Self {
15509         unsafe { ::std::mem::zeroed() }
15510     }
15511 }
15512 impl ::std::fmt::Debug for CRYPT_RC4_KEY_STATE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15513     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15514         fmt.debug_struct("CRYPT_RC4_KEY_STATE").field("Key", &self.Key).field("SBox", &self.SBox).field("i", &self.i).field("j", &self.j).finish()
15515     }
15516 }
15517 impl ::std::cmp::PartialEq for CRYPT_RC4_KEY_STATE {
eq(&self, other: &Self) -> bool15518     fn eq(&self, other: &Self) -> bool {
15519         self.Key == other.Key && self.SBox == other.SBox && self.i == other.i && self.j == other.j
15520     }
15521 }
15522 impl ::std::cmp::Eq for CRYPT_RC4_KEY_STATE {}
15523 unsafe impl ::windows::runtime::Abi for CRYPT_RC4_KEY_STATE {
15524     type Abi = Self;
15525     type DefaultType = Self;
15526 }
15527 pub const CRYPT_RDN_ATTR_OID_GROUP_ID: u32 = 5u32;
15528 pub const CRYPT_READ: u32 = 8u32;
15529 pub const CRYPT_REGISTER_FIRST_INDEX: u32 = 0u32;
15530 pub const CRYPT_REGISTER_LAST_INDEX: u32 = 4294967295u32;
15531 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15532 #[repr(C)]
15533 #[cfg(feature = "Win32_Foundation")]
15534 pub struct CRYPT_RETRIEVE_AUX_INFO {
15535     pub cbSize: u32,
15536     pub pLastSyncTime: *mut super::super::Foundation::FILETIME,
15537     pub dwMaxUrlRetrievalByteCount: u32,
15538     pub pPreFetchInfo: *mut CRYPTNET_URL_CACHE_PRE_FETCH_INFO,
15539     pub pFlushInfo: *mut CRYPTNET_URL_CACHE_FLUSH_INFO,
15540     pub ppResponseInfo: *mut *mut CRYPTNET_URL_CACHE_RESPONSE_INFO,
15541     pub pwszCacheFileNamePrefix: super::super::Foundation::PWSTR,
15542     pub pftCacheResync: *mut super::super::Foundation::FILETIME,
15543     pub fProxyCacheRetrieval: super::super::Foundation::BOOL,
15544     pub dwHttpStatusCode: u32,
15545     pub ppwszErrorResponseHeaders: *mut super::super::Foundation::PWSTR,
15546     pub ppErrorContentBlob: *mut *mut CRYPTOAPI_BLOB,
15547 }
15548 #[cfg(feature = "Win32_Foundation")]
15549 impl CRYPT_RETRIEVE_AUX_INFO {}
15550 #[cfg(feature = "Win32_Foundation")]
15551 impl ::std::default::Default for CRYPT_RETRIEVE_AUX_INFO {
default() -> Self15552     fn default() -> Self {
15553         unsafe { ::std::mem::zeroed() }
15554     }
15555 }
15556 #[cfg(feature = "Win32_Foundation")]
15557 impl ::std::fmt::Debug for CRYPT_RETRIEVE_AUX_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15558     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15559         fmt.debug_struct("CRYPT_RETRIEVE_AUX_INFO")
15560             .field("cbSize", &self.cbSize)
15561             .field("pLastSyncTime", &self.pLastSyncTime)
15562             .field("dwMaxUrlRetrievalByteCount", &self.dwMaxUrlRetrievalByteCount)
15563             .field("pPreFetchInfo", &self.pPreFetchInfo)
15564             .field("pFlushInfo", &self.pFlushInfo)
15565             .field("ppResponseInfo", &self.ppResponseInfo)
15566             .field("pwszCacheFileNamePrefix", &self.pwszCacheFileNamePrefix)
15567             .field("pftCacheResync", &self.pftCacheResync)
15568             .field("fProxyCacheRetrieval", &self.fProxyCacheRetrieval)
15569             .field("dwHttpStatusCode", &self.dwHttpStatusCode)
15570             .field("ppwszErrorResponseHeaders", &self.ppwszErrorResponseHeaders)
15571             .field("ppErrorContentBlob", &self.ppErrorContentBlob)
15572             .finish()
15573     }
15574 }
15575 #[cfg(feature = "Win32_Foundation")]
15576 impl ::std::cmp::PartialEq for CRYPT_RETRIEVE_AUX_INFO {
eq(&self, other: &Self) -> bool15577     fn eq(&self, other: &Self) -> bool {
15578         self.cbSize == other.cbSize
15579             && self.pLastSyncTime == other.pLastSyncTime
15580             && self.dwMaxUrlRetrievalByteCount == other.dwMaxUrlRetrievalByteCount
15581             && self.pPreFetchInfo == other.pPreFetchInfo
15582             && self.pFlushInfo == other.pFlushInfo
15583             && self.ppResponseInfo == other.ppResponseInfo
15584             && self.pwszCacheFileNamePrefix == other.pwszCacheFileNamePrefix
15585             && self.pftCacheResync == other.pftCacheResync
15586             && self.fProxyCacheRetrieval == other.fProxyCacheRetrieval
15587             && self.dwHttpStatusCode == other.dwHttpStatusCode
15588             && self.ppwszErrorResponseHeaders == other.ppwszErrorResponseHeaders
15589             && self.ppErrorContentBlob == other.ppErrorContentBlob
15590     }
15591 }
15592 #[cfg(feature = "Win32_Foundation")]
15593 impl ::std::cmp::Eq for CRYPT_RETRIEVE_AUX_INFO {}
15594 #[cfg(feature = "Win32_Foundation")]
15595 unsafe impl ::windows::runtime::Abi for CRYPT_RETRIEVE_AUX_INFO {
15596     type Abi = Self;
15597     type DefaultType = Self;
15598 }
15599 pub const CRYPT_RETRIEVE_MAX_ERROR_CONTENT_LENGTH: u32 = 4096u32;
15600 pub const CRYPT_RETRIEVE_MULTIPLE_OBJECTS: u32 = 1u32;
15601 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15602 #[repr(C)]
15603 #[cfg(feature = "Win32_Foundation")]
15604 pub struct CRYPT_RSAES_OAEP_PARAMETERS {
15605     pub HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
15606     pub MaskGenAlgorithm: CRYPT_MASK_GEN_ALGORITHM,
15607     pub PSourceAlgorithm: CRYPT_PSOURCE_ALGORITHM,
15608 }
15609 #[cfg(feature = "Win32_Foundation")]
15610 impl CRYPT_RSAES_OAEP_PARAMETERS {}
15611 #[cfg(feature = "Win32_Foundation")]
15612 impl ::std::default::Default for CRYPT_RSAES_OAEP_PARAMETERS {
default() -> Self15613     fn default() -> Self {
15614         unsafe { ::std::mem::zeroed() }
15615     }
15616 }
15617 #[cfg(feature = "Win32_Foundation")]
15618 impl ::std::fmt::Debug for CRYPT_RSAES_OAEP_PARAMETERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15619     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15620         fmt.debug_struct("CRYPT_RSAES_OAEP_PARAMETERS").field("HashAlgorithm", &self.HashAlgorithm).field("MaskGenAlgorithm", &self.MaskGenAlgorithm).field("PSourceAlgorithm", &self.PSourceAlgorithm).finish()
15621     }
15622 }
15623 #[cfg(feature = "Win32_Foundation")]
15624 impl ::std::cmp::PartialEq for CRYPT_RSAES_OAEP_PARAMETERS {
eq(&self, other: &Self) -> bool15625     fn eq(&self, other: &Self) -> bool {
15626         self.HashAlgorithm == other.HashAlgorithm && self.MaskGenAlgorithm == other.MaskGenAlgorithm && self.PSourceAlgorithm == other.PSourceAlgorithm
15627     }
15628 }
15629 #[cfg(feature = "Win32_Foundation")]
15630 impl ::std::cmp::Eq for CRYPT_RSAES_OAEP_PARAMETERS {}
15631 #[cfg(feature = "Win32_Foundation")]
15632 unsafe impl ::windows::runtime::Abi for CRYPT_RSAES_OAEP_PARAMETERS {
15633     type Abi = Self;
15634     type DefaultType = Self;
15635 }
15636 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15637 #[repr(C)]
15638 #[cfg(feature = "Win32_Foundation")]
15639 pub struct CRYPT_RSA_SSA_PSS_PARAMETERS {
15640     pub HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
15641     pub MaskGenAlgorithm: CRYPT_MASK_GEN_ALGORITHM,
15642     pub dwSaltLength: u32,
15643     pub dwTrailerField: u32,
15644 }
15645 #[cfg(feature = "Win32_Foundation")]
15646 impl CRYPT_RSA_SSA_PSS_PARAMETERS {}
15647 #[cfg(feature = "Win32_Foundation")]
15648 impl ::std::default::Default for CRYPT_RSA_SSA_PSS_PARAMETERS {
default() -> Self15649     fn default() -> Self {
15650         unsafe { ::std::mem::zeroed() }
15651     }
15652 }
15653 #[cfg(feature = "Win32_Foundation")]
15654 impl ::std::fmt::Debug for CRYPT_RSA_SSA_PSS_PARAMETERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15655     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15656         fmt.debug_struct("CRYPT_RSA_SSA_PSS_PARAMETERS").field("HashAlgorithm", &self.HashAlgorithm).field("MaskGenAlgorithm", &self.MaskGenAlgorithm).field("dwSaltLength", &self.dwSaltLength).field("dwTrailerField", &self.dwTrailerField).finish()
15657     }
15658 }
15659 #[cfg(feature = "Win32_Foundation")]
15660 impl ::std::cmp::PartialEq for CRYPT_RSA_SSA_PSS_PARAMETERS {
eq(&self, other: &Self) -> bool15661     fn eq(&self, other: &Self) -> bool {
15662         self.HashAlgorithm == other.HashAlgorithm && self.MaskGenAlgorithm == other.MaskGenAlgorithm && self.dwSaltLength == other.dwSaltLength && self.dwTrailerField == other.dwTrailerField
15663     }
15664 }
15665 #[cfg(feature = "Win32_Foundation")]
15666 impl ::std::cmp::Eq for CRYPT_RSA_SSA_PSS_PARAMETERS {}
15667 #[cfg(feature = "Win32_Foundation")]
15668 unsafe impl ::windows::runtime::Abi for CRYPT_RSA_SSA_PSS_PARAMETERS {
15669     type Abi = Self;
15670     type DefaultType = Self;
15671 }
15672 pub const CRYPT_SECRETDIGEST: u32 = 1u32;
15673 pub const CRYPT_SEC_DESCR: u32 = 1u32;
15674 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15675 #[repr(C)]
15676 pub struct CRYPT_SEQUENCE_OF_ANY {
15677     pub cValue: u32,
15678     pub rgValue: *mut CRYPTOAPI_BLOB,
15679 }
15680 impl CRYPT_SEQUENCE_OF_ANY {}
15681 impl ::std::default::Default for CRYPT_SEQUENCE_OF_ANY {
default() -> Self15682     fn default() -> Self {
15683         unsafe { ::std::mem::zeroed() }
15684     }
15685 }
15686 impl ::std::fmt::Debug for CRYPT_SEQUENCE_OF_ANY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15687     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15688         fmt.debug_struct("CRYPT_SEQUENCE_OF_ANY").field("cValue", &self.cValue).field("rgValue", &self.rgValue).finish()
15689     }
15690 }
15691 impl ::std::cmp::PartialEq for CRYPT_SEQUENCE_OF_ANY {
eq(&self, other: &Self) -> bool15692     fn eq(&self, other: &Self) -> bool {
15693         self.cValue == other.cValue && self.rgValue == other.rgValue
15694     }
15695 }
15696 impl ::std::cmp::Eq for CRYPT_SEQUENCE_OF_ANY {}
15697 unsafe impl ::windows::runtime::Abi for CRYPT_SEQUENCE_OF_ANY {
15698     type Abi = Self;
15699     type DefaultType = Self;
15700 }
15701 pub const CRYPT_SERVER: u32 = 1024u32;
15702 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
15703 #[repr(transparent)]
15704 pub struct CRYPT_SET_HASH_PARAM(pub u32);
15705 pub const HP_HMAC_INFO: CRYPT_SET_HASH_PARAM = CRYPT_SET_HASH_PARAM(5u32);
15706 pub const HP_HASHVAL: CRYPT_SET_HASH_PARAM = CRYPT_SET_HASH_PARAM(2u32);
15707 impl ::std::convert::From<u32> for CRYPT_SET_HASH_PARAM {
from(value: u32) -> Self15708     fn from(value: u32) -> Self {
15709         Self(value)
15710     }
15711 }
15712 unsafe impl ::windows::runtime::Abi for CRYPT_SET_HASH_PARAM {
15713     type Abi = Self;
15714     type DefaultType = Self;
15715 }
15716 impl ::std::ops::BitOr for CRYPT_SET_HASH_PARAM {
15717     type Output = Self;
bitor(self, rhs: Self) -> Self15718     fn bitor(self, rhs: Self) -> Self {
15719         Self(self.0 | rhs.0)
15720     }
15721 }
15722 impl ::std::ops::BitAnd for CRYPT_SET_HASH_PARAM {
15723     type Output = Self;
bitand(self, rhs: Self) -> Self15724     fn bitand(self, rhs: Self) -> Self {
15725         Self(self.0 & rhs.0)
15726     }
15727 }
15728 impl ::std::ops::BitOrAssign for CRYPT_SET_HASH_PARAM {
bitor_assign(&mut self, rhs: Self)15729     fn bitor_assign(&mut self, rhs: Self) {
15730         self.0.bitor_assign(rhs.0)
15731     }
15732 }
15733 impl ::std::ops::BitAndAssign for CRYPT_SET_HASH_PARAM {
bitand_assign(&mut self, rhs: Self)15734     fn bitand_assign(&mut self, rhs: Self) {
15735         self.0.bitand_assign(rhs.0)
15736     }
15737 }
15738 impl ::std::ops::Not for CRYPT_SET_HASH_PARAM {
15739     type Output = Self;
not(self) -> Self15740     fn not(self) -> Self {
15741         Self(self.0.not())
15742     }
15743 }
15744 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
15745 #[repr(transparent)]
15746 pub struct CRYPT_SET_PROV_PARAM_ID(pub u32);
15747 pub const PP_CLIENT_HWND: CRYPT_SET_PROV_PARAM_ID = CRYPT_SET_PROV_PARAM_ID(1u32);
15748 pub const PP_DELETEKEY: CRYPT_SET_PROV_PARAM_ID = CRYPT_SET_PROV_PARAM_ID(24u32);
15749 pub const PP_KEYEXCHANGE_ALG: CRYPT_SET_PROV_PARAM_ID = CRYPT_SET_PROV_PARAM_ID(14u32);
15750 pub const PP_KEYEXCHANGE_PIN: CRYPT_SET_PROV_PARAM_ID = CRYPT_SET_PROV_PARAM_ID(32u32);
15751 pub const PP_KEYEXCHANGE_KEYSIZE: CRYPT_SET_PROV_PARAM_ID = CRYPT_SET_PROV_PARAM_ID(12u32);
15752 pub const PP_KEYSET_SEC_DESCR: CRYPT_SET_PROV_PARAM_ID = CRYPT_SET_PROV_PARAM_ID(8u32);
15753 pub const PP_PIN_PROMPT_STRING: CRYPT_SET_PROV_PARAM_ID = CRYPT_SET_PROV_PARAM_ID(44u32);
15754 pub const PP_ROOT_CERTSTORE: CRYPT_SET_PROV_PARAM_ID = CRYPT_SET_PROV_PARAM_ID(46u32);
15755 pub const PP_SIGNATURE_ALG: CRYPT_SET_PROV_PARAM_ID = CRYPT_SET_PROV_PARAM_ID(15u32);
15756 pub const PP_SIGNATURE_PIN: CRYPT_SET_PROV_PARAM_ID = CRYPT_SET_PROV_PARAM_ID(33u32);
15757 pub const PP_SIGNATURE_KEYSIZE: CRYPT_SET_PROV_PARAM_ID = CRYPT_SET_PROV_PARAM_ID(13u32);
15758 pub const PP_UI_PROMPT: CRYPT_SET_PROV_PARAM_ID = CRYPT_SET_PROV_PARAM_ID(21u32);
15759 pub const PP_USE_HARDWARE_RNG: CRYPT_SET_PROV_PARAM_ID = CRYPT_SET_PROV_PARAM_ID(38u32);
15760 pub const PP_USER_CERTSTORE: CRYPT_SET_PROV_PARAM_ID = CRYPT_SET_PROV_PARAM_ID(42u32);
15761 pub const PP_SECURE_KEYEXCHANGE_PIN: CRYPT_SET_PROV_PARAM_ID = CRYPT_SET_PROV_PARAM_ID(47u32);
15762 pub const PP_SECURE_SIGNATURE_PIN: CRYPT_SET_PROV_PARAM_ID = CRYPT_SET_PROV_PARAM_ID(48u32);
15763 pub const PP_SMARTCARD_READER: CRYPT_SET_PROV_PARAM_ID = CRYPT_SET_PROV_PARAM_ID(43u32);
15764 impl ::std::convert::From<u32> for CRYPT_SET_PROV_PARAM_ID {
from(value: u32) -> Self15765     fn from(value: u32) -> Self {
15766         Self(value)
15767     }
15768 }
15769 unsafe impl ::windows::runtime::Abi for CRYPT_SET_PROV_PARAM_ID {
15770     type Abi = Self;
15771     type DefaultType = Self;
15772 }
15773 impl ::std::ops::BitOr for CRYPT_SET_PROV_PARAM_ID {
15774     type Output = Self;
bitor(self, rhs: Self) -> Self15775     fn bitor(self, rhs: Self) -> Self {
15776         Self(self.0 | rhs.0)
15777     }
15778 }
15779 impl ::std::ops::BitAnd for CRYPT_SET_PROV_PARAM_ID {
15780     type Output = Self;
bitand(self, rhs: Self) -> Self15781     fn bitand(self, rhs: Self) -> Self {
15782         Self(self.0 & rhs.0)
15783     }
15784 }
15785 impl ::std::ops::BitOrAssign for CRYPT_SET_PROV_PARAM_ID {
bitor_assign(&mut self, rhs: Self)15786     fn bitor_assign(&mut self, rhs: Self) {
15787         self.0.bitor_assign(rhs.0)
15788     }
15789 }
15790 impl ::std::ops::BitAndAssign for CRYPT_SET_PROV_PARAM_ID {
bitand_assign(&mut self, rhs: Self)15791     fn bitand_assign(&mut self, rhs: Self) {
15792         self.0.bitand_assign(rhs.0)
15793     }
15794 }
15795 impl ::std::ops::Not for CRYPT_SET_PROV_PARAM_ID {
15796     type Output = Self;
not(self) -> Self15797     fn not(self) -> Self {
15798         Self(self.0.not())
15799     }
15800 }
15801 pub const CRYPT_SGC: u32 = 1u32;
15802 pub const CRYPT_SGC_ENUM: u32 = 4u32;
15803 pub const CRYPT_SIGN_ALG_OID_GROUP_ID: u32 = 4u32;
15804 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15805 #[repr(C)]
15806 #[cfg(feature = "Win32_Foundation")]
15807 pub struct CRYPT_SIGN_MESSAGE_PARA {
15808     pub cbSize: u32,
15809     pub dwMsgEncodingType: u32,
15810     pub pSigningCert: *mut CERT_CONTEXT,
15811     pub HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
15812     pub pvHashAuxInfo: *mut ::std::ffi::c_void,
15813     pub cMsgCert: u32,
15814     pub rgpMsgCert: *mut *mut CERT_CONTEXT,
15815     pub cMsgCrl: u32,
15816     pub rgpMsgCrl: *mut *mut CRL_CONTEXT,
15817     pub cAuthAttr: u32,
15818     pub rgAuthAttr: *mut CRYPT_ATTRIBUTE,
15819     pub cUnauthAttr: u32,
15820     pub rgUnauthAttr: *mut CRYPT_ATTRIBUTE,
15821     pub dwFlags: u32,
15822     pub dwInnerContentType: u32,
15823 }
15824 #[cfg(feature = "Win32_Foundation")]
15825 impl CRYPT_SIGN_MESSAGE_PARA {}
15826 #[cfg(feature = "Win32_Foundation")]
15827 impl ::std::default::Default for CRYPT_SIGN_MESSAGE_PARA {
default() -> Self15828     fn default() -> Self {
15829         unsafe { ::std::mem::zeroed() }
15830     }
15831 }
15832 #[cfg(feature = "Win32_Foundation")]
15833 impl ::std::fmt::Debug for CRYPT_SIGN_MESSAGE_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15834     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15835         fmt.debug_struct("CRYPT_SIGN_MESSAGE_PARA")
15836             .field("cbSize", &self.cbSize)
15837             .field("dwMsgEncodingType", &self.dwMsgEncodingType)
15838             .field("pSigningCert", &self.pSigningCert)
15839             .field("HashAlgorithm", &self.HashAlgorithm)
15840             .field("pvHashAuxInfo", &self.pvHashAuxInfo)
15841             .field("cMsgCert", &self.cMsgCert)
15842             .field("rgpMsgCert", &self.rgpMsgCert)
15843             .field("cMsgCrl", &self.cMsgCrl)
15844             .field("rgpMsgCrl", &self.rgpMsgCrl)
15845             .field("cAuthAttr", &self.cAuthAttr)
15846             .field("rgAuthAttr", &self.rgAuthAttr)
15847             .field("cUnauthAttr", &self.cUnauthAttr)
15848             .field("rgUnauthAttr", &self.rgUnauthAttr)
15849             .field("dwFlags", &self.dwFlags)
15850             .field("dwInnerContentType", &self.dwInnerContentType)
15851             .finish()
15852     }
15853 }
15854 #[cfg(feature = "Win32_Foundation")]
15855 impl ::std::cmp::PartialEq for CRYPT_SIGN_MESSAGE_PARA {
eq(&self, other: &Self) -> bool15856     fn eq(&self, other: &Self) -> bool {
15857         self.cbSize == other.cbSize
15858             && self.dwMsgEncodingType == other.dwMsgEncodingType
15859             && self.pSigningCert == other.pSigningCert
15860             && self.HashAlgorithm == other.HashAlgorithm
15861             && self.pvHashAuxInfo == other.pvHashAuxInfo
15862             && self.cMsgCert == other.cMsgCert
15863             && self.rgpMsgCert == other.rgpMsgCert
15864             && self.cMsgCrl == other.cMsgCrl
15865             && self.rgpMsgCrl == other.rgpMsgCrl
15866             && self.cAuthAttr == other.cAuthAttr
15867             && self.rgAuthAttr == other.rgAuthAttr
15868             && self.cUnauthAttr == other.cUnauthAttr
15869             && self.rgUnauthAttr == other.rgUnauthAttr
15870             && self.dwFlags == other.dwFlags
15871             && self.dwInnerContentType == other.dwInnerContentType
15872     }
15873 }
15874 #[cfg(feature = "Win32_Foundation")]
15875 impl ::std::cmp::Eq for CRYPT_SIGN_MESSAGE_PARA {}
15876 #[cfg(feature = "Win32_Foundation")]
15877 unsafe impl ::windows::runtime::Abi for CRYPT_SIGN_MESSAGE_PARA {
15878     type Abi = Self;
15879     type DefaultType = Self;
15880 }
15881 pub const CRYPT_SILENT: u32 = 64u32;
15882 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15883 #[repr(C)]
15884 pub struct CRYPT_SMART_CARD_ROOT_INFO {
15885     pub rgbCardID: [u8; 16],
15886     pub luid: ROOT_INFO_LUID,
15887 }
15888 impl CRYPT_SMART_CARD_ROOT_INFO {}
15889 impl ::std::default::Default for CRYPT_SMART_CARD_ROOT_INFO {
default() -> Self15890     fn default() -> Self {
15891         unsafe { ::std::mem::zeroed() }
15892     }
15893 }
15894 impl ::std::fmt::Debug for CRYPT_SMART_CARD_ROOT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15895     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15896         fmt.debug_struct("CRYPT_SMART_CARD_ROOT_INFO").field("rgbCardID", &self.rgbCardID).field("luid", &self.luid).finish()
15897     }
15898 }
15899 impl ::std::cmp::PartialEq for CRYPT_SMART_CARD_ROOT_INFO {
eq(&self, other: &Self) -> bool15900     fn eq(&self, other: &Self) -> bool {
15901         self.rgbCardID == other.rgbCardID && self.luid == other.luid
15902     }
15903 }
15904 impl ::std::cmp::Eq for CRYPT_SMART_CARD_ROOT_INFO {}
15905 unsafe impl ::windows::runtime::Abi for CRYPT_SMART_CARD_ROOT_INFO {
15906     type Abi = Self;
15907     type DefaultType = Self;
15908 }
15909 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15910 #[repr(C)]
15911 #[cfg(feature = "Win32_Foundation")]
15912 pub struct CRYPT_SMIME_CAPABILITIES {
15913     pub cCapability: u32,
15914     pub rgCapability: *mut CRYPT_SMIME_CAPABILITY,
15915 }
15916 #[cfg(feature = "Win32_Foundation")]
15917 impl CRYPT_SMIME_CAPABILITIES {}
15918 #[cfg(feature = "Win32_Foundation")]
15919 impl ::std::default::Default for CRYPT_SMIME_CAPABILITIES {
default() -> Self15920     fn default() -> Self {
15921         unsafe { ::std::mem::zeroed() }
15922     }
15923 }
15924 #[cfg(feature = "Win32_Foundation")]
15925 impl ::std::fmt::Debug for CRYPT_SMIME_CAPABILITIES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15926     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15927         fmt.debug_struct("CRYPT_SMIME_CAPABILITIES").field("cCapability", &self.cCapability).field("rgCapability", &self.rgCapability).finish()
15928     }
15929 }
15930 #[cfg(feature = "Win32_Foundation")]
15931 impl ::std::cmp::PartialEq for CRYPT_SMIME_CAPABILITIES {
eq(&self, other: &Self) -> bool15932     fn eq(&self, other: &Self) -> bool {
15933         self.cCapability == other.cCapability && self.rgCapability == other.rgCapability
15934     }
15935 }
15936 #[cfg(feature = "Win32_Foundation")]
15937 impl ::std::cmp::Eq for CRYPT_SMIME_CAPABILITIES {}
15938 #[cfg(feature = "Win32_Foundation")]
15939 unsafe impl ::windows::runtime::Abi for CRYPT_SMIME_CAPABILITIES {
15940     type Abi = Self;
15941     type DefaultType = Self;
15942 }
15943 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15944 #[repr(C)]
15945 #[cfg(feature = "Win32_Foundation")]
15946 pub struct CRYPT_SMIME_CAPABILITY {
15947     pub pszObjId: super::super::Foundation::PSTR,
15948     pub Parameters: CRYPTOAPI_BLOB,
15949 }
15950 #[cfg(feature = "Win32_Foundation")]
15951 impl CRYPT_SMIME_CAPABILITY {}
15952 #[cfg(feature = "Win32_Foundation")]
15953 impl ::std::default::Default for CRYPT_SMIME_CAPABILITY {
default() -> Self15954     fn default() -> Self {
15955         unsafe { ::std::mem::zeroed() }
15956     }
15957 }
15958 #[cfg(feature = "Win32_Foundation")]
15959 impl ::std::fmt::Debug for CRYPT_SMIME_CAPABILITY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result15960     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15961         fmt.debug_struct("CRYPT_SMIME_CAPABILITY").field("pszObjId", &self.pszObjId).field("Parameters", &self.Parameters).finish()
15962     }
15963 }
15964 #[cfg(feature = "Win32_Foundation")]
15965 impl ::std::cmp::PartialEq for CRYPT_SMIME_CAPABILITY {
eq(&self, other: &Self) -> bool15966     fn eq(&self, other: &Self) -> bool {
15967         self.pszObjId == other.pszObjId && self.Parameters == other.Parameters
15968     }
15969 }
15970 #[cfg(feature = "Win32_Foundation")]
15971 impl ::std::cmp::Eq for CRYPT_SMIME_CAPABILITY {}
15972 #[cfg(feature = "Win32_Foundation")]
15973 unsafe impl ::windows::runtime::Abi for CRYPT_SMIME_CAPABILITY {
15974     type Abi = Self;
15975     type DefaultType = Self;
15976 }
15977 pub const CRYPT_SORTED_CTL_ENCODE_HASHED_SUBJECT_IDENTIFIER_FLAG: u32 = 65536u32;
15978 pub const CRYPT_STICKY_CACHE_RETRIEVAL: u32 = 4096u32;
15979 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
15980 #[repr(transparent)]
15981 pub struct CRYPT_STRING(pub u32);
15982 pub const CRYPT_STRING_BASE64HEADER: CRYPT_STRING = CRYPT_STRING(0u32);
15983 pub const CRYPT_STRING_BASE64: CRYPT_STRING = CRYPT_STRING(1u32);
15984 pub const CRYPT_STRING_BINARY: CRYPT_STRING = CRYPT_STRING(2u32);
15985 pub const CRYPT_STRING_BASE64REQUESTHEADER: CRYPT_STRING = CRYPT_STRING(3u32);
15986 pub const CRYPT_STRING_HEX: CRYPT_STRING = CRYPT_STRING(4u32);
15987 pub const CRYPT_STRING_HEXASCII: CRYPT_STRING = CRYPT_STRING(5u32);
15988 pub const CRYPT_STRING_BASE64X509CRLHEADER: CRYPT_STRING = CRYPT_STRING(9u32);
15989 pub const CRYPT_STRING_HEXADDR: CRYPT_STRING = CRYPT_STRING(10u32);
15990 pub const CRYPT_STRING_HEXASCIIADDR: CRYPT_STRING = CRYPT_STRING(11u32);
15991 pub const CRYPT_STRING_HEXRAW: CRYPT_STRING = CRYPT_STRING(12u32);
15992 pub const CRYPT_STRING_STRICT: CRYPT_STRING = CRYPT_STRING(536870912u32);
15993 pub const CRYPT_STRING_BASE64_ANY: CRYPT_STRING = CRYPT_STRING(6u32);
15994 pub const CRYPT_STRING_ANY: CRYPT_STRING = CRYPT_STRING(7u32);
15995 pub const CRYPT_STRING_HEX_ANY: CRYPT_STRING = CRYPT_STRING(8u32);
15996 impl ::std::convert::From<u32> for CRYPT_STRING {
from(value: u32) -> Self15997     fn from(value: u32) -> Self {
15998         Self(value)
15999     }
16000 }
16001 unsafe impl ::windows::runtime::Abi for CRYPT_STRING {
16002     type Abi = Self;
16003     type DefaultType = Self;
16004 }
16005 impl ::std::ops::BitOr for CRYPT_STRING {
16006     type Output = Self;
bitor(self, rhs: Self) -> Self16007     fn bitor(self, rhs: Self) -> Self {
16008         Self(self.0 | rhs.0)
16009     }
16010 }
16011 impl ::std::ops::BitAnd for CRYPT_STRING {
16012     type Output = Self;
bitand(self, rhs: Self) -> Self16013     fn bitand(self, rhs: Self) -> Self {
16014         Self(self.0 & rhs.0)
16015     }
16016 }
16017 impl ::std::ops::BitOrAssign for CRYPT_STRING {
bitor_assign(&mut self, rhs: Self)16018     fn bitor_assign(&mut self, rhs: Self) {
16019         self.0.bitor_assign(rhs.0)
16020     }
16021 }
16022 impl ::std::ops::BitAndAssign for CRYPT_STRING {
bitand_assign(&mut self, rhs: Self)16023     fn bitand_assign(&mut self, rhs: Self) {
16024         self.0.bitand_assign(rhs.0)
16025     }
16026 }
16027 impl ::std::ops::Not for CRYPT_STRING {
16028     type Output = Self;
not(self) -> Self16029     fn not(self) -> Self {
16030         Self(self.0.not())
16031     }
16032 }
16033 pub const CRYPT_STRING_BASE64URI: u32 = 13u32;
16034 pub const CRYPT_STRING_ENCODEMASK: u32 = 255u32;
16035 pub const CRYPT_STRING_HASHDATA: u32 = 268435456u32;
16036 pub const CRYPT_STRING_NOCR: u32 = 2147483648u32;
16037 pub const CRYPT_STRING_NOCRLF: u32 = 1073741824u32;
16038 pub const CRYPT_STRING_PERCENTESCAPE: u32 = 134217728u32;
16039 pub const CRYPT_STRING_RESERVED100: u32 = 256u32;
16040 pub const CRYPT_STRING_RESERVED200: u32 = 512u32;
16041 pub const CRYPT_SUCCEED: u32 = 1u32;
16042 pub const CRYPT_TEMPLATE_OID_GROUP_ID: u32 = 9u32;
16043 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16044 #[repr(C)]
16045 pub struct CRYPT_TIMESTAMP_ACCURACY {
16046     pub dwSeconds: u32,
16047     pub dwMillis: u32,
16048     pub dwMicros: u32,
16049 }
16050 impl CRYPT_TIMESTAMP_ACCURACY {}
16051 impl ::std::default::Default for CRYPT_TIMESTAMP_ACCURACY {
default() -> Self16052     fn default() -> Self {
16053         unsafe { ::std::mem::zeroed() }
16054     }
16055 }
16056 impl ::std::fmt::Debug for CRYPT_TIMESTAMP_ACCURACY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16057     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16058         fmt.debug_struct("CRYPT_TIMESTAMP_ACCURACY").field("dwSeconds", &self.dwSeconds).field("dwMillis", &self.dwMillis).field("dwMicros", &self.dwMicros).finish()
16059     }
16060 }
16061 impl ::std::cmp::PartialEq for CRYPT_TIMESTAMP_ACCURACY {
eq(&self, other: &Self) -> bool16062     fn eq(&self, other: &Self) -> bool {
16063         self.dwSeconds == other.dwSeconds && self.dwMillis == other.dwMillis && self.dwMicros == other.dwMicros
16064     }
16065 }
16066 impl ::std::cmp::Eq for CRYPT_TIMESTAMP_ACCURACY {}
16067 unsafe impl ::windows::runtime::Abi for CRYPT_TIMESTAMP_ACCURACY {
16068     type Abi = Self;
16069     type DefaultType = Self;
16070 }
16071 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16072 #[repr(C)]
16073 #[cfg(feature = "Win32_Foundation")]
16074 pub struct CRYPT_TIMESTAMP_CONTEXT {
16075     pub cbEncoded: u32,
16076     pub pbEncoded: *mut u8,
16077     pub pTimeStamp: *mut CRYPT_TIMESTAMP_INFO,
16078 }
16079 #[cfg(feature = "Win32_Foundation")]
16080 impl CRYPT_TIMESTAMP_CONTEXT {}
16081 #[cfg(feature = "Win32_Foundation")]
16082 impl ::std::default::Default for CRYPT_TIMESTAMP_CONTEXT {
default() -> Self16083     fn default() -> Self {
16084         unsafe { ::std::mem::zeroed() }
16085     }
16086 }
16087 #[cfg(feature = "Win32_Foundation")]
16088 impl ::std::fmt::Debug for CRYPT_TIMESTAMP_CONTEXT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16089     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16090         fmt.debug_struct("CRYPT_TIMESTAMP_CONTEXT").field("cbEncoded", &self.cbEncoded).field("pbEncoded", &self.pbEncoded).field("pTimeStamp", &self.pTimeStamp).finish()
16091     }
16092 }
16093 #[cfg(feature = "Win32_Foundation")]
16094 impl ::std::cmp::PartialEq for CRYPT_TIMESTAMP_CONTEXT {
eq(&self, other: &Self) -> bool16095     fn eq(&self, other: &Self) -> bool {
16096         self.cbEncoded == other.cbEncoded && self.pbEncoded == other.pbEncoded && self.pTimeStamp == other.pTimeStamp
16097     }
16098 }
16099 #[cfg(feature = "Win32_Foundation")]
16100 impl ::std::cmp::Eq for CRYPT_TIMESTAMP_CONTEXT {}
16101 #[cfg(feature = "Win32_Foundation")]
16102 unsafe impl ::windows::runtime::Abi for CRYPT_TIMESTAMP_CONTEXT {
16103     type Abi = Self;
16104     type DefaultType = Self;
16105 }
16106 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16107 #[repr(C)]
16108 #[cfg(feature = "Win32_Foundation")]
16109 pub struct CRYPT_TIMESTAMP_INFO {
16110     pub dwVersion: u32,
16111     pub pszTSAPolicyId: super::super::Foundation::PSTR,
16112     pub HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
16113     pub HashedMessage: CRYPTOAPI_BLOB,
16114     pub SerialNumber: CRYPTOAPI_BLOB,
16115     pub ftTime: super::super::Foundation::FILETIME,
16116     pub pvAccuracy: *mut CRYPT_TIMESTAMP_ACCURACY,
16117     pub fOrdering: super::super::Foundation::BOOL,
16118     pub Nonce: CRYPTOAPI_BLOB,
16119     pub Tsa: CRYPTOAPI_BLOB,
16120     pub cExtension: u32,
16121     pub rgExtension: *mut CERT_EXTENSION,
16122 }
16123 #[cfg(feature = "Win32_Foundation")]
16124 impl CRYPT_TIMESTAMP_INFO {}
16125 #[cfg(feature = "Win32_Foundation")]
16126 impl ::std::default::Default for CRYPT_TIMESTAMP_INFO {
default() -> Self16127     fn default() -> Self {
16128         unsafe { ::std::mem::zeroed() }
16129     }
16130 }
16131 #[cfg(feature = "Win32_Foundation")]
16132 impl ::std::fmt::Debug for CRYPT_TIMESTAMP_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16133     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16134         fmt.debug_struct("CRYPT_TIMESTAMP_INFO")
16135             .field("dwVersion", &self.dwVersion)
16136             .field("pszTSAPolicyId", &self.pszTSAPolicyId)
16137             .field("HashAlgorithm", &self.HashAlgorithm)
16138             .field("HashedMessage", &self.HashedMessage)
16139             .field("SerialNumber", &self.SerialNumber)
16140             .field("ftTime", &self.ftTime)
16141             .field("pvAccuracy", &self.pvAccuracy)
16142             .field("fOrdering", &self.fOrdering)
16143             .field("Nonce", &self.Nonce)
16144             .field("Tsa", &self.Tsa)
16145             .field("cExtension", &self.cExtension)
16146             .field("rgExtension", &self.rgExtension)
16147             .finish()
16148     }
16149 }
16150 #[cfg(feature = "Win32_Foundation")]
16151 impl ::std::cmp::PartialEq for CRYPT_TIMESTAMP_INFO {
eq(&self, other: &Self) -> bool16152     fn eq(&self, other: &Self) -> bool {
16153         self.dwVersion == other.dwVersion && self.pszTSAPolicyId == other.pszTSAPolicyId && self.HashAlgorithm == other.HashAlgorithm && self.HashedMessage == other.HashedMessage && self.SerialNumber == other.SerialNumber && self.ftTime == other.ftTime && self.pvAccuracy == other.pvAccuracy && self.fOrdering == other.fOrdering && self.Nonce == other.Nonce && self.Tsa == other.Tsa && self.cExtension == other.cExtension && self.rgExtension == other.rgExtension
16154     }
16155 }
16156 #[cfg(feature = "Win32_Foundation")]
16157 impl ::std::cmp::Eq for CRYPT_TIMESTAMP_INFO {}
16158 #[cfg(feature = "Win32_Foundation")]
16159 unsafe impl ::windows::runtime::Abi for CRYPT_TIMESTAMP_INFO {
16160     type Abi = Self;
16161     type DefaultType = Self;
16162 }
16163 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16164 #[repr(C)]
16165 #[cfg(feature = "Win32_Foundation")]
16166 pub struct CRYPT_TIMESTAMP_PARA {
16167     pub pszTSAPolicyId: super::super::Foundation::PSTR,
16168     pub fRequestCerts: super::super::Foundation::BOOL,
16169     pub Nonce: CRYPTOAPI_BLOB,
16170     pub cExtension: u32,
16171     pub rgExtension: *mut CERT_EXTENSION,
16172 }
16173 #[cfg(feature = "Win32_Foundation")]
16174 impl CRYPT_TIMESTAMP_PARA {}
16175 #[cfg(feature = "Win32_Foundation")]
16176 impl ::std::default::Default for CRYPT_TIMESTAMP_PARA {
default() -> Self16177     fn default() -> Self {
16178         unsafe { ::std::mem::zeroed() }
16179     }
16180 }
16181 #[cfg(feature = "Win32_Foundation")]
16182 impl ::std::fmt::Debug for CRYPT_TIMESTAMP_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16183     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16184         fmt.debug_struct("CRYPT_TIMESTAMP_PARA").field("pszTSAPolicyId", &self.pszTSAPolicyId).field("fRequestCerts", &self.fRequestCerts).field("Nonce", &self.Nonce).field("cExtension", &self.cExtension).field("rgExtension", &self.rgExtension).finish()
16185     }
16186 }
16187 #[cfg(feature = "Win32_Foundation")]
16188 impl ::std::cmp::PartialEq for CRYPT_TIMESTAMP_PARA {
eq(&self, other: &Self) -> bool16189     fn eq(&self, other: &Self) -> bool {
16190         self.pszTSAPolicyId == other.pszTSAPolicyId && self.fRequestCerts == other.fRequestCerts && self.Nonce == other.Nonce && self.cExtension == other.cExtension && self.rgExtension == other.rgExtension
16191     }
16192 }
16193 #[cfg(feature = "Win32_Foundation")]
16194 impl ::std::cmp::Eq for CRYPT_TIMESTAMP_PARA {}
16195 #[cfg(feature = "Win32_Foundation")]
16196 unsafe impl ::windows::runtime::Abi for CRYPT_TIMESTAMP_PARA {
16197     type Abi = Self;
16198     type DefaultType = Self;
16199 }
16200 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16201 #[repr(C)]
16202 #[cfg(feature = "Win32_Foundation")]
16203 pub struct CRYPT_TIMESTAMP_REQUEST {
16204     pub dwVersion: CRYPT_TIMESTAMP_VERSION,
16205     pub HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
16206     pub HashedMessage: CRYPTOAPI_BLOB,
16207     pub pszTSAPolicyId: super::super::Foundation::PSTR,
16208     pub Nonce: CRYPTOAPI_BLOB,
16209     pub fCertReq: super::super::Foundation::BOOL,
16210     pub cExtension: u32,
16211     pub rgExtension: *mut CERT_EXTENSION,
16212 }
16213 #[cfg(feature = "Win32_Foundation")]
16214 impl CRYPT_TIMESTAMP_REQUEST {}
16215 #[cfg(feature = "Win32_Foundation")]
16216 impl ::std::default::Default for CRYPT_TIMESTAMP_REQUEST {
default() -> Self16217     fn default() -> Self {
16218         unsafe { ::std::mem::zeroed() }
16219     }
16220 }
16221 #[cfg(feature = "Win32_Foundation")]
16222 impl ::std::fmt::Debug for CRYPT_TIMESTAMP_REQUEST {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16223     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16224         fmt.debug_struct("CRYPT_TIMESTAMP_REQUEST")
16225             .field("dwVersion", &self.dwVersion)
16226             .field("HashAlgorithm", &self.HashAlgorithm)
16227             .field("HashedMessage", &self.HashedMessage)
16228             .field("pszTSAPolicyId", &self.pszTSAPolicyId)
16229             .field("Nonce", &self.Nonce)
16230             .field("fCertReq", &self.fCertReq)
16231             .field("cExtension", &self.cExtension)
16232             .field("rgExtension", &self.rgExtension)
16233             .finish()
16234     }
16235 }
16236 #[cfg(feature = "Win32_Foundation")]
16237 impl ::std::cmp::PartialEq for CRYPT_TIMESTAMP_REQUEST {
eq(&self, other: &Self) -> bool16238     fn eq(&self, other: &Self) -> bool {
16239         self.dwVersion == other.dwVersion && self.HashAlgorithm == other.HashAlgorithm && self.HashedMessage == other.HashedMessage && self.pszTSAPolicyId == other.pszTSAPolicyId && self.Nonce == other.Nonce && self.fCertReq == other.fCertReq && self.cExtension == other.cExtension && self.rgExtension == other.rgExtension
16240     }
16241 }
16242 #[cfg(feature = "Win32_Foundation")]
16243 impl ::std::cmp::Eq for CRYPT_TIMESTAMP_REQUEST {}
16244 #[cfg(feature = "Win32_Foundation")]
16245 unsafe impl ::windows::runtime::Abi for CRYPT_TIMESTAMP_REQUEST {
16246     type Abi = Self;
16247     type DefaultType = Self;
16248 }
16249 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16250 #[repr(C)]
16251 #[cfg(feature = "Win32_Foundation")]
16252 pub struct CRYPT_TIMESTAMP_RESPONSE {
16253     pub dwStatus: CRYPT_TIMESTAMP_RESPONSE_STATUS,
16254     pub cFreeText: u32,
16255     pub rgFreeText: *mut super::super::Foundation::PWSTR,
16256     pub FailureInfo: CRYPT_BIT_BLOB,
16257     pub ContentInfo: CRYPTOAPI_BLOB,
16258 }
16259 #[cfg(feature = "Win32_Foundation")]
16260 impl CRYPT_TIMESTAMP_RESPONSE {}
16261 #[cfg(feature = "Win32_Foundation")]
16262 impl ::std::default::Default for CRYPT_TIMESTAMP_RESPONSE {
default() -> Self16263     fn default() -> Self {
16264         unsafe { ::std::mem::zeroed() }
16265     }
16266 }
16267 #[cfg(feature = "Win32_Foundation")]
16268 impl ::std::fmt::Debug for CRYPT_TIMESTAMP_RESPONSE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16269     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16270         fmt.debug_struct("CRYPT_TIMESTAMP_RESPONSE").field("dwStatus", &self.dwStatus).field("cFreeText", &self.cFreeText).field("rgFreeText", &self.rgFreeText).field("FailureInfo", &self.FailureInfo).field("ContentInfo", &self.ContentInfo).finish()
16271     }
16272 }
16273 #[cfg(feature = "Win32_Foundation")]
16274 impl ::std::cmp::PartialEq for CRYPT_TIMESTAMP_RESPONSE {
eq(&self, other: &Self) -> bool16275     fn eq(&self, other: &Self) -> bool {
16276         self.dwStatus == other.dwStatus && self.cFreeText == other.cFreeText && self.rgFreeText == other.rgFreeText && self.FailureInfo == other.FailureInfo && self.ContentInfo == other.ContentInfo
16277     }
16278 }
16279 #[cfg(feature = "Win32_Foundation")]
16280 impl ::std::cmp::Eq for CRYPT_TIMESTAMP_RESPONSE {}
16281 #[cfg(feature = "Win32_Foundation")]
16282 unsafe impl ::windows::runtime::Abi for CRYPT_TIMESTAMP_RESPONSE {
16283     type Abi = Self;
16284     type DefaultType = Self;
16285 }
16286 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
16287 #[repr(transparent)]
16288 pub struct CRYPT_TIMESTAMP_RESPONSE_STATUS(pub u32);
16289 pub const TIMESTAMP_STATUS_GRANTED: CRYPT_TIMESTAMP_RESPONSE_STATUS = CRYPT_TIMESTAMP_RESPONSE_STATUS(0u32);
16290 pub const TIMESTAMP_STATUS_GRANTED_WITH_MODS: CRYPT_TIMESTAMP_RESPONSE_STATUS = CRYPT_TIMESTAMP_RESPONSE_STATUS(1u32);
16291 pub const TIMESTAMP_STATUS_REJECTED: CRYPT_TIMESTAMP_RESPONSE_STATUS = CRYPT_TIMESTAMP_RESPONSE_STATUS(2u32);
16292 pub const TIMESTAMP_STATUS_WAITING: CRYPT_TIMESTAMP_RESPONSE_STATUS = CRYPT_TIMESTAMP_RESPONSE_STATUS(3u32);
16293 pub const TIMESTAMP_STATUS_REVOCATION_WARNING: CRYPT_TIMESTAMP_RESPONSE_STATUS = CRYPT_TIMESTAMP_RESPONSE_STATUS(4u32);
16294 pub const TIMESTAMP_STATUS_REVOKED: CRYPT_TIMESTAMP_RESPONSE_STATUS = CRYPT_TIMESTAMP_RESPONSE_STATUS(5u32);
16295 impl ::std::convert::From<u32> for CRYPT_TIMESTAMP_RESPONSE_STATUS {
from(value: u32) -> Self16296     fn from(value: u32) -> Self {
16297         Self(value)
16298     }
16299 }
16300 unsafe impl ::windows::runtime::Abi for CRYPT_TIMESTAMP_RESPONSE_STATUS {
16301     type Abi = Self;
16302     type DefaultType = Self;
16303 }
16304 impl ::std::ops::BitOr for CRYPT_TIMESTAMP_RESPONSE_STATUS {
16305     type Output = Self;
bitor(self, rhs: Self) -> Self16306     fn bitor(self, rhs: Self) -> Self {
16307         Self(self.0 | rhs.0)
16308     }
16309 }
16310 impl ::std::ops::BitAnd for CRYPT_TIMESTAMP_RESPONSE_STATUS {
16311     type Output = Self;
bitand(self, rhs: Self) -> Self16312     fn bitand(self, rhs: Self) -> Self {
16313         Self(self.0 & rhs.0)
16314     }
16315 }
16316 impl ::std::ops::BitOrAssign for CRYPT_TIMESTAMP_RESPONSE_STATUS {
bitor_assign(&mut self, rhs: Self)16317     fn bitor_assign(&mut self, rhs: Self) {
16318         self.0.bitor_assign(rhs.0)
16319     }
16320 }
16321 impl ::std::ops::BitAndAssign for CRYPT_TIMESTAMP_RESPONSE_STATUS {
bitand_assign(&mut self, rhs: Self)16322     fn bitand_assign(&mut self, rhs: Self) {
16323         self.0.bitand_assign(rhs.0)
16324     }
16325 }
16326 impl ::std::ops::Not for CRYPT_TIMESTAMP_RESPONSE_STATUS {
16327     type Output = Self;
not(self) -> Self16328     fn not(self) -> Self {
16329         Self(self.0.not())
16330     }
16331 }
16332 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
16333 #[repr(transparent)]
16334 pub struct CRYPT_TIMESTAMP_VERSION(pub u32);
16335 pub const TIMESTAMP_VERSION: CRYPT_TIMESTAMP_VERSION = CRYPT_TIMESTAMP_VERSION(1u32);
16336 impl ::std::convert::From<u32> for CRYPT_TIMESTAMP_VERSION {
from(value: u32) -> Self16337     fn from(value: u32) -> Self {
16338         Self(value)
16339     }
16340 }
16341 unsafe impl ::windows::runtime::Abi for CRYPT_TIMESTAMP_VERSION {
16342     type Abi = Self;
16343     type DefaultType = Self;
16344 }
16345 impl ::std::ops::BitOr for CRYPT_TIMESTAMP_VERSION {
16346     type Output = Self;
bitor(self, rhs: Self) -> Self16347     fn bitor(self, rhs: Self) -> Self {
16348         Self(self.0 | rhs.0)
16349     }
16350 }
16351 impl ::std::ops::BitAnd for CRYPT_TIMESTAMP_VERSION {
16352     type Output = Self;
bitand(self, rhs: Self) -> Self16353     fn bitand(self, rhs: Self) -> Self {
16354         Self(self.0 & rhs.0)
16355     }
16356 }
16357 impl ::std::ops::BitOrAssign for CRYPT_TIMESTAMP_VERSION {
bitor_assign(&mut self, rhs: Self)16358     fn bitor_assign(&mut self, rhs: Self) {
16359         self.0.bitor_assign(rhs.0)
16360     }
16361 }
16362 impl ::std::ops::BitAndAssign for CRYPT_TIMESTAMP_VERSION {
bitand_assign(&mut self, rhs: Self)16363     fn bitand_assign(&mut self, rhs: Self) {
16364         self.0.bitand_assign(rhs.0)
16365     }
16366 }
16367 impl ::std::ops::Not for CRYPT_TIMESTAMP_VERSION {
16368     type Output = Self;
not(self) -> Self16369     fn not(self) -> Self {
16370         Self(self.0.not())
16371     }
16372 }
16373 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16374 #[repr(C)]
16375 #[cfg(feature = "Win32_Foundation")]
16376 pub struct CRYPT_TIME_STAMP_REQUEST_INFO {
16377     pub pszTimeStampAlgorithm: super::super::Foundation::PSTR,
16378     pub pszContentType: super::super::Foundation::PSTR,
16379     pub Content: CRYPTOAPI_BLOB,
16380     pub cAttribute: u32,
16381     pub rgAttribute: *mut CRYPT_ATTRIBUTE,
16382 }
16383 #[cfg(feature = "Win32_Foundation")]
16384 impl CRYPT_TIME_STAMP_REQUEST_INFO {}
16385 #[cfg(feature = "Win32_Foundation")]
16386 impl ::std::default::Default for CRYPT_TIME_STAMP_REQUEST_INFO {
default() -> Self16387     fn default() -> Self {
16388         unsafe { ::std::mem::zeroed() }
16389     }
16390 }
16391 #[cfg(feature = "Win32_Foundation")]
16392 impl ::std::fmt::Debug for CRYPT_TIME_STAMP_REQUEST_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16393     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16394         fmt.debug_struct("CRYPT_TIME_STAMP_REQUEST_INFO").field("pszTimeStampAlgorithm", &self.pszTimeStampAlgorithm).field("pszContentType", &self.pszContentType).field("Content", &self.Content).field("cAttribute", &self.cAttribute).field("rgAttribute", &self.rgAttribute).finish()
16395     }
16396 }
16397 #[cfg(feature = "Win32_Foundation")]
16398 impl ::std::cmp::PartialEq for CRYPT_TIME_STAMP_REQUEST_INFO {
eq(&self, other: &Self) -> bool16399     fn eq(&self, other: &Self) -> bool {
16400         self.pszTimeStampAlgorithm == other.pszTimeStampAlgorithm && self.pszContentType == other.pszContentType && self.Content == other.Content && self.cAttribute == other.cAttribute && self.rgAttribute == other.rgAttribute
16401     }
16402 }
16403 #[cfg(feature = "Win32_Foundation")]
16404 impl ::std::cmp::Eq for CRYPT_TIME_STAMP_REQUEST_INFO {}
16405 #[cfg(feature = "Win32_Foundation")]
16406 unsafe impl ::windows::runtime::Abi for CRYPT_TIME_STAMP_REQUEST_INFO {
16407     type Abi = Self;
16408     type DefaultType = Self;
16409 }
16410 pub const CRYPT_TYPE2_FORMAT: u32 = 2u32;
16411 pub const CRYPT_UI_PROMPT: u32 = 4u32;
16412 pub const CRYPT_UNICODE_NAME_DECODE_DISABLE_IE4_UTF8_FLAG: u32 = 16777216u32;
16413 pub const CRYPT_UNICODE_NAME_ENCODE_FORCE_UTF8_UNICODE_FLAG: u32 = 268435456u32;
16414 pub const CRYPT_UPDATE_KEY: u32 = 8u32;
16415 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16416 #[repr(C)]
16417 #[cfg(feature = "Win32_Foundation")]
16418 pub struct CRYPT_URL_ARRAY {
16419     pub cUrl: u32,
16420     pub rgwszUrl: *mut super::super::Foundation::PWSTR,
16421 }
16422 #[cfg(feature = "Win32_Foundation")]
16423 impl CRYPT_URL_ARRAY {}
16424 #[cfg(feature = "Win32_Foundation")]
16425 impl ::std::default::Default for CRYPT_URL_ARRAY {
default() -> Self16426     fn default() -> Self {
16427         unsafe { ::std::mem::zeroed() }
16428     }
16429 }
16430 #[cfg(feature = "Win32_Foundation")]
16431 impl ::std::fmt::Debug for CRYPT_URL_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16432     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16433         fmt.debug_struct("CRYPT_URL_ARRAY").field("cUrl", &self.cUrl).field("rgwszUrl", &self.rgwszUrl).finish()
16434     }
16435 }
16436 #[cfg(feature = "Win32_Foundation")]
16437 impl ::std::cmp::PartialEq for CRYPT_URL_ARRAY {
eq(&self, other: &Self) -> bool16438     fn eq(&self, other: &Self) -> bool {
16439         self.cUrl == other.cUrl && self.rgwszUrl == other.rgwszUrl
16440     }
16441 }
16442 #[cfg(feature = "Win32_Foundation")]
16443 impl ::std::cmp::Eq for CRYPT_URL_ARRAY {}
16444 #[cfg(feature = "Win32_Foundation")]
16445 unsafe impl ::windows::runtime::Abi for CRYPT_URL_ARRAY {
16446     type Abi = Self;
16447     type DefaultType = Self;
16448 }
16449 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16450 #[repr(C)]
16451 pub struct CRYPT_URL_INFO {
16452     pub cbSize: u32,
16453     pub dwSyncDeltaTime: u32,
16454     pub cGroup: u32,
16455     pub rgcGroupEntry: *mut u32,
16456 }
16457 impl CRYPT_URL_INFO {}
16458 impl ::std::default::Default for CRYPT_URL_INFO {
default() -> Self16459     fn default() -> Self {
16460         unsafe { ::std::mem::zeroed() }
16461     }
16462 }
16463 impl ::std::fmt::Debug for CRYPT_URL_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16464     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16465         fmt.debug_struct("CRYPT_URL_INFO").field("cbSize", &self.cbSize).field("dwSyncDeltaTime", &self.dwSyncDeltaTime).field("cGroup", &self.cGroup).field("rgcGroupEntry", &self.rgcGroupEntry).finish()
16466     }
16467 }
16468 impl ::std::cmp::PartialEq for CRYPT_URL_INFO {
eq(&self, other: &Self) -> bool16469     fn eq(&self, other: &Self) -> bool {
16470         self.cbSize == other.cbSize && self.dwSyncDeltaTime == other.dwSyncDeltaTime && self.cGroup == other.cGroup && self.rgcGroupEntry == other.rgcGroupEntry
16471     }
16472 }
16473 impl ::std::cmp::Eq for CRYPT_URL_INFO {}
16474 unsafe impl ::windows::runtime::Abi for CRYPT_URL_INFO {
16475     type Abi = Self;
16476     type DefaultType = Self;
16477 }
16478 pub const CRYPT_USERDATA: u32 = 1u32;
16479 pub const CRYPT_USER_DEFAULT: u32 = 2u32;
16480 pub const CRYPT_USER_PROTECTED_STRONG: u32 = 1048576u32;
16481 pub const CRYPT_VERIFYCONTEXT: u32 = 4026531840u32;
16482 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
16483 #[repr(transparent)]
16484 pub struct CRYPT_VERIFY_CERT_FLAGS(pub u32);
16485 pub const CRYPT_VERIFY_CERT_SIGN_DISABLE_MD2_MD4_FLAG: CRYPT_VERIFY_CERT_FLAGS = CRYPT_VERIFY_CERT_FLAGS(1u32);
16486 pub const CRYPT_VERIFY_CERT_SIGN_SET_STRONG_PROPERTIES_FLAG: CRYPT_VERIFY_CERT_FLAGS = CRYPT_VERIFY_CERT_FLAGS(2u32);
16487 pub const CRYPT_VERIFY_CERT_SIGN_RETURN_STRONG_PROPERTIES_FLAG: CRYPT_VERIFY_CERT_FLAGS = CRYPT_VERIFY_CERT_FLAGS(4u32);
16488 impl ::std::convert::From<u32> for CRYPT_VERIFY_CERT_FLAGS {
from(value: u32) -> Self16489     fn from(value: u32) -> Self {
16490         Self(value)
16491     }
16492 }
16493 unsafe impl ::windows::runtime::Abi for CRYPT_VERIFY_CERT_FLAGS {
16494     type Abi = Self;
16495     type DefaultType = Self;
16496 }
16497 impl ::std::ops::BitOr for CRYPT_VERIFY_CERT_FLAGS {
16498     type Output = Self;
bitor(self, rhs: Self) -> Self16499     fn bitor(self, rhs: Self) -> Self {
16500         Self(self.0 | rhs.0)
16501     }
16502 }
16503 impl ::std::ops::BitAnd for CRYPT_VERIFY_CERT_FLAGS {
16504     type Output = Self;
bitand(self, rhs: Self) -> Self16505     fn bitand(self, rhs: Self) -> Self {
16506         Self(self.0 & rhs.0)
16507     }
16508 }
16509 impl ::std::ops::BitOrAssign for CRYPT_VERIFY_CERT_FLAGS {
bitor_assign(&mut self, rhs: Self)16510     fn bitor_assign(&mut self, rhs: Self) {
16511         self.0.bitor_assign(rhs.0)
16512     }
16513 }
16514 impl ::std::ops::BitAndAssign for CRYPT_VERIFY_CERT_FLAGS {
bitand_assign(&mut self, rhs: Self)16515     fn bitand_assign(&mut self, rhs: Self) {
16516         self.0.bitand_assign(rhs.0)
16517     }
16518 }
16519 impl ::std::ops::Not for CRYPT_VERIFY_CERT_FLAGS {
16520     type Output = Self;
not(self) -> Self16521     fn not(self) -> Self {
16522         Self(self.0.not())
16523     }
16524 }
16525 pub const CRYPT_VERIFY_CERT_SIGN_CHECK_WEAK_HASH_FLAG: u32 = 8u32;
16526 pub const CRYPT_VERIFY_CERT_SIGN_ISSUER_CERT: u32 = 2u32;
16527 pub const CRYPT_VERIFY_CERT_SIGN_ISSUER_CHAIN: u32 = 3u32;
16528 pub const CRYPT_VERIFY_CERT_SIGN_ISSUER_NULL: u32 = 4u32;
16529 pub const CRYPT_VERIFY_CERT_SIGN_ISSUER_PUBKEY: u32 = 1u32;
16530 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16531 #[repr(C)]
16532 pub struct CRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO {
16533     pub CertSignHashCNGAlgPropData: CRYPTOAPI_BLOB,
16534     pub CertIssuerPubKeyBitLengthPropData: CRYPTOAPI_BLOB,
16535 }
16536 impl CRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO {}
16537 impl ::std::default::Default for CRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO {
default() -> Self16538     fn default() -> Self {
16539         unsafe { ::std::mem::zeroed() }
16540     }
16541 }
16542 impl ::std::fmt::Debug for CRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16543     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16544         fmt.debug_struct("CRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO").field("CertSignHashCNGAlgPropData", &self.CertSignHashCNGAlgPropData).field("CertIssuerPubKeyBitLengthPropData", &self.CertIssuerPubKeyBitLengthPropData).finish()
16545     }
16546 }
16547 impl ::std::cmp::PartialEq for CRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO {
eq(&self, other: &Self) -> bool16548     fn eq(&self, other: &Self) -> bool {
16549         self.CertSignHashCNGAlgPropData == other.CertSignHashCNGAlgPropData && self.CertIssuerPubKeyBitLengthPropData == other.CertIssuerPubKeyBitLengthPropData
16550     }
16551 }
16552 impl ::std::cmp::Eq for CRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO {}
16553 unsafe impl ::windows::runtime::Abi for CRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO {
16554     type Abi = Self;
16555     type DefaultType = Self;
16556 }
16557 pub const CRYPT_VERIFY_CERT_SIGN_SUBJECT_BLOB: u32 = 1u32;
16558 pub const CRYPT_VERIFY_CERT_SIGN_SUBJECT_CERT: u32 = 2u32;
16559 pub const CRYPT_VERIFY_CERT_SIGN_SUBJECT_CRL: u32 = 3u32;
16560 pub const CRYPT_VERIFY_CERT_SIGN_SUBJECT_OCSP_BASIC_SIGNED_RESPONSE: u32 = 4u32;
16561 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16562 #[repr(C)]
16563 #[cfg(feature = "Win32_Foundation")]
16564 pub struct CRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFO {
16565     pub cCNGHashAlgid: u32,
16566     pub rgpwszCNGHashAlgid: *mut super::super::Foundation::PWSTR,
16567     pub dwWeakIndex: u32,
16568 }
16569 #[cfg(feature = "Win32_Foundation")]
16570 impl CRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFO {}
16571 #[cfg(feature = "Win32_Foundation")]
16572 impl ::std::default::Default for CRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFO {
default() -> Self16573     fn default() -> Self {
16574         unsafe { ::std::mem::zeroed() }
16575     }
16576 }
16577 #[cfg(feature = "Win32_Foundation")]
16578 impl ::std::fmt::Debug for CRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16579     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16580         fmt.debug_struct("CRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFO").field("cCNGHashAlgid", &self.cCNGHashAlgid).field("rgpwszCNGHashAlgid", &self.rgpwszCNGHashAlgid).field("dwWeakIndex", &self.dwWeakIndex).finish()
16581     }
16582 }
16583 #[cfg(feature = "Win32_Foundation")]
16584 impl ::std::cmp::PartialEq for CRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFO {
eq(&self, other: &Self) -> bool16585     fn eq(&self, other: &Self) -> bool {
16586         self.cCNGHashAlgid == other.cCNGHashAlgid && self.rgpwszCNGHashAlgid == other.rgpwszCNGHashAlgid && self.dwWeakIndex == other.dwWeakIndex
16587     }
16588 }
16589 #[cfg(feature = "Win32_Foundation")]
16590 impl ::std::cmp::Eq for CRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFO {}
16591 #[cfg(feature = "Win32_Foundation")]
16592 unsafe impl ::windows::runtime::Abi for CRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFO {
16593     type Abi = Self;
16594     type DefaultType = Self;
16595 }
16596 pub const CRYPT_VERIFY_CONTEXT_SIGNATURE: u32 = 32u32;
16597 pub const CRYPT_VERIFY_DATA_HASH: u32 = 64u32;
16598 #[derive(:: std :: clone :: Clone)]
16599 #[repr(C)]
16600 #[cfg(feature = "Win32_Foundation")]
16601 pub struct CRYPT_VERIFY_MESSAGE_PARA {
16602     pub cbSize: u32,
16603     pub dwMsgAndCertEncodingType: u32,
16604     pub hCryptProv: usize,
16605     pub pfnGetSignerCertificate: ::std::option::Option<PFN_CRYPT_GET_SIGNER_CERTIFICATE>,
16606     pub pvGetArg: *mut ::std::ffi::c_void,
16607 }
16608 #[cfg(feature = "Win32_Foundation")]
16609 impl CRYPT_VERIFY_MESSAGE_PARA {}
16610 #[cfg(feature = "Win32_Foundation")]
16611 impl ::std::default::Default for CRYPT_VERIFY_MESSAGE_PARA {
default() -> Self16612     fn default() -> Self {
16613         unsafe { ::std::mem::zeroed() }
16614     }
16615 }
16616 #[cfg(feature = "Win32_Foundation")]
16617 impl ::std::fmt::Debug for CRYPT_VERIFY_MESSAGE_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16618     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16619         fmt.debug_struct("CRYPT_VERIFY_MESSAGE_PARA").field("cbSize", &self.cbSize).field("dwMsgAndCertEncodingType", &self.dwMsgAndCertEncodingType).field("hCryptProv", &self.hCryptProv).field("pvGetArg", &self.pvGetArg).finish()
16620     }
16621 }
16622 #[cfg(feature = "Win32_Foundation")]
16623 impl ::std::cmp::PartialEq for CRYPT_VERIFY_MESSAGE_PARA {
eq(&self, other: &Self) -> bool16624     fn eq(&self, other: &Self) -> bool {
16625         self.cbSize == other.cbSize && self.dwMsgAndCertEncodingType == other.dwMsgAndCertEncodingType && self.hCryptProv == other.hCryptProv && self.pfnGetSignerCertificate.map(|f| f as usize) == other.pfnGetSignerCertificate.map(|f| f as usize) && self.pvGetArg == other.pvGetArg
16626     }
16627 }
16628 #[cfg(feature = "Win32_Foundation")]
16629 impl ::std::cmp::Eq for CRYPT_VERIFY_MESSAGE_PARA {}
16630 #[cfg(feature = "Win32_Foundation")]
16631 unsafe impl ::windows::runtime::Abi for CRYPT_VERIFY_MESSAGE_PARA {
16632     type Abi = ::std::mem::ManuallyDrop<Self>;
16633     type DefaultType = Self;
16634 }
16635 pub const CRYPT_WIRE_ONLY_RETRIEVAL: u32 = 4u32;
16636 pub const CRYPT_WRITE: u32 = 16u32;
16637 pub const CRYPT_X931_FORMAT: u32 = 4u32;
16638 pub const CRYPT_X942_COUNTER_BYTE_LENGTH: u32 = 4u32;
16639 pub const CRYPT_X942_KEY_LENGTH_BYTE_LENGTH: u32 = 4u32;
16640 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16641 #[repr(C)]
16642 #[cfg(feature = "Win32_Foundation")]
16643 pub struct CRYPT_X942_OTHER_INFO {
16644     pub pszContentEncryptionObjId: super::super::Foundation::PSTR,
16645     pub rgbCounter: [u8; 4],
16646     pub rgbKeyLength: [u8; 4],
16647     pub PubInfo: CRYPTOAPI_BLOB,
16648 }
16649 #[cfg(feature = "Win32_Foundation")]
16650 impl CRYPT_X942_OTHER_INFO {}
16651 #[cfg(feature = "Win32_Foundation")]
16652 impl ::std::default::Default for CRYPT_X942_OTHER_INFO {
default() -> Self16653     fn default() -> Self {
16654         unsafe { ::std::mem::zeroed() }
16655     }
16656 }
16657 #[cfg(feature = "Win32_Foundation")]
16658 impl ::std::fmt::Debug for CRYPT_X942_OTHER_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16659     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16660         fmt.debug_struct("CRYPT_X942_OTHER_INFO").field("pszContentEncryptionObjId", &self.pszContentEncryptionObjId).field("rgbCounter", &self.rgbCounter).field("rgbKeyLength", &self.rgbKeyLength).field("PubInfo", &self.PubInfo).finish()
16661     }
16662 }
16663 #[cfg(feature = "Win32_Foundation")]
16664 impl ::std::cmp::PartialEq for CRYPT_X942_OTHER_INFO {
eq(&self, other: &Self) -> bool16665     fn eq(&self, other: &Self) -> bool {
16666         self.pszContentEncryptionObjId == other.pszContentEncryptionObjId && self.rgbCounter == other.rgbCounter && self.rgbKeyLength == other.rgbKeyLength && self.PubInfo == other.PubInfo
16667     }
16668 }
16669 #[cfg(feature = "Win32_Foundation")]
16670 impl ::std::cmp::Eq for CRYPT_X942_OTHER_INFO {}
16671 #[cfg(feature = "Win32_Foundation")]
16672 unsafe impl ::windows::runtime::Abi for CRYPT_X942_OTHER_INFO {
16673     type Abi = Self;
16674     type DefaultType = Self;
16675 }
16676 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16677 #[repr(C)]
16678 #[cfg(feature = "Win32_Foundation")]
16679 pub struct CRYPT_XML_ALGORITHM {
16680     pub cbSize: u32,
16681     pub wszAlgorithm: super::super::Foundation::PWSTR,
16682     pub Encoded: CRYPT_XML_BLOB,
16683 }
16684 #[cfg(feature = "Win32_Foundation")]
16685 impl CRYPT_XML_ALGORITHM {}
16686 #[cfg(feature = "Win32_Foundation")]
16687 impl ::std::default::Default for CRYPT_XML_ALGORITHM {
default() -> Self16688     fn default() -> Self {
16689         unsafe { ::std::mem::zeroed() }
16690     }
16691 }
16692 #[cfg(feature = "Win32_Foundation")]
16693 impl ::std::fmt::Debug for CRYPT_XML_ALGORITHM {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16694     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16695         fmt.debug_struct("CRYPT_XML_ALGORITHM").field("cbSize", &self.cbSize).field("wszAlgorithm", &self.wszAlgorithm).field("Encoded", &self.Encoded).finish()
16696     }
16697 }
16698 #[cfg(feature = "Win32_Foundation")]
16699 impl ::std::cmp::PartialEq for CRYPT_XML_ALGORITHM {
eq(&self, other: &Self) -> bool16700     fn eq(&self, other: &Self) -> bool {
16701         self.cbSize == other.cbSize && self.wszAlgorithm == other.wszAlgorithm && self.Encoded == other.Encoded
16702     }
16703 }
16704 #[cfg(feature = "Win32_Foundation")]
16705 impl ::std::cmp::Eq for CRYPT_XML_ALGORITHM {}
16706 #[cfg(feature = "Win32_Foundation")]
16707 unsafe impl ::windows::runtime::Abi for CRYPT_XML_ALGORITHM {
16708     type Abi = Self;
16709     type DefaultType = Self;
16710 }
16711 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16712 #[repr(C)]
16713 #[cfg(feature = "Win32_Foundation")]
16714 pub struct CRYPT_XML_ALGORITHM_INFO {
16715     pub cbSize: u32,
16716     pub wszAlgorithmURI: super::super::Foundation::PWSTR,
16717     pub wszName: super::super::Foundation::PWSTR,
16718     pub dwGroupId: CRYPT_XML_GROUP_ID,
16719     pub wszCNGAlgid: super::super::Foundation::PWSTR,
16720     pub wszCNGExtraAlgid: super::super::Foundation::PWSTR,
16721     pub dwSignFlags: u32,
16722     pub dwVerifyFlags: u32,
16723     pub pvPaddingInfo: *mut ::std::ffi::c_void,
16724     pub pvExtraInfo: *mut ::std::ffi::c_void,
16725 }
16726 #[cfg(feature = "Win32_Foundation")]
16727 impl CRYPT_XML_ALGORITHM_INFO {}
16728 #[cfg(feature = "Win32_Foundation")]
16729 impl ::std::default::Default for CRYPT_XML_ALGORITHM_INFO {
default() -> Self16730     fn default() -> Self {
16731         unsafe { ::std::mem::zeroed() }
16732     }
16733 }
16734 #[cfg(feature = "Win32_Foundation")]
16735 impl ::std::fmt::Debug for CRYPT_XML_ALGORITHM_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16736     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16737         fmt.debug_struct("CRYPT_XML_ALGORITHM_INFO")
16738             .field("cbSize", &self.cbSize)
16739             .field("wszAlgorithmURI", &self.wszAlgorithmURI)
16740             .field("wszName", &self.wszName)
16741             .field("dwGroupId", &self.dwGroupId)
16742             .field("wszCNGAlgid", &self.wszCNGAlgid)
16743             .field("wszCNGExtraAlgid", &self.wszCNGExtraAlgid)
16744             .field("dwSignFlags", &self.dwSignFlags)
16745             .field("dwVerifyFlags", &self.dwVerifyFlags)
16746             .field("pvPaddingInfo", &self.pvPaddingInfo)
16747             .field("pvExtraInfo", &self.pvExtraInfo)
16748             .finish()
16749     }
16750 }
16751 #[cfg(feature = "Win32_Foundation")]
16752 impl ::std::cmp::PartialEq for CRYPT_XML_ALGORITHM_INFO {
eq(&self, other: &Self) -> bool16753     fn eq(&self, other: &Self) -> bool {
16754         self.cbSize == other.cbSize && self.wszAlgorithmURI == other.wszAlgorithmURI && self.wszName == other.wszName && self.dwGroupId == other.dwGroupId && self.wszCNGAlgid == other.wszCNGAlgid && self.wszCNGExtraAlgid == other.wszCNGExtraAlgid && self.dwSignFlags == other.dwSignFlags && self.dwVerifyFlags == other.dwVerifyFlags && self.pvPaddingInfo == other.pvPaddingInfo && self.pvExtraInfo == other.pvExtraInfo
16755     }
16756 }
16757 #[cfg(feature = "Win32_Foundation")]
16758 impl ::std::cmp::Eq for CRYPT_XML_ALGORITHM_INFO {}
16759 #[cfg(feature = "Win32_Foundation")]
16760 unsafe impl ::windows::runtime::Abi for CRYPT_XML_ALGORITHM_INFO {
16761     type Abi = Self;
16762     type DefaultType = Self;
16763 }
16764 pub const CRYPT_XML_ALGORITHM_INFO_FIND_BY_CNG_ALGID: u32 = 3u32;
16765 pub const CRYPT_XML_ALGORITHM_INFO_FIND_BY_CNG_SIGN_ALGID: u32 = 4u32;
16766 pub const CRYPT_XML_ALGORITHM_INFO_FIND_BY_NAME: u32 = 2u32;
16767 pub const CRYPT_XML_ALGORITHM_INFO_FIND_BY_URI: u32 = 1u32;
16768 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16769 #[repr(C)]
16770 pub struct CRYPT_XML_BLOB {
16771     pub dwCharset: CRYPT_XML_CHARSET,
16772     pub cbData: u32,
16773     pub pbData: *mut u8,
16774 }
16775 impl CRYPT_XML_BLOB {}
16776 impl ::std::default::Default for CRYPT_XML_BLOB {
default() -> Self16777     fn default() -> Self {
16778         unsafe { ::std::mem::zeroed() }
16779     }
16780 }
16781 impl ::std::fmt::Debug for CRYPT_XML_BLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16782     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16783         fmt.debug_struct("CRYPT_XML_BLOB").field("dwCharset", &self.dwCharset).field("cbData", &self.cbData).field("pbData", &self.pbData).finish()
16784     }
16785 }
16786 impl ::std::cmp::PartialEq for CRYPT_XML_BLOB {
eq(&self, other: &Self) -> bool16787     fn eq(&self, other: &Self) -> bool {
16788         self.dwCharset == other.dwCharset && self.cbData == other.cbData && self.pbData == other.pbData
16789     }
16790 }
16791 impl ::std::cmp::Eq for CRYPT_XML_BLOB {}
16792 unsafe impl ::windows::runtime::Abi for CRYPT_XML_BLOB {
16793     type Abi = Self;
16794     type DefaultType = Self;
16795 }
16796 pub const CRYPT_XML_BLOB_MAX: u32 = 2147483640u32;
16797 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
16798 #[repr(transparent)]
16799 pub struct CRYPT_XML_CHARSET(pub i32);
16800 pub const CRYPT_XML_CHARSET_AUTO: CRYPT_XML_CHARSET = CRYPT_XML_CHARSET(0i32);
16801 pub const CRYPT_XML_CHARSET_UTF8: CRYPT_XML_CHARSET = CRYPT_XML_CHARSET(1i32);
16802 pub const CRYPT_XML_CHARSET_UTF16LE: CRYPT_XML_CHARSET = CRYPT_XML_CHARSET(2i32);
16803 pub const CRYPT_XML_CHARSET_UTF16BE: CRYPT_XML_CHARSET = CRYPT_XML_CHARSET(3i32);
16804 impl ::std::convert::From<i32> for CRYPT_XML_CHARSET {
from(value: i32) -> Self16805     fn from(value: i32) -> Self {
16806         Self(value)
16807     }
16808 }
16809 unsafe impl ::windows::runtime::Abi for CRYPT_XML_CHARSET {
16810     type Abi = Self;
16811     type DefaultType = Self;
16812 }
16813 #[derive(:: std :: clone :: Clone)]
16814 #[repr(C)]
16815 #[cfg(feature = "Win32_Foundation")]
16816 pub struct CRYPT_XML_CRYPTOGRAPHIC_INTERFACE {
16817     pub cbSize: u32,
16818     pub fpCryptXmlEncodeAlgorithm: ::std::option::Option<CryptXmlDllEncodeAlgorithm>,
16819     pub fpCryptXmlCreateDigest: ::std::option::Option<CryptXmlDllCreateDigest>,
16820     pub fpCryptXmlDigestData: ::std::option::Option<CryptXmlDllDigestData>,
16821     pub fpCryptXmlFinalizeDigest: ::std::option::Option<CryptXmlDllFinalizeDigest>,
16822     pub fpCryptXmlCloseDigest: ::std::option::Option<CryptXmlDllCloseDigest>,
16823     pub fpCryptXmlSignData: ::std::option::Option<CryptXmlDllSignData>,
16824     pub fpCryptXmlVerifySignature: ::std::option::Option<CryptXmlDllVerifySignature>,
16825     pub fpCryptXmlGetAlgorithmInfo: ::std::option::Option<CryptXmlDllGetAlgorithmInfo>,
16826 }
16827 #[cfg(feature = "Win32_Foundation")]
16828 impl CRYPT_XML_CRYPTOGRAPHIC_INTERFACE {}
16829 #[cfg(feature = "Win32_Foundation")]
16830 impl ::std::default::Default for CRYPT_XML_CRYPTOGRAPHIC_INTERFACE {
default() -> Self16831     fn default() -> Self {
16832         unsafe { ::std::mem::zeroed() }
16833     }
16834 }
16835 #[cfg(feature = "Win32_Foundation")]
16836 impl ::std::fmt::Debug for CRYPT_XML_CRYPTOGRAPHIC_INTERFACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16837     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16838         fmt.debug_struct("CRYPT_XML_CRYPTOGRAPHIC_INTERFACE").field("cbSize", &self.cbSize).finish()
16839     }
16840 }
16841 #[cfg(feature = "Win32_Foundation")]
16842 impl ::std::cmp::PartialEq for CRYPT_XML_CRYPTOGRAPHIC_INTERFACE {
eq(&self, other: &Self) -> bool16843     fn eq(&self, other: &Self) -> bool {
16844         self.cbSize == other.cbSize
16845             && self.fpCryptXmlEncodeAlgorithm.map(|f| f as usize) == other.fpCryptXmlEncodeAlgorithm.map(|f| f as usize)
16846             && self.fpCryptXmlCreateDigest.map(|f| f as usize) == other.fpCryptXmlCreateDigest.map(|f| f as usize)
16847             && self.fpCryptXmlDigestData.map(|f| f as usize) == other.fpCryptXmlDigestData.map(|f| f as usize)
16848             && self.fpCryptXmlFinalizeDigest.map(|f| f as usize) == other.fpCryptXmlFinalizeDigest.map(|f| f as usize)
16849             && self.fpCryptXmlCloseDigest.map(|f| f as usize) == other.fpCryptXmlCloseDigest.map(|f| f as usize)
16850             && self.fpCryptXmlSignData.map(|f| f as usize) == other.fpCryptXmlSignData.map(|f| f as usize)
16851             && self.fpCryptXmlVerifySignature.map(|f| f as usize) == other.fpCryptXmlVerifySignature.map(|f| f as usize)
16852             && self.fpCryptXmlGetAlgorithmInfo.map(|f| f as usize) == other.fpCryptXmlGetAlgorithmInfo.map(|f| f as usize)
16853     }
16854 }
16855 #[cfg(feature = "Win32_Foundation")]
16856 impl ::std::cmp::Eq for CRYPT_XML_CRYPTOGRAPHIC_INTERFACE {}
16857 #[cfg(feature = "Win32_Foundation")]
16858 unsafe impl ::windows::runtime::Abi for CRYPT_XML_CRYPTOGRAPHIC_INTERFACE {
16859     type Abi = ::std::mem::ManuallyDrop<Self>;
16860     type DefaultType = Self;
16861 }
16862 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16863 #[repr(C)]
16864 pub struct CRYPT_XML_DATA_BLOB {
16865     pub cbData: u32,
16866     pub pbData: *mut u8,
16867 }
16868 impl CRYPT_XML_DATA_BLOB {}
16869 impl ::std::default::Default for CRYPT_XML_DATA_BLOB {
default() -> Self16870     fn default() -> Self {
16871         unsafe { ::std::mem::zeroed() }
16872     }
16873 }
16874 impl ::std::fmt::Debug for CRYPT_XML_DATA_BLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16875     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16876         fmt.debug_struct("CRYPT_XML_DATA_BLOB").field("cbData", &self.cbData).field("pbData", &self.pbData).finish()
16877     }
16878 }
16879 impl ::std::cmp::PartialEq for CRYPT_XML_DATA_BLOB {
eq(&self, other: &Self) -> bool16880     fn eq(&self, other: &Self) -> bool {
16881         self.cbData == other.cbData && self.pbData == other.pbData
16882     }
16883 }
16884 impl ::std::cmp::Eq for CRYPT_XML_DATA_BLOB {}
16885 unsafe impl ::windows::runtime::Abi for CRYPT_XML_DATA_BLOB {
16886     type Abi = Self;
16887     type DefaultType = Self;
16888 }
16889 #[derive(:: std :: clone :: Clone)]
16890 #[repr(C)]
16891 pub struct CRYPT_XML_DATA_PROVIDER {
16892     pub pvCallbackState: *mut ::std::ffi::c_void,
16893     pub cbBufferSize: u32,
16894     pub pfnRead: ::std::option::Option<PFN_CRYPT_XML_DATA_PROVIDER_READ>,
16895     pub pfnClose: ::std::option::Option<PFN_CRYPT_XML_DATA_PROVIDER_CLOSE>,
16896 }
16897 impl CRYPT_XML_DATA_PROVIDER {}
16898 impl ::std::default::Default for CRYPT_XML_DATA_PROVIDER {
default() -> Self16899     fn default() -> Self {
16900         unsafe { ::std::mem::zeroed() }
16901     }
16902 }
16903 impl ::std::fmt::Debug for CRYPT_XML_DATA_PROVIDER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16904     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16905         fmt.debug_struct("CRYPT_XML_DATA_PROVIDER").field("pvCallbackState", &self.pvCallbackState).field("cbBufferSize", &self.cbBufferSize).finish()
16906     }
16907 }
16908 impl ::std::cmp::PartialEq for CRYPT_XML_DATA_PROVIDER {
eq(&self, other: &Self) -> bool16909     fn eq(&self, other: &Self) -> bool {
16910         self.pvCallbackState == other.pvCallbackState && self.cbBufferSize == other.cbBufferSize && self.pfnRead.map(|f| f as usize) == other.pfnRead.map(|f| f as usize) && self.pfnClose.map(|f| f as usize) == other.pfnClose.map(|f| f as usize)
16911     }
16912 }
16913 impl ::std::cmp::Eq for CRYPT_XML_DATA_PROVIDER {}
16914 unsafe impl ::windows::runtime::Abi for CRYPT_XML_DATA_PROVIDER {
16915     type Abi = ::std::mem::ManuallyDrop<Self>;
16916     type DefaultType = Self;
16917 }
16918 pub const CRYPT_XML_DIGEST_REFERENCE_DATA_TRANSFORMED: u32 = 1u32;
16919 pub const CRYPT_XML_DIGEST_VALUE_MAX: u32 = 128u32;
16920 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16921 #[repr(C)]
16922 #[cfg(feature = "Win32_Foundation")]
16923 pub struct CRYPT_XML_DOC_CTXT {
16924     pub cbSize: u32,
16925     pub hDocCtxt: *mut ::std::ffi::c_void,
16926     pub pTransformsConfig: *mut CRYPT_XML_TRANSFORM_CHAIN_CONFIG,
16927     pub cSignature: u32,
16928     pub rgpSignature: *mut *mut CRYPT_XML_SIGNATURE,
16929 }
16930 #[cfg(feature = "Win32_Foundation")]
16931 impl CRYPT_XML_DOC_CTXT {}
16932 #[cfg(feature = "Win32_Foundation")]
16933 impl ::std::default::Default for CRYPT_XML_DOC_CTXT {
default() -> Self16934     fn default() -> Self {
16935         unsafe { ::std::mem::zeroed() }
16936     }
16937 }
16938 #[cfg(feature = "Win32_Foundation")]
16939 impl ::std::fmt::Debug for CRYPT_XML_DOC_CTXT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result16940     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16941         fmt.debug_struct("CRYPT_XML_DOC_CTXT").field("cbSize", &self.cbSize).field("hDocCtxt", &self.hDocCtxt).field("pTransformsConfig", &self.pTransformsConfig).field("cSignature", &self.cSignature).field("rgpSignature", &self.rgpSignature).finish()
16942     }
16943 }
16944 #[cfg(feature = "Win32_Foundation")]
16945 impl ::std::cmp::PartialEq for CRYPT_XML_DOC_CTXT {
eq(&self, other: &Self) -> bool16946     fn eq(&self, other: &Self) -> bool {
16947         self.cbSize == other.cbSize && self.hDocCtxt == other.hDocCtxt && self.pTransformsConfig == other.pTransformsConfig && self.cSignature == other.cSignature && self.rgpSignature == other.rgpSignature
16948     }
16949 }
16950 #[cfg(feature = "Win32_Foundation")]
16951 impl ::std::cmp::Eq for CRYPT_XML_DOC_CTXT {}
16952 #[cfg(feature = "Win32_Foundation")]
16953 unsafe impl ::windows::runtime::Abi for CRYPT_XML_DOC_CTXT {
16954     type Abi = Self;
16955     type DefaultType = Self;
16956 }
16957 pub const CRYPT_XML_E_ALGORITHM: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885372i32 as _);
16958 pub const CRYPT_XML_E_BASE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885376i32 as _);
16959 pub const CRYPT_XML_E_ENCODING: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885373i32 as _);
16960 pub const CRYPT_XML_E_HANDLE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885370i32 as _);
16961 pub const CRYPT_XML_E_HASH_FAILED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885365i32 as _);
16962 pub const CRYPT_XML_E_INVALID_DIGEST: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885367i32 as _);
16963 pub const CRYPT_XML_E_INVALID_KEYVALUE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885361i32 as _);
16964 pub const CRYPT_XML_E_INVALID_SIGNATURE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885366i32 as _);
16965 pub const CRYPT_XML_E_LARGE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885375i32 as _);
16966 pub const CRYPT_XML_E_LAST: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885358i32 as _);
16967 pub const CRYPT_XML_E_NON_UNIQUE_ID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885358i32 as _);
16968 pub const CRYPT_XML_E_OPERATION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885369i32 as _);
16969 pub const CRYPT_XML_E_SIGNER: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885359i32 as _);
16970 pub const CRYPT_XML_E_SIGN_FAILED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885364i32 as _);
16971 pub const CRYPT_XML_E_TOO_MANY_SIGNATURES: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885362i32 as _);
16972 pub const CRYPT_XML_E_TOO_MANY_TRANSFORMS: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885374i32 as _);
16973 pub const CRYPT_XML_E_TRANSFORM: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885371i32 as _);
16974 pub const CRYPT_XML_E_UNEXPECTED_XML: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885360i32 as _);
16975 pub const CRYPT_XML_E_UNRESOLVED_REFERENCE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885368i32 as _);
16976 pub const CRYPT_XML_E_VERIFY_FAILED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2146885363i32 as _);
16977 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
16978 #[repr(transparent)]
16979 pub struct CRYPT_XML_FLAGS(pub u32);
16980 pub const CRYPT_XML_FLAG_DISABLE_EXTENSIONS: CRYPT_XML_FLAGS = CRYPT_XML_FLAGS(268435456u32);
16981 pub const CRYPT_XML_FLAG_NO_SERIALIZE: CRYPT_XML_FLAGS = CRYPT_XML_FLAGS(2147483648u32);
16982 pub const CRYPT_XML_SIGN_ADD_KEYVALUE: CRYPT_XML_FLAGS = CRYPT_XML_FLAGS(1u32);
16983 impl ::std::convert::From<u32> for CRYPT_XML_FLAGS {
from(value: u32) -> Self16984     fn from(value: u32) -> Self {
16985         Self(value)
16986     }
16987 }
16988 unsafe impl ::windows::runtime::Abi for CRYPT_XML_FLAGS {
16989     type Abi = Self;
16990     type DefaultType = Self;
16991 }
16992 impl ::std::ops::BitOr for CRYPT_XML_FLAGS {
16993     type Output = Self;
bitor(self, rhs: Self) -> Self16994     fn bitor(self, rhs: Self) -> Self {
16995         Self(self.0 | rhs.0)
16996     }
16997 }
16998 impl ::std::ops::BitAnd for CRYPT_XML_FLAGS {
16999     type Output = Self;
bitand(self, rhs: Self) -> Self17000     fn bitand(self, rhs: Self) -> Self {
17001         Self(self.0 & rhs.0)
17002     }
17003 }
17004 impl ::std::ops::BitOrAssign for CRYPT_XML_FLAGS {
bitor_assign(&mut self, rhs: Self)17005     fn bitor_assign(&mut self, rhs: Self) {
17006         self.0.bitor_assign(rhs.0)
17007     }
17008 }
17009 impl ::std::ops::BitAndAssign for CRYPT_XML_FLAGS {
bitand_assign(&mut self, rhs: Self)17010     fn bitand_assign(&mut self, rhs: Self) {
17011         self.0.bitand_assign(rhs.0)
17012     }
17013 }
17014 impl ::std::ops::Not for CRYPT_XML_FLAGS {
17015     type Output = Self;
not(self) -> Self17016     fn not(self) -> Self {
17017         Self(self.0.not())
17018     }
17019 }
17020 pub const CRYPT_XML_FLAG_ADD_OBJECT_CREATE_COPY: u32 = 1u32;
17021 pub const CRYPT_XML_FLAG_ALWAYS_RETURN_ENCODED_OBJECT: u32 = 1073741824u32;
17022 pub const CRYPT_XML_FLAG_CREATE_REFERENCE_AS_OBJECT: u32 = 1u32;
17023 pub const CRYPT_XML_FLAG_ECDSA_DSIG11: u32 = 67108864u32;
17024 pub const CRYPT_XML_FLAG_ENFORCE_ID_NAME_FORMAT: u32 = 134217728u32;
17025 pub const CRYPT_XML_FLAG_ENFORCE_ID_NCNAME_FORMAT: u32 = 536870912u32;
17026 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
17027 #[repr(transparent)]
17028 pub struct CRYPT_XML_GROUP_ID(pub u32);
17029 pub const CRYPT_XML_GROUP_ID_HASH_________: CRYPT_XML_GROUP_ID = CRYPT_XML_GROUP_ID(1u32);
17030 pub const CRYPT_XML_GROUP_ID_SIGN_________: CRYPT_XML_GROUP_ID = CRYPT_XML_GROUP_ID(2u32);
17031 impl ::std::convert::From<u32> for CRYPT_XML_GROUP_ID {
from(value: u32) -> Self17032     fn from(value: u32) -> Self {
17033         Self(value)
17034     }
17035 }
17036 unsafe impl ::windows::runtime::Abi for CRYPT_XML_GROUP_ID {
17037     type Abi = Self;
17038     type DefaultType = Self;
17039 }
17040 impl ::std::ops::BitOr for CRYPT_XML_GROUP_ID {
17041     type Output = Self;
bitor(self, rhs: Self) -> Self17042     fn bitor(self, rhs: Self) -> Self {
17043         Self(self.0 | rhs.0)
17044     }
17045 }
17046 impl ::std::ops::BitAnd for CRYPT_XML_GROUP_ID {
17047     type Output = Self;
bitand(self, rhs: Self) -> Self17048     fn bitand(self, rhs: Self) -> Self {
17049         Self(self.0 & rhs.0)
17050     }
17051 }
17052 impl ::std::ops::BitOrAssign for CRYPT_XML_GROUP_ID {
bitor_assign(&mut self, rhs: Self)17053     fn bitor_assign(&mut self, rhs: Self) {
17054         self.0.bitor_assign(rhs.0)
17055     }
17056 }
17057 impl ::std::ops::BitAndAssign for CRYPT_XML_GROUP_ID {
bitand_assign(&mut self, rhs: Self)17058     fn bitand_assign(&mut self, rhs: Self) {
17059         self.0.bitand_assign(rhs.0)
17060     }
17061 }
17062 impl ::std::ops::Not for CRYPT_XML_GROUP_ID {
17063     type Output = Self;
not(self) -> Self17064     fn not(self) -> Self {
17065         Self(self.0.not())
17066     }
17067 }
17068 pub const CRYPT_XML_GROUP_ID_HASH: u32 = 1u32;
17069 pub const CRYPT_XML_GROUP_ID_SIGN: u32 = 2u32;
17070 pub const CRYPT_XML_ID_MAX: u32 = 256u32;
17071 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17072 #[repr(C)]
17073 #[cfg(feature = "Win32_Foundation")]
17074 pub struct CRYPT_XML_ISSUER_SERIAL {
17075     pub wszIssuer: super::super::Foundation::PWSTR,
17076     pub wszSerial: super::super::Foundation::PWSTR,
17077 }
17078 #[cfg(feature = "Win32_Foundation")]
17079 impl CRYPT_XML_ISSUER_SERIAL {}
17080 #[cfg(feature = "Win32_Foundation")]
17081 impl ::std::default::Default for CRYPT_XML_ISSUER_SERIAL {
default() -> Self17082     fn default() -> Self {
17083         unsafe { ::std::mem::zeroed() }
17084     }
17085 }
17086 #[cfg(feature = "Win32_Foundation")]
17087 impl ::std::fmt::Debug for CRYPT_XML_ISSUER_SERIAL {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result17088     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17089         fmt.debug_struct("CRYPT_XML_ISSUER_SERIAL").field("wszIssuer", &self.wszIssuer).field("wszSerial", &self.wszSerial).finish()
17090     }
17091 }
17092 #[cfg(feature = "Win32_Foundation")]
17093 impl ::std::cmp::PartialEq for CRYPT_XML_ISSUER_SERIAL {
eq(&self, other: &Self) -> bool17094     fn eq(&self, other: &Self) -> bool {
17095         self.wszIssuer == other.wszIssuer && self.wszSerial == other.wszSerial
17096     }
17097 }
17098 #[cfg(feature = "Win32_Foundation")]
17099 impl ::std::cmp::Eq for CRYPT_XML_ISSUER_SERIAL {}
17100 #[cfg(feature = "Win32_Foundation")]
17101 unsafe impl ::windows::runtime::Abi for CRYPT_XML_ISSUER_SERIAL {
17102     type Abi = Self;
17103     type DefaultType = Self;
17104 }
17105 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17106 #[repr(C)]
17107 #[cfg(feature = "Win32_Foundation")]
17108 pub struct CRYPT_XML_KEYINFO_PARAM {
17109     pub wszId: super::super::Foundation::PWSTR,
17110     pub wszKeyName: super::super::Foundation::PWSTR,
17111     pub SKI: CRYPTOAPI_BLOB,
17112     pub wszSubjectName: super::super::Foundation::PWSTR,
17113     pub cCertificate: u32,
17114     pub rgCertificate: *mut CRYPTOAPI_BLOB,
17115     pub cCRL: u32,
17116     pub rgCRL: *mut CRYPTOAPI_BLOB,
17117 }
17118 #[cfg(feature = "Win32_Foundation")]
17119 impl CRYPT_XML_KEYINFO_PARAM {}
17120 #[cfg(feature = "Win32_Foundation")]
17121 impl ::std::default::Default for CRYPT_XML_KEYINFO_PARAM {
default() -> Self17122     fn default() -> Self {
17123         unsafe { ::std::mem::zeroed() }
17124     }
17125 }
17126 #[cfg(feature = "Win32_Foundation")]
17127 impl ::std::fmt::Debug for CRYPT_XML_KEYINFO_PARAM {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result17128     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17129         fmt.debug_struct("CRYPT_XML_KEYINFO_PARAM")
17130             .field("wszId", &self.wszId)
17131             .field("wszKeyName", &self.wszKeyName)
17132             .field("SKI", &self.SKI)
17133             .field("wszSubjectName", &self.wszSubjectName)
17134             .field("cCertificate", &self.cCertificate)
17135             .field("rgCertificate", &self.rgCertificate)
17136             .field("cCRL", &self.cCRL)
17137             .field("rgCRL", &self.rgCRL)
17138             .finish()
17139     }
17140 }
17141 #[cfg(feature = "Win32_Foundation")]
17142 impl ::std::cmp::PartialEq for CRYPT_XML_KEYINFO_PARAM {
eq(&self, other: &Self) -> bool17143     fn eq(&self, other: &Self) -> bool {
17144         self.wszId == other.wszId && self.wszKeyName == other.wszKeyName && self.SKI == other.SKI && self.wszSubjectName == other.wszSubjectName && self.cCertificate == other.cCertificate && self.rgCertificate == other.rgCertificate && self.cCRL == other.cCRL && self.rgCRL == other.rgCRL
17145     }
17146 }
17147 #[cfg(feature = "Win32_Foundation")]
17148 impl ::std::cmp::Eq for CRYPT_XML_KEYINFO_PARAM {}
17149 #[cfg(feature = "Win32_Foundation")]
17150 unsafe impl ::windows::runtime::Abi for CRYPT_XML_KEYINFO_PARAM {
17151     type Abi = Self;
17152     type DefaultType = Self;
17153 }
17154 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
17155 #[repr(transparent)]
17156 pub struct CRYPT_XML_KEYINFO_SPEC(pub i32);
17157 pub const CRYPT_XML_KEYINFO_SPEC_NONE: CRYPT_XML_KEYINFO_SPEC = CRYPT_XML_KEYINFO_SPEC(0i32);
17158 pub const CRYPT_XML_KEYINFO_SPEC_ENCODED: CRYPT_XML_KEYINFO_SPEC = CRYPT_XML_KEYINFO_SPEC(1i32);
17159 pub const CRYPT_XML_KEYINFO_SPEC_PARAM: CRYPT_XML_KEYINFO_SPEC = CRYPT_XML_KEYINFO_SPEC(2i32);
17160 impl ::std::convert::From<i32> for CRYPT_XML_KEYINFO_SPEC {
from(value: i32) -> Self17161     fn from(value: i32) -> Self {
17162         Self(value)
17163     }
17164 }
17165 unsafe impl ::windows::runtime::Abi for CRYPT_XML_KEYINFO_SPEC {
17166     type Abi = Self;
17167     type DefaultType = Self;
17168 }
17169 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
17170 #[repr(transparent)]
17171 pub struct CRYPT_XML_KEYINFO_TYPE(pub u32);
17172 pub const CRYPT_XML_KEYINFO_TYPE_KEYNAME: CRYPT_XML_KEYINFO_TYPE = CRYPT_XML_KEYINFO_TYPE(1u32);
17173 pub const CRYPT_XML_KEYINFO_TYPE_KEYVALUE: CRYPT_XML_KEYINFO_TYPE = CRYPT_XML_KEYINFO_TYPE(2u32);
17174 pub const CRYPT_XML_KEYINFO_TYPE_RETRIEVAL: CRYPT_XML_KEYINFO_TYPE = CRYPT_XML_KEYINFO_TYPE(3u32);
17175 pub const CRYPT_XML_KEYINFO_TYPE_X509DATA: CRYPT_XML_KEYINFO_TYPE = CRYPT_XML_KEYINFO_TYPE(4u32);
17176 pub const CRYPT_XML_KEYINFO_TYPE_CUSTOM: CRYPT_XML_KEYINFO_TYPE = CRYPT_XML_KEYINFO_TYPE(5u32);
17177 impl ::std::convert::From<u32> for CRYPT_XML_KEYINFO_TYPE {
from(value: u32) -> Self17178     fn from(value: u32) -> Self {
17179         Self(value)
17180     }
17181 }
17182 unsafe impl ::windows::runtime::Abi for CRYPT_XML_KEYINFO_TYPE {
17183     type Abi = Self;
17184     type DefaultType = Self;
17185 }
17186 impl ::std::ops::BitOr for CRYPT_XML_KEYINFO_TYPE {
17187     type Output = Self;
bitor(self, rhs: Self) -> Self17188     fn bitor(self, rhs: Self) -> Self {
17189         Self(self.0 | rhs.0)
17190     }
17191 }
17192 impl ::std::ops::BitAnd for CRYPT_XML_KEYINFO_TYPE {
17193     type Output = Self;
bitand(self, rhs: Self) -> Self17194     fn bitand(self, rhs: Self) -> Self {
17195         Self(self.0 & rhs.0)
17196     }
17197 }
17198 impl ::std::ops::BitOrAssign for CRYPT_XML_KEYINFO_TYPE {
bitor_assign(&mut self, rhs: Self)17199     fn bitor_assign(&mut self, rhs: Self) {
17200         self.0.bitor_assign(rhs.0)
17201     }
17202 }
17203 impl ::std::ops::BitAndAssign for CRYPT_XML_KEYINFO_TYPE {
bitand_assign(&mut self, rhs: Self)17204     fn bitand_assign(&mut self, rhs: Self) {
17205         self.0.bitand_assign(rhs.0)
17206     }
17207 }
17208 impl ::std::ops::Not for CRYPT_XML_KEYINFO_TYPE {
17209     type Output = Self;
not(self) -> Self17210     fn not(self) -> Self {
17211         Self(self.0.not())
17212     }
17213 }
17214 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17215 #[repr(C)]
17216 pub struct CRYPT_XML_KEY_DSA_KEY_VALUE {
17217     pub P: CRYPT_XML_DATA_BLOB,
17218     pub Q: CRYPT_XML_DATA_BLOB,
17219     pub G: CRYPT_XML_DATA_BLOB,
17220     pub Y: CRYPT_XML_DATA_BLOB,
17221     pub J: CRYPT_XML_DATA_BLOB,
17222     pub Seed: CRYPT_XML_DATA_BLOB,
17223     pub Counter: CRYPT_XML_DATA_BLOB,
17224 }
17225 impl CRYPT_XML_KEY_DSA_KEY_VALUE {}
17226 impl ::std::default::Default for CRYPT_XML_KEY_DSA_KEY_VALUE {
default() -> Self17227     fn default() -> Self {
17228         unsafe { ::std::mem::zeroed() }
17229     }
17230 }
17231 impl ::std::fmt::Debug for CRYPT_XML_KEY_DSA_KEY_VALUE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result17232     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17233         fmt.debug_struct("CRYPT_XML_KEY_DSA_KEY_VALUE").field("P", &self.P).field("Q", &self.Q).field("G", &self.G).field("Y", &self.Y).field("J", &self.J).field("Seed", &self.Seed).field("Counter", &self.Counter).finish()
17234     }
17235 }
17236 impl ::std::cmp::PartialEq for CRYPT_XML_KEY_DSA_KEY_VALUE {
eq(&self, other: &Self) -> bool17237     fn eq(&self, other: &Self) -> bool {
17238         self.P == other.P && self.Q == other.Q && self.G == other.G && self.Y == other.Y && self.J == other.J && self.Seed == other.Seed && self.Counter == other.Counter
17239     }
17240 }
17241 impl ::std::cmp::Eq for CRYPT_XML_KEY_DSA_KEY_VALUE {}
17242 unsafe impl ::windows::runtime::Abi for CRYPT_XML_KEY_DSA_KEY_VALUE {
17243     type Abi = Self;
17244     type DefaultType = Self;
17245 }
17246 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17247 #[repr(C)]
17248 #[cfg(feature = "Win32_Foundation")]
17249 pub struct CRYPT_XML_KEY_ECDSA_KEY_VALUE {
17250     pub wszNamedCurve: super::super::Foundation::PWSTR,
17251     pub X: CRYPT_XML_DATA_BLOB,
17252     pub Y: CRYPT_XML_DATA_BLOB,
17253     pub ExplicitPara: CRYPT_XML_BLOB,
17254 }
17255 #[cfg(feature = "Win32_Foundation")]
17256 impl CRYPT_XML_KEY_ECDSA_KEY_VALUE {}
17257 #[cfg(feature = "Win32_Foundation")]
17258 impl ::std::default::Default for CRYPT_XML_KEY_ECDSA_KEY_VALUE {
default() -> Self17259     fn default() -> Self {
17260         unsafe { ::std::mem::zeroed() }
17261     }
17262 }
17263 #[cfg(feature = "Win32_Foundation")]
17264 impl ::std::fmt::Debug for CRYPT_XML_KEY_ECDSA_KEY_VALUE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result17265     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17266         fmt.debug_struct("CRYPT_XML_KEY_ECDSA_KEY_VALUE").field("wszNamedCurve", &self.wszNamedCurve).field("X", &self.X).field("Y", &self.Y).field("ExplicitPara", &self.ExplicitPara).finish()
17267     }
17268 }
17269 #[cfg(feature = "Win32_Foundation")]
17270 impl ::std::cmp::PartialEq for CRYPT_XML_KEY_ECDSA_KEY_VALUE {
eq(&self, other: &Self) -> bool17271     fn eq(&self, other: &Self) -> bool {
17272         self.wszNamedCurve == other.wszNamedCurve && self.X == other.X && self.Y == other.Y && self.ExplicitPara == other.ExplicitPara
17273     }
17274 }
17275 #[cfg(feature = "Win32_Foundation")]
17276 impl ::std::cmp::Eq for CRYPT_XML_KEY_ECDSA_KEY_VALUE {}
17277 #[cfg(feature = "Win32_Foundation")]
17278 unsafe impl ::windows::runtime::Abi for CRYPT_XML_KEY_ECDSA_KEY_VALUE {
17279     type Abi = Self;
17280     type DefaultType = Self;
17281 }
17282 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17283 #[repr(C)]
17284 #[cfg(feature = "Win32_Foundation")]
17285 pub struct CRYPT_XML_KEY_INFO {
17286     pub cbSize: u32,
17287     pub wszId: super::super::Foundation::PWSTR,
17288     pub cKeyInfo: u32,
17289     pub rgKeyInfo: *mut CRYPT_XML_KEY_INFO_ITEM,
17290     pub hVerifyKey: BCRYPT_KEY_HANDLE,
17291 }
17292 #[cfg(feature = "Win32_Foundation")]
17293 impl CRYPT_XML_KEY_INFO {}
17294 #[cfg(feature = "Win32_Foundation")]
17295 impl ::std::default::Default for CRYPT_XML_KEY_INFO {
default() -> Self17296     fn default() -> Self {
17297         unsafe { ::std::mem::zeroed() }
17298     }
17299 }
17300 #[cfg(feature = "Win32_Foundation")]
17301 impl ::std::fmt::Debug for CRYPT_XML_KEY_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result17302     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17303         fmt.debug_struct("CRYPT_XML_KEY_INFO").field("cbSize", &self.cbSize).field("wszId", &self.wszId).field("cKeyInfo", &self.cKeyInfo).field("rgKeyInfo", &self.rgKeyInfo).field("hVerifyKey", &self.hVerifyKey).finish()
17304     }
17305 }
17306 #[cfg(feature = "Win32_Foundation")]
17307 impl ::std::cmp::PartialEq for CRYPT_XML_KEY_INFO {
eq(&self, other: &Self) -> bool17308     fn eq(&self, other: &Self) -> bool {
17309         self.cbSize == other.cbSize && self.wszId == other.wszId && self.cKeyInfo == other.cKeyInfo && self.rgKeyInfo == other.rgKeyInfo && self.hVerifyKey == other.hVerifyKey
17310     }
17311 }
17312 #[cfg(feature = "Win32_Foundation")]
17313 impl ::std::cmp::Eq for CRYPT_XML_KEY_INFO {}
17314 #[cfg(feature = "Win32_Foundation")]
17315 unsafe impl ::windows::runtime::Abi for CRYPT_XML_KEY_INFO {
17316     type Abi = Self;
17317     type DefaultType = Self;
17318 }
17319 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17320 #[repr(C)]
17321 #[cfg(feature = "Win32_Foundation")]
17322 pub struct CRYPT_XML_KEY_INFO_ITEM {
17323     pub dwType: CRYPT_XML_KEYINFO_TYPE,
17324     pub Anonymous: CRYPT_XML_KEY_INFO_ITEM_0,
17325 }
17326 #[cfg(feature = "Win32_Foundation")]
17327 impl CRYPT_XML_KEY_INFO_ITEM {}
17328 #[cfg(feature = "Win32_Foundation")]
17329 impl ::std::default::Default for CRYPT_XML_KEY_INFO_ITEM {
default() -> Self17330     fn default() -> Self {
17331         unsafe { ::std::mem::zeroed() }
17332     }
17333 }
17334 #[cfg(feature = "Win32_Foundation")]
17335 impl ::std::cmp::PartialEq for CRYPT_XML_KEY_INFO_ITEM {
eq(&self, _other: &Self) -> bool17336     fn eq(&self, _other: &Self) -> bool {
17337         unimplemented!()
17338     }
17339 }
17340 #[cfg(feature = "Win32_Foundation")]
17341 impl ::std::cmp::Eq for CRYPT_XML_KEY_INFO_ITEM {}
17342 #[cfg(feature = "Win32_Foundation")]
17343 unsafe impl ::windows::runtime::Abi for CRYPT_XML_KEY_INFO_ITEM {
17344     type Abi = Self;
17345     type DefaultType = Self;
17346 }
17347 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17348 #[repr(C)]
17349 #[cfg(feature = "Win32_Foundation")]
17350 pub union CRYPT_XML_KEY_INFO_ITEM_0 {
17351     pub wszKeyName: super::super::Foundation::PWSTR,
17352     pub KeyValue: CRYPT_XML_KEY_VALUE,
17353     pub RetrievalMethod: CRYPT_XML_BLOB,
17354     pub X509Data: CRYPT_XML_X509DATA,
17355     pub Custom: CRYPT_XML_BLOB,
17356 }
17357 #[cfg(feature = "Win32_Foundation")]
17358 impl CRYPT_XML_KEY_INFO_ITEM_0 {}
17359 #[cfg(feature = "Win32_Foundation")]
17360 impl ::std::default::Default for CRYPT_XML_KEY_INFO_ITEM_0 {
default() -> Self17361     fn default() -> Self {
17362         unsafe { ::std::mem::zeroed() }
17363     }
17364 }
17365 #[cfg(feature = "Win32_Foundation")]
17366 impl ::std::cmp::PartialEq for CRYPT_XML_KEY_INFO_ITEM_0 {
eq(&self, _other: &Self) -> bool17367     fn eq(&self, _other: &Self) -> bool {
17368         unimplemented!()
17369     }
17370 }
17371 #[cfg(feature = "Win32_Foundation")]
17372 impl ::std::cmp::Eq for CRYPT_XML_KEY_INFO_ITEM_0 {}
17373 #[cfg(feature = "Win32_Foundation")]
17374 unsafe impl ::windows::runtime::Abi for CRYPT_XML_KEY_INFO_ITEM_0 {
17375     type Abi = Self;
17376     type DefaultType = Self;
17377 }
17378 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17379 #[repr(C)]
17380 pub struct CRYPT_XML_KEY_RSA_KEY_VALUE {
17381     pub Modulus: CRYPT_XML_DATA_BLOB,
17382     pub Exponent: CRYPT_XML_DATA_BLOB,
17383 }
17384 impl CRYPT_XML_KEY_RSA_KEY_VALUE {}
17385 impl ::std::default::Default for CRYPT_XML_KEY_RSA_KEY_VALUE {
default() -> Self17386     fn default() -> Self {
17387         unsafe { ::std::mem::zeroed() }
17388     }
17389 }
17390 impl ::std::fmt::Debug for CRYPT_XML_KEY_RSA_KEY_VALUE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result17391     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17392         fmt.debug_struct("CRYPT_XML_KEY_RSA_KEY_VALUE").field("Modulus", &self.Modulus).field("Exponent", &self.Exponent).finish()
17393     }
17394 }
17395 impl ::std::cmp::PartialEq for CRYPT_XML_KEY_RSA_KEY_VALUE {
eq(&self, other: &Self) -> bool17396     fn eq(&self, other: &Self) -> bool {
17397         self.Modulus == other.Modulus && self.Exponent == other.Exponent
17398     }
17399 }
17400 impl ::std::cmp::Eq for CRYPT_XML_KEY_RSA_KEY_VALUE {}
17401 unsafe impl ::windows::runtime::Abi for CRYPT_XML_KEY_RSA_KEY_VALUE {
17402     type Abi = Self;
17403     type DefaultType = Self;
17404 }
17405 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17406 #[repr(C)]
17407 #[cfg(feature = "Win32_Foundation")]
17408 pub struct CRYPT_XML_KEY_VALUE {
17409     pub dwType: CRYPT_XML_KEY_VALUE_TYPE,
17410     pub Anonymous: CRYPT_XML_KEY_VALUE_0,
17411 }
17412 #[cfg(feature = "Win32_Foundation")]
17413 impl CRYPT_XML_KEY_VALUE {}
17414 #[cfg(feature = "Win32_Foundation")]
17415 impl ::std::default::Default for CRYPT_XML_KEY_VALUE {
default() -> Self17416     fn default() -> Self {
17417         unsafe { ::std::mem::zeroed() }
17418     }
17419 }
17420 #[cfg(feature = "Win32_Foundation")]
17421 impl ::std::cmp::PartialEq for CRYPT_XML_KEY_VALUE {
eq(&self, _other: &Self) -> bool17422     fn eq(&self, _other: &Self) -> bool {
17423         unimplemented!()
17424     }
17425 }
17426 #[cfg(feature = "Win32_Foundation")]
17427 impl ::std::cmp::Eq for CRYPT_XML_KEY_VALUE {}
17428 #[cfg(feature = "Win32_Foundation")]
17429 unsafe impl ::windows::runtime::Abi for CRYPT_XML_KEY_VALUE {
17430     type Abi = Self;
17431     type DefaultType = Self;
17432 }
17433 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17434 #[repr(C)]
17435 #[cfg(feature = "Win32_Foundation")]
17436 pub union CRYPT_XML_KEY_VALUE_0 {
17437     pub DSAKeyValue: CRYPT_XML_KEY_DSA_KEY_VALUE,
17438     pub RSAKeyValue: CRYPT_XML_KEY_RSA_KEY_VALUE,
17439     pub ECDSAKeyValue: CRYPT_XML_KEY_ECDSA_KEY_VALUE,
17440     pub Custom: CRYPT_XML_BLOB,
17441 }
17442 #[cfg(feature = "Win32_Foundation")]
17443 impl CRYPT_XML_KEY_VALUE_0 {}
17444 #[cfg(feature = "Win32_Foundation")]
17445 impl ::std::default::Default for CRYPT_XML_KEY_VALUE_0 {
default() -> Self17446     fn default() -> Self {
17447         unsafe { ::std::mem::zeroed() }
17448     }
17449 }
17450 #[cfg(feature = "Win32_Foundation")]
17451 impl ::std::cmp::PartialEq for CRYPT_XML_KEY_VALUE_0 {
eq(&self, _other: &Self) -> bool17452     fn eq(&self, _other: &Self) -> bool {
17453         unimplemented!()
17454     }
17455 }
17456 #[cfg(feature = "Win32_Foundation")]
17457 impl ::std::cmp::Eq for CRYPT_XML_KEY_VALUE_0 {}
17458 #[cfg(feature = "Win32_Foundation")]
17459 unsafe impl ::windows::runtime::Abi for CRYPT_XML_KEY_VALUE_0 {
17460     type Abi = Self;
17461     type DefaultType = Self;
17462 }
17463 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
17464 #[repr(transparent)]
17465 pub struct CRYPT_XML_KEY_VALUE_TYPE(pub u32);
17466 pub const CRYPT_XML_KEY_VALUE_TYPE_DSA: CRYPT_XML_KEY_VALUE_TYPE = CRYPT_XML_KEY_VALUE_TYPE(1u32);
17467 pub const CRYPT_XML_KEY_VALUE_TYPE_RSA: CRYPT_XML_KEY_VALUE_TYPE = CRYPT_XML_KEY_VALUE_TYPE(2u32);
17468 pub const CRYPT_XML_KEY_VALUE_TYPE_ECDSA: CRYPT_XML_KEY_VALUE_TYPE = CRYPT_XML_KEY_VALUE_TYPE(3u32);
17469 pub const CRYPT_XML_KEY_VALUE_TYPE_CUSTOM: CRYPT_XML_KEY_VALUE_TYPE = CRYPT_XML_KEY_VALUE_TYPE(4u32);
17470 impl ::std::convert::From<u32> for CRYPT_XML_KEY_VALUE_TYPE {
from(value: u32) -> Self17471     fn from(value: u32) -> Self {
17472         Self(value)
17473     }
17474 }
17475 unsafe impl ::windows::runtime::Abi for CRYPT_XML_KEY_VALUE_TYPE {
17476     type Abi = Self;
17477     type DefaultType = Self;
17478 }
17479 impl ::std::ops::BitOr for CRYPT_XML_KEY_VALUE_TYPE {
17480     type Output = Self;
bitor(self, rhs: Self) -> Self17481     fn bitor(self, rhs: Self) -> Self {
17482         Self(self.0 | rhs.0)
17483     }
17484 }
17485 impl ::std::ops::BitAnd for CRYPT_XML_KEY_VALUE_TYPE {
17486     type Output = Self;
bitand(self, rhs: Self) -> Self17487     fn bitand(self, rhs: Self) -> Self {
17488         Self(self.0 & rhs.0)
17489     }
17490 }
17491 impl ::std::ops::BitOrAssign for CRYPT_XML_KEY_VALUE_TYPE {
bitor_assign(&mut self, rhs: Self)17492     fn bitor_assign(&mut self, rhs: Self) {
17493         self.0.bitor_assign(rhs.0)
17494     }
17495 }
17496 impl ::std::ops::BitAndAssign for CRYPT_XML_KEY_VALUE_TYPE {
bitand_assign(&mut self, rhs: Self)17497     fn bitand_assign(&mut self, rhs: Self) {
17498         self.0.bitand_assign(rhs.0)
17499     }
17500 }
17501 impl ::std::ops::Not for CRYPT_XML_KEY_VALUE_TYPE {
17502     type Output = Self;
not(self) -> Self17503     fn not(self) -> Self {
17504         Self(self.0.not())
17505     }
17506 }
17507 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17508 #[repr(C)]
17509 #[cfg(feature = "Win32_Foundation")]
17510 pub struct CRYPT_XML_OBJECT {
17511     pub cbSize: u32,
17512     pub hObject: *mut ::std::ffi::c_void,
17513     pub wszId: super::super::Foundation::PWSTR,
17514     pub wszMimeType: super::super::Foundation::PWSTR,
17515     pub wszEncoding: super::super::Foundation::PWSTR,
17516     pub Manifest: CRYPT_XML_REFERENCES,
17517     pub Encoded: CRYPT_XML_BLOB,
17518 }
17519 #[cfg(feature = "Win32_Foundation")]
17520 impl CRYPT_XML_OBJECT {}
17521 #[cfg(feature = "Win32_Foundation")]
17522 impl ::std::default::Default for CRYPT_XML_OBJECT {
default() -> Self17523     fn default() -> Self {
17524         unsafe { ::std::mem::zeroed() }
17525     }
17526 }
17527 #[cfg(feature = "Win32_Foundation")]
17528 impl ::std::fmt::Debug for CRYPT_XML_OBJECT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result17529     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17530         fmt.debug_struct("CRYPT_XML_OBJECT").field("cbSize", &self.cbSize).field("hObject", &self.hObject).field("wszId", &self.wszId).field("wszMimeType", &self.wszMimeType).field("wszEncoding", &self.wszEncoding).field("Manifest", &self.Manifest).field("Encoded", &self.Encoded).finish()
17531     }
17532 }
17533 #[cfg(feature = "Win32_Foundation")]
17534 impl ::std::cmp::PartialEq for CRYPT_XML_OBJECT {
eq(&self, other: &Self) -> bool17535     fn eq(&self, other: &Self) -> bool {
17536         self.cbSize == other.cbSize && self.hObject == other.hObject && self.wszId == other.wszId && self.wszMimeType == other.wszMimeType && self.wszEncoding == other.wszEncoding && self.Manifest == other.Manifest && self.Encoded == other.Encoded
17537     }
17538 }
17539 #[cfg(feature = "Win32_Foundation")]
17540 impl ::std::cmp::Eq for CRYPT_XML_OBJECT {}
17541 #[cfg(feature = "Win32_Foundation")]
17542 unsafe impl ::windows::runtime::Abi for CRYPT_XML_OBJECT {
17543     type Abi = Self;
17544     type DefaultType = Self;
17545 }
17546 pub const CRYPT_XML_OBJECTS_MAX: u32 = 256u32;
17547 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17548 #[repr(C)]
17549 pub struct CRYPT_XML_PROPERTY {
17550     pub dwPropId: CRYPT_XML_PROPERTY_ID,
17551     pub pvValue: *mut ::std::ffi::c_void,
17552     pub cbValue: u32,
17553 }
17554 impl CRYPT_XML_PROPERTY {}
17555 impl ::std::default::Default for CRYPT_XML_PROPERTY {
default() -> Self17556     fn default() -> Self {
17557         unsafe { ::std::mem::zeroed() }
17558     }
17559 }
17560 impl ::std::fmt::Debug for CRYPT_XML_PROPERTY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result17561     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17562         fmt.debug_struct("CRYPT_XML_PROPERTY").field("dwPropId", &self.dwPropId).field("pvValue", &self.pvValue).field("cbValue", &self.cbValue).finish()
17563     }
17564 }
17565 impl ::std::cmp::PartialEq for CRYPT_XML_PROPERTY {
eq(&self, other: &Self) -> bool17566     fn eq(&self, other: &Self) -> bool {
17567         self.dwPropId == other.dwPropId && self.pvValue == other.pvValue && self.cbValue == other.cbValue
17568     }
17569 }
17570 impl ::std::cmp::Eq for CRYPT_XML_PROPERTY {}
17571 unsafe impl ::windows::runtime::Abi for CRYPT_XML_PROPERTY {
17572     type Abi = Self;
17573     type DefaultType = Self;
17574 }
17575 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
17576 #[repr(transparent)]
17577 pub struct CRYPT_XML_PROPERTY_ID(pub i32);
17578 pub const CRYPT_XML_PROPERTY_MAX_HEAP_SIZE: CRYPT_XML_PROPERTY_ID = CRYPT_XML_PROPERTY_ID(1i32);
17579 pub const CRYPT_XML_PROPERTY_SIGNATURE_LOCATION: CRYPT_XML_PROPERTY_ID = CRYPT_XML_PROPERTY_ID(2i32);
17580 pub const CRYPT_XML_PROPERTY_MAX_SIGNATURES: CRYPT_XML_PROPERTY_ID = CRYPT_XML_PROPERTY_ID(3i32);
17581 pub const CRYPT_XML_PROPERTY_DOC_DECLARATION: CRYPT_XML_PROPERTY_ID = CRYPT_XML_PROPERTY_ID(4i32);
17582 pub const CRYPT_XML_PROPERTY_XML_OUTPUT_CHARSET: CRYPT_XML_PROPERTY_ID = CRYPT_XML_PROPERTY_ID(5i32);
17583 impl ::std::convert::From<i32> for CRYPT_XML_PROPERTY_ID {
from(value: i32) -> Self17584     fn from(value: i32) -> Self {
17585         Self(value)
17586     }
17587 }
17588 unsafe impl ::windows::runtime::Abi for CRYPT_XML_PROPERTY_ID {
17589     type Abi = Self;
17590     type DefaultType = Self;
17591 }
17592 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17593 #[repr(C)]
17594 #[cfg(feature = "Win32_Foundation")]
17595 pub struct CRYPT_XML_REFERENCE {
17596     pub cbSize: u32,
17597     pub hReference: *mut ::std::ffi::c_void,
17598     pub wszId: super::super::Foundation::PWSTR,
17599     pub wszUri: super::super::Foundation::PWSTR,
17600     pub wszType: super::super::Foundation::PWSTR,
17601     pub DigestMethod: CRYPT_XML_ALGORITHM,
17602     pub DigestValue: CRYPTOAPI_BLOB,
17603     pub cTransform: u32,
17604     pub rgTransform: *mut CRYPT_XML_ALGORITHM,
17605 }
17606 #[cfg(feature = "Win32_Foundation")]
17607 impl CRYPT_XML_REFERENCE {}
17608 #[cfg(feature = "Win32_Foundation")]
17609 impl ::std::default::Default for CRYPT_XML_REFERENCE {
default() -> Self17610     fn default() -> Self {
17611         unsafe { ::std::mem::zeroed() }
17612     }
17613 }
17614 #[cfg(feature = "Win32_Foundation")]
17615 impl ::std::fmt::Debug for CRYPT_XML_REFERENCE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result17616     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17617         fmt.debug_struct("CRYPT_XML_REFERENCE")
17618             .field("cbSize", &self.cbSize)
17619             .field("hReference", &self.hReference)
17620             .field("wszId", &self.wszId)
17621             .field("wszUri", &self.wszUri)
17622             .field("wszType", &self.wszType)
17623             .field("DigestMethod", &self.DigestMethod)
17624             .field("DigestValue", &self.DigestValue)
17625             .field("cTransform", &self.cTransform)
17626             .field("rgTransform", &self.rgTransform)
17627             .finish()
17628     }
17629 }
17630 #[cfg(feature = "Win32_Foundation")]
17631 impl ::std::cmp::PartialEq for CRYPT_XML_REFERENCE {
eq(&self, other: &Self) -> bool17632     fn eq(&self, other: &Self) -> bool {
17633         self.cbSize == other.cbSize && self.hReference == other.hReference && self.wszId == other.wszId && self.wszUri == other.wszUri && self.wszType == other.wszType && self.DigestMethod == other.DigestMethod && self.DigestValue == other.DigestValue && self.cTransform == other.cTransform && self.rgTransform == other.rgTransform
17634     }
17635 }
17636 #[cfg(feature = "Win32_Foundation")]
17637 impl ::std::cmp::Eq for CRYPT_XML_REFERENCE {}
17638 #[cfg(feature = "Win32_Foundation")]
17639 unsafe impl ::windows::runtime::Abi for CRYPT_XML_REFERENCE {
17640     type Abi = Self;
17641     type DefaultType = Self;
17642 }
17643 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17644 #[repr(C)]
17645 #[cfg(feature = "Win32_Foundation")]
17646 pub struct CRYPT_XML_REFERENCES {
17647     pub cReference: u32,
17648     pub rgpReference: *mut *mut CRYPT_XML_REFERENCE,
17649 }
17650 #[cfg(feature = "Win32_Foundation")]
17651 impl CRYPT_XML_REFERENCES {}
17652 #[cfg(feature = "Win32_Foundation")]
17653 impl ::std::default::Default for CRYPT_XML_REFERENCES {
default() -> Self17654     fn default() -> Self {
17655         unsafe { ::std::mem::zeroed() }
17656     }
17657 }
17658 #[cfg(feature = "Win32_Foundation")]
17659 impl ::std::fmt::Debug for CRYPT_XML_REFERENCES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result17660     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17661         fmt.debug_struct("CRYPT_XML_REFERENCES").field("cReference", &self.cReference).field("rgpReference", &self.rgpReference).finish()
17662     }
17663 }
17664 #[cfg(feature = "Win32_Foundation")]
17665 impl ::std::cmp::PartialEq for CRYPT_XML_REFERENCES {
eq(&self, other: &Self) -> bool17666     fn eq(&self, other: &Self) -> bool {
17667         self.cReference == other.cReference && self.rgpReference == other.rgpReference
17668     }
17669 }
17670 #[cfg(feature = "Win32_Foundation")]
17671 impl ::std::cmp::Eq for CRYPT_XML_REFERENCES {}
17672 #[cfg(feature = "Win32_Foundation")]
17673 unsafe impl ::windows::runtime::Abi for CRYPT_XML_REFERENCES {
17674     type Abi = Self;
17675     type DefaultType = Self;
17676 }
17677 pub const CRYPT_XML_REFERENCES_MAX: u32 = 32760u32;
17678 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17679 #[repr(C)]
17680 #[cfg(feature = "Win32_Foundation")]
17681 pub struct CRYPT_XML_SIGNATURE {
17682     pub cbSize: u32,
17683     pub hSignature: *mut ::std::ffi::c_void,
17684     pub wszId: super::super::Foundation::PWSTR,
17685     pub SignedInfo: CRYPT_XML_SIGNED_INFO,
17686     pub SignatureValue: CRYPTOAPI_BLOB,
17687     pub pKeyInfo: *mut CRYPT_XML_KEY_INFO,
17688     pub cObject: u32,
17689     pub rgpObject: *mut *mut CRYPT_XML_OBJECT,
17690 }
17691 #[cfg(feature = "Win32_Foundation")]
17692 impl CRYPT_XML_SIGNATURE {}
17693 #[cfg(feature = "Win32_Foundation")]
17694 impl ::std::default::Default for CRYPT_XML_SIGNATURE {
default() -> Self17695     fn default() -> Self {
17696         unsafe { ::std::mem::zeroed() }
17697     }
17698 }
17699 #[cfg(feature = "Win32_Foundation")]
17700 impl ::std::fmt::Debug for CRYPT_XML_SIGNATURE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result17701     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17702         fmt.debug_struct("CRYPT_XML_SIGNATURE")
17703             .field("cbSize", &self.cbSize)
17704             .field("hSignature", &self.hSignature)
17705             .field("wszId", &self.wszId)
17706             .field("SignedInfo", &self.SignedInfo)
17707             .field("SignatureValue", &self.SignatureValue)
17708             .field("pKeyInfo", &self.pKeyInfo)
17709             .field("cObject", &self.cObject)
17710             .field("rgpObject", &self.rgpObject)
17711             .finish()
17712     }
17713 }
17714 #[cfg(feature = "Win32_Foundation")]
17715 impl ::std::cmp::PartialEq for CRYPT_XML_SIGNATURE {
eq(&self, other: &Self) -> bool17716     fn eq(&self, other: &Self) -> bool {
17717         self.cbSize == other.cbSize && self.hSignature == other.hSignature && self.wszId == other.wszId && self.SignedInfo == other.SignedInfo && self.SignatureValue == other.SignatureValue && self.pKeyInfo == other.pKeyInfo && self.cObject == other.cObject && self.rgpObject == other.rgpObject
17718     }
17719 }
17720 #[cfg(feature = "Win32_Foundation")]
17721 impl ::std::cmp::Eq for CRYPT_XML_SIGNATURE {}
17722 #[cfg(feature = "Win32_Foundation")]
17723 unsafe impl ::windows::runtime::Abi for CRYPT_XML_SIGNATURE {
17724     type Abi = Self;
17725     type DefaultType = Self;
17726 }
17727 pub const CRYPT_XML_SIGNATURES_MAX: u32 = 16u32;
17728 pub const CRYPT_XML_SIGNATURE_VALUE_MAX: u32 = 2048u32;
17729 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17730 #[repr(C)]
17731 #[cfg(feature = "Win32_Foundation")]
17732 pub struct CRYPT_XML_SIGNED_INFO {
17733     pub cbSize: u32,
17734     pub wszId: super::super::Foundation::PWSTR,
17735     pub Canonicalization: CRYPT_XML_ALGORITHM,
17736     pub SignatureMethod: CRYPT_XML_ALGORITHM,
17737     pub cReference: u32,
17738     pub rgpReference: *mut *mut CRYPT_XML_REFERENCE,
17739     pub Encoded: CRYPT_XML_BLOB,
17740 }
17741 #[cfg(feature = "Win32_Foundation")]
17742 impl CRYPT_XML_SIGNED_INFO {}
17743 #[cfg(feature = "Win32_Foundation")]
17744 impl ::std::default::Default for CRYPT_XML_SIGNED_INFO {
default() -> Self17745     fn default() -> Self {
17746         unsafe { ::std::mem::zeroed() }
17747     }
17748 }
17749 #[cfg(feature = "Win32_Foundation")]
17750 impl ::std::fmt::Debug for CRYPT_XML_SIGNED_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result17751     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17752         fmt.debug_struct("CRYPT_XML_SIGNED_INFO")
17753             .field("cbSize", &self.cbSize)
17754             .field("wszId", &self.wszId)
17755             .field("Canonicalization", &self.Canonicalization)
17756             .field("SignatureMethod", &self.SignatureMethod)
17757             .field("cReference", &self.cReference)
17758             .field("rgpReference", &self.rgpReference)
17759             .field("Encoded", &self.Encoded)
17760             .finish()
17761     }
17762 }
17763 #[cfg(feature = "Win32_Foundation")]
17764 impl ::std::cmp::PartialEq for CRYPT_XML_SIGNED_INFO {
eq(&self, other: &Self) -> bool17765     fn eq(&self, other: &Self) -> bool {
17766         self.cbSize == other.cbSize && self.wszId == other.wszId && self.Canonicalization == other.Canonicalization && self.SignatureMethod == other.SignatureMethod && self.cReference == other.cReference && self.rgpReference == other.rgpReference && self.Encoded == other.Encoded
17767     }
17768 }
17769 #[cfg(feature = "Win32_Foundation")]
17770 impl ::std::cmp::Eq for CRYPT_XML_SIGNED_INFO {}
17771 #[cfg(feature = "Win32_Foundation")]
17772 unsafe impl ::windows::runtime::Abi for CRYPT_XML_SIGNED_INFO {
17773     type Abi = Self;
17774     type DefaultType = Self;
17775 }
17776 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17777 #[repr(C)]
17778 pub struct CRYPT_XML_STATUS {
17779     pub cbSize: u32,
17780     pub dwErrorStatus: CRYPT_XML_STATUS_ERROR_STATUS,
17781     pub dwInfoStatus: CRYPT_XML_STATUS_INFO_STATUS,
17782 }
17783 impl CRYPT_XML_STATUS {}
17784 impl ::std::default::Default for CRYPT_XML_STATUS {
default() -> Self17785     fn default() -> Self {
17786         unsafe { ::std::mem::zeroed() }
17787     }
17788 }
17789 impl ::std::fmt::Debug for CRYPT_XML_STATUS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result17790     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17791         fmt.debug_struct("CRYPT_XML_STATUS").field("cbSize", &self.cbSize).field("dwErrorStatus", &self.dwErrorStatus).field("dwInfoStatus", &self.dwInfoStatus).finish()
17792     }
17793 }
17794 impl ::std::cmp::PartialEq for CRYPT_XML_STATUS {
eq(&self, other: &Self) -> bool17795     fn eq(&self, other: &Self) -> bool {
17796         self.cbSize == other.cbSize && self.dwErrorStatus == other.dwErrorStatus && self.dwInfoStatus == other.dwInfoStatus
17797     }
17798 }
17799 impl ::std::cmp::Eq for CRYPT_XML_STATUS {}
17800 unsafe impl ::windows::runtime::Abi for CRYPT_XML_STATUS {
17801     type Abi = Self;
17802     type DefaultType = Self;
17803 }
17804 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
17805 #[repr(transparent)]
17806 pub struct CRYPT_XML_STATUS_ERROR_STATUS(pub u32);
17807 pub const CRYPT_XML_STATUS_ERROR_NOT_RESOLVED: CRYPT_XML_STATUS_ERROR_STATUS = CRYPT_XML_STATUS_ERROR_STATUS(1u32);
17808 pub const CRYPT_XML_STATUS_ERROR_DIGEST_INVALID: CRYPT_XML_STATUS_ERROR_STATUS = CRYPT_XML_STATUS_ERROR_STATUS(2u32);
17809 pub const CRYPT_XML_STATUS_ERROR_NOT_SUPPORTED_ALGORITHM: CRYPT_XML_STATUS_ERROR_STATUS = CRYPT_XML_STATUS_ERROR_STATUS(5u32);
17810 pub const CRYPT_XML_STATUS_ERROR_NOT_SUPPORTED_TRANSFORM: CRYPT_XML_STATUS_ERROR_STATUS = CRYPT_XML_STATUS_ERROR_STATUS(8u32);
17811 pub const CRYPT_XML_STATUS_ERROR_SIGNATURE_INVALID: CRYPT_XML_STATUS_ERROR_STATUS = CRYPT_XML_STATUS_ERROR_STATUS(65536u32);
17812 pub const CRYPT_XML_STATUS_ERROR_KEYINFO_NOT_PARSED: CRYPT_XML_STATUS_ERROR_STATUS = CRYPT_XML_STATUS_ERROR_STATUS(131072u32);
17813 impl ::std::convert::From<u32> for CRYPT_XML_STATUS_ERROR_STATUS {
from(value: u32) -> Self17814     fn from(value: u32) -> Self {
17815         Self(value)
17816     }
17817 }
17818 unsafe impl ::windows::runtime::Abi for CRYPT_XML_STATUS_ERROR_STATUS {
17819     type Abi = Self;
17820     type DefaultType = Self;
17821 }
17822 impl ::std::ops::BitOr for CRYPT_XML_STATUS_ERROR_STATUS {
17823     type Output = Self;
bitor(self, rhs: Self) -> Self17824     fn bitor(self, rhs: Self) -> Self {
17825         Self(self.0 | rhs.0)
17826     }
17827 }
17828 impl ::std::ops::BitAnd for CRYPT_XML_STATUS_ERROR_STATUS {
17829     type Output = Self;
bitand(self, rhs: Self) -> Self17830     fn bitand(self, rhs: Self) -> Self {
17831         Self(self.0 & rhs.0)
17832     }
17833 }
17834 impl ::std::ops::BitOrAssign for CRYPT_XML_STATUS_ERROR_STATUS {
bitor_assign(&mut self, rhs: Self)17835     fn bitor_assign(&mut self, rhs: Self) {
17836         self.0.bitor_assign(rhs.0)
17837     }
17838 }
17839 impl ::std::ops::BitAndAssign for CRYPT_XML_STATUS_ERROR_STATUS {
bitand_assign(&mut self, rhs: Self)17840     fn bitand_assign(&mut self, rhs: Self) {
17841         self.0.bitand_assign(rhs.0)
17842     }
17843 }
17844 impl ::std::ops::Not for CRYPT_XML_STATUS_ERROR_STATUS {
17845     type Output = Self;
not(self) -> Self17846     fn not(self) -> Self {
17847         Self(self.0.not())
17848     }
17849 }
17850 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
17851 #[repr(transparent)]
17852 pub struct CRYPT_XML_STATUS_INFO_STATUS(pub u32);
17853 pub const CRYPT_XML_STATUS_INTERNAL_REFERENCE: CRYPT_XML_STATUS_INFO_STATUS = CRYPT_XML_STATUS_INFO_STATUS(1u32);
17854 pub const CRYPT_XML_STATUS_KEY_AVAILABLE: CRYPT_XML_STATUS_INFO_STATUS = CRYPT_XML_STATUS_INFO_STATUS(2u32);
17855 pub const CRYPT_XML_STATUS_DIGESTING: CRYPT_XML_STATUS_INFO_STATUS = CRYPT_XML_STATUS_INFO_STATUS(4u32);
17856 pub const CRYPT_XML_STATUS_DIGEST_VALID: CRYPT_XML_STATUS_INFO_STATUS = CRYPT_XML_STATUS_INFO_STATUS(8u32);
17857 pub const CRYPT_XML_STATUS_SIGNATURE_VALID: CRYPT_XML_STATUS_INFO_STATUS = CRYPT_XML_STATUS_INFO_STATUS(65536u32);
17858 pub const CRYPT_XML_STATUS_OPENED_TO_ENCODE: CRYPT_XML_STATUS_INFO_STATUS = CRYPT_XML_STATUS_INFO_STATUS(2147483648u32);
17859 impl ::std::convert::From<u32> for CRYPT_XML_STATUS_INFO_STATUS {
from(value: u32) -> Self17860     fn from(value: u32) -> Self {
17861         Self(value)
17862     }
17863 }
17864 unsafe impl ::windows::runtime::Abi for CRYPT_XML_STATUS_INFO_STATUS {
17865     type Abi = Self;
17866     type DefaultType = Self;
17867 }
17868 impl ::std::ops::BitOr for CRYPT_XML_STATUS_INFO_STATUS {
17869     type Output = Self;
bitor(self, rhs: Self) -> Self17870     fn bitor(self, rhs: Self) -> Self {
17871         Self(self.0 | rhs.0)
17872     }
17873 }
17874 impl ::std::ops::BitAnd for CRYPT_XML_STATUS_INFO_STATUS {
17875     type Output = Self;
bitand(self, rhs: Self) -> Self17876     fn bitand(self, rhs: Self) -> Self {
17877         Self(self.0 & rhs.0)
17878     }
17879 }
17880 impl ::std::ops::BitOrAssign for CRYPT_XML_STATUS_INFO_STATUS {
bitor_assign(&mut self, rhs: Self)17881     fn bitor_assign(&mut self, rhs: Self) {
17882         self.0.bitor_assign(rhs.0)
17883     }
17884 }
17885 impl ::std::ops::BitAndAssign for CRYPT_XML_STATUS_INFO_STATUS {
bitand_assign(&mut self, rhs: Self)17886     fn bitand_assign(&mut self, rhs: Self) {
17887         self.0.bitand_assign(rhs.0)
17888     }
17889 }
17890 impl ::std::ops::Not for CRYPT_XML_STATUS_INFO_STATUS {
17891     type Output = Self;
not(self) -> Self17892     fn not(self) -> Self {
17893         Self(self.0.not())
17894     }
17895 }
17896 pub const CRYPT_XML_STATUS_NO_ERROR: u32 = 0u32;
17897 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17898 #[repr(C)]
17899 #[cfg(feature = "Win32_Foundation")]
17900 pub struct CRYPT_XML_TRANSFORM_CHAIN_CONFIG {
17901     pub cbSize: u32,
17902     pub cTransformInfo: u32,
17903     pub rgpTransformInfo: *mut *mut CRYPT_XML_TRANSFORM_INFO,
17904 }
17905 #[cfg(feature = "Win32_Foundation")]
17906 impl CRYPT_XML_TRANSFORM_CHAIN_CONFIG {}
17907 #[cfg(feature = "Win32_Foundation")]
17908 impl ::std::default::Default for CRYPT_XML_TRANSFORM_CHAIN_CONFIG {
default() -> Self17909     fn default() -> Self {
17910         unsafe { ::std::mem::zeroed() }
17911     }
17912 }
17913 #[cfg(feature = "Win32_Foundation")]
17914 impl ::std::fmt::Debug for CRYPT_XML_TRANSFORM_CHAIN_CONFIG {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result17915     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17916         fmt.debug_struct("CRYPT_XML_TRANSFORM_CHAIN_CONFIG").field("cbSize", &self.cbSize).field("cTransformInfo", &self.cTransformInfo).field("rgpTransformInfo", &self.rgpTransformInfo).finish()
17917     }
17918 }
17919 #[cfg(feature = "Win32_Foundation")]
17920 impl ::std::cmp::PartialEq for CRYPT_XML_TRANSFORM_CHAIN_CONFIG {
eq(&self, other: &Self) -> bool17921     fn eq(&self, other: &Self) -> bool {
17922         self.cbSize == other.cbSize && self.cTransformInfo == other.cTransformInfo && self.rgpTransformInfo == other.rgpTransformInfo
17923     }
17924 }
17925 #[cfg(feature = "Win32_Foundation")]
17926 impl ::std::cmp::Eq for CRYPT_XML_TRANSFORM_CHAIN_CONFIG {}
17927 #[cfg(feature = "Win32_Foundation")]
17928 unsafe impl ::windows::runtime::Abi for CRYPT_XML_TRANSFORM_CHAIN_CONFIG {
17929     type Abi = Self;
17930     type DefaultType = Self;
17931 }
17932 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
17933 #[repr(transparent)]
17934 pub struct CRYPT_XML_TRANSFORM_FLAGS(pub u32);
17935 pub const CRYPT_XML_TRANSFORM_ON_STREAM: CRYPT_XML_TRANSFORM_FLAGS = CRYPT_XML_TRANSFORM_FLAGS(1u32);
17936 pub const CRYPT_XML_TRANSFORM_ON_NODESET: CRYPT_XML_TRANSFORM_FLAGS = CRYPT_XML_TRANSFORM_FLAGS(2u32);
17937 pub const CRYPT_XML_TRANSFORM_URI_QUERY_STRING: CRYPT_XML_TRANSFORM_FLAGS = CRYPT_XML_TRANSFORM_FLAGS(3u32);
17938 impl ::std::convert::From<u32> for CRYPT_XML_TRANSFORM_FLAGS {
from(value: u32) -> Self17939     fn from(value: u32) -> Self {
17940         Self(value)
17941     }
17942 }
17943 unsafe impl ::windows::runtime::Abi for CRYPT_XML_TRANSFORM_FLAGS {
17944     type Abi = Self;
17945     type DefaultType = Self;
17946 }
17947 impl ::std::ops::BitOr for CRYPT_XML_TRANSFORM_FLAGS {
17948     type Output = Self;
bitor(self, rhs: Self) -> Self17949     fn bitor(self, rhs: Self) -> Self {
17950         Self(self.0 | rhs.0)
17951     }
17952 }
17953 impl ::std::ops::BitAnd for CRYPT_XML_TRANSFORM_FLAGS {
17954     type Output = Self;
bitand(self, rhs: Self) -> Self17955     fn bitand(self, rhs: Self) -> Self {
17956         Self(self.0 & rhs.0)
17957     }
17958 }
17959 impl ::std::ops::BitOrAssign for CRYPT_XML_TRANSFORM_FLAGS {
bitor_assign(&mut self, rhs: Self)17960     fn bitor_assign(&mut self, rhs: Self) {
17961         self.0.bitor_assign(rhs.0)
17962     }
17963 }
17964 impl ::std::ops::BitAndAssign for CRYPT_XML_TRANSFORM_FLAGS {
bitand_assign(&mut self, rhs: Self)17965     fn bitand_assign(&mut self, rhs: Self) {
17966         self.0.bitand_assign(rhs.0)
17967     }
17968 }
17969 impl ::std::ops::Not for CRYPT_XML_TRANSFORM_FLAGS {
17970     type Output = Self;
not(self) -> Self17971     fn not(self) -> Self {
17972         Self(self.0.not())
17973     }
17974 }
17975 #[derive(:: std :: clone :: Clone)]
17976 #[repr(C)]
17977 #[cfg(feature = "Win32_Foundation")]
17978 pub struct CRYPT_XML_TRANSFORM_INFO {
17979     pub cbSize: u32,
17980     pub wszAlgorithm: super::super::Foundation::PWSTR,
17981     pub cbBufferSize: u32,
17982     pub dwFlags: CRYPT_XML_TRANSFORM_FLAGS,
17983     pub pfnCreateTransform: ::std::option::Option<PFN_CRYPT_XML_CREATE_TRANSFORM>,
17984 }
17985 #[cfg(feature = "Win32_Foundation")]
17986 impl CRYPT_XML_TRANSFORM_INFO {}
17987 #[cfg(feature = "Win32_Foundation")]
17988 impl ::std::default::Default for CRYPT_XML_TRANSFORM_INFO {
default() -> Self17989     fn default() -> Self {
17990         unsafe { ::std::mem::zeroed() }
17991     }
17992 }
17993 #[cfg(feature = "Win32_Foundation")]
17994 impl ::std::fmt::Debug for CRYPT_XML_TRANSFORM_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result17995     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17996         fmt.debug_struct("CRYPT_XML_TRANSFORM_INFO").field("cbSize", &self.cbSize).field("wszAlgorithm", &self.wszAlgorithm).field("cbBufferSize", &self.cbBufferSize).field("dwFlags", &self.dwFlags).finish()
17997     }
17998 }
17999 #[cfg(feature = "Win32_Foundation")]
18000 impl ::std::cmp::PartialEq for CRYPT_XML_TRANSFORM_INFO {
eq(&self, other: &Self) -> bool18001     fn eq(&self, other: &Self) -> bool {
18002         self.cbSize == other.cbSize && self.wszAlgorithm == other.wszAlgorithm && self.cbBufferSize == other.cbBufferSize && self.dwFlags == other.dwFlags && self.pfnCreateTransform.map(|f| f as usize) == other.pfnCreateTransform.map(|f| f as usize)
18003     }
18004 }
18005 #[cfg(feature = "Win32_Foundation")]
18006 impl ::std::cmp::Eq for CRYPT_XML_TRANSFORM_INFO {}
18007 #[cfg(feature = "Win32_Foundation")]
18008 unsafe impl ::windows::runtime::Abi for CRYPT_XML_TRANSFORM_INFO {
18009     type Abi = ::std::mem::ManuallyDrop<Self>;
18010     type DefaultType = Self;
18011 }
18012 pub const CRYPT_XML_TRANSFORM_MAX: u32 = 16u32;
18013 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18014 #[repr(C)]
18015 #[cfg(feature = "Win32_Foundation")]
18016 pub struct CRYPT_XML_X509DATA {
18017     pub cX509Data: u32,
18018     pub rgX509Data: *mut CRYPT_XML_X509DATA_ITEM,
18019 }
18020 #[cfg(feature = "Win32_Foundation")]
18021 impl CRYPT_XML_X509DATA {}
18022 #[cfg(feature = "Win32_Foundation")]
18023 impl ::std::default::Default for CRYPT_XML_X509DATA {
default() -> Self18024     fn default() -> Self {
18025         unsafe { ::std::mem::zeroed() }
18026     }
18027 }
18028 #[cfg(feature = "Win32_Foundation")]
18029 impl ::std::fmt::Debug for CRYPT_XML_X509DATA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result18030     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18031         fmt.debug_struct("CRYPT_XML_X509DATA").field("cX509Data", &self.cX509Data).field("rgX509Data", &self.rgX509Data).finish()
18032     }
18033 }
18034 #[cfg(feature = "Win32_Foundation")]
18035 impl ::std::cmp::PartialEq for CRYPT_XML_X509DATA {
eq(&self, other: &Self) -> bool18036     fn eq(&self, other: &Self) -> bool {
18037         self.cX509Data == other.cX509Data && self.rgX509Data == other.rgX509Data
18038     }
18039 }
18040 #[cfg(feature = "Win32_Foundation")]
18041 impl ::std::cmp::Eq for CRYPT_XML_X509DATA {}
18042 #[cfg(feature = "Win32_Foundation")]
18043 unsafe impl ::windows::runtime::Abi for CRYPT_XML_X509DATA {
18044     type Abi = Self;
18045     type DefaultType = Self;
18046 }
18047 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18048 #[repr(C)]
18049 #[cfg(feature = "Win32_Foundation")]
18050 pub struct CRYPT_XML_X509DATA_ITEM {
18051     pub dwType: CRYPT_XML_X509DATA_TYPE,
18052     pub Anonymous: CRYPT_XML_X509DATA_ITEM_0,
18053 }
18054 #[cfg(feature = "Win32_Foundation")]
18055 impl CRYPT_XML_X509DATA_ITEM {}
18056 #[cfg(feature = "Win32_Foundation")]
18057 impl ::std::default::Default for CRYPT_XML_X509DATA_ITEM {
default() -> Self18058     fn default() -> Self {
18059         unsafe { ::std::mem::zeroed() }
18060     }
18061 }
18062 #[cfg(feature = "Win32_Foundation")]
18063 impl ::std::cmp::PartialEq for CRYPT_XML_X509DATA_ITEM {
eq(&self, _other: &Self) -> bool18064     fn eq(&self, _other: &Self) -> bool {
18065         unimplemented!()
18066     }
18067 }
18068 #[cfg(feature = "Win32_Foundation")]
18069 impl ::std::cmp::Eq for CRYPT_XML_X509DATA_ITEM {}
18070 #[cfg(feature = "Win32_Foundation")]
18071 unsafe impl ::windows::runtime::Abi for CRYPT_XML_X509DATA_ITEM {
18072     type Abi = Self;
18073     type DefaultType = Self;
18074 }
18075 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18076 #[repr(C)]
18077 #[cfg(feature = "Win32_Foundation")]
18078 pub union CRYPT_XML_X509DATA_ITEM_0 {
18079     pub IssuerSerial: CRYPT_XML_ISSUER_SERIAL,
18080     pub SKI: CRYPT_XML_DATA_BLOB,
18081     pub wszSubjectName: super::super::Foundation::PWSTR,
18082     pub Certificate: CRYPT_XML_DATA_BLOB,
18083     pub CRL: CRYPT_XML_DATA_BLOB,
18084     pub Custom: CRYPT_XML_BLOB,
18085 }
18086 #[cfg(feature = "Win32_Foundation")]
18087 impl CRYPT_XML_X509DATA_ITEM_0 {}
18088 #[cfg(feature = "Win32_Foundation")]
18089 impl ::std::default::Default for CRYPT_XML_X509DATA_ITEM_0 {
default() -> Self18090     fn default() -> Self {
18091         unsafe { ::std::mem::zeroed() }
18092     }
18093 }
18094 #[cfg(feature = "Win32_Foundation")]
18095 impl ::std::cmp::PartialEq for CRYPT_XML_X509DATA_ITEM_0 {
eq(&self, _other: &Self) -> bool18096     fn eq(&self, _other: &Self) -> bool {
18097         unimplemented!()
18098     }
18099 }
18100 #[cfg(feature = "Win32_Foundation")]
18101 impl ::std::cmp::Eq for CRYPT_XML_X509DATA_ITEM_0 {}
18102 #[cfg(feature = "Win32_Foundation")]
18103 unsafe impl ::windows::runtime::Abi for CRYPT_XML_X509DATA_ITEM_0 {
18104     type Abi = Self;
18105     type DefaultType = Self;
18106 }
18107 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
18108 #[repr(transparent)]
18109 pub struct CRYPT_XML_X509DATA_TYPE(pub u32);
18110 pub const CRYPT_XML_X509DATA_TYPE_ISSUER_SERIAL: CRYPT_XML_X509DATA_TYPE = CRYPT_XML_X509DATA_TYPE(1u32);
18111 pub const CRYPT_XML_X509DATA_TYPE_SKI: CRYPT_XML_X509DATA_TYPE = CRYPT_XML_X509DATA_TYPE(2u32);
18112 pub const CRYPT_XML_X509DATA_TYPE_SUBJECT_NAME: CRYPT_XML_X509DATA_TYPE = CRYPT_XML_X509DATA_TYPE(3u32);
18113 pub const CRYPT_XML_X509DATA_TYPE_CERTIFICATE: CRYPT_XML_X509DATA_TYPE = CRYPT_XML_X509DATA_TYPE(4u32);
18114 pub const CRYPT_XML_X509DATA_TYPE_CRL: CRYPT_XML_X509DATA_TYPE = CRYPT_XML_X509DATA_TYPE(5u32);
18115 pub const CRYPT_XML_X509DATA_TYPE_CUSTOM: CRYPT_XML_X509DATA_TYPE = CRYPT_XML_X509DATA_TYPE(6u32);
18116 impl ::std::convert::From<u32> for CRYPT_XML_X509DATA_TYPE {
from(value: u32) -> Self18117     fn from(value: u32) -> Self {
18118         Self(value)
18119     }
18120 }
18121 unsafe impl ::windows::runtime::Abi for CRYPT_XML_X509DATA_TYPE {
18122     type Abi = Self;
18123     type DefaultType = Self;
18124 }
18125 impl ::std::ops::BitOr for CRYPT_XML_X509DATA_TYPE {
18126     type Output = Self;
bitor(self, rhs: Self) -> Self18127     fn bitor(self, rhs: Self) -> Self {
18128         Self(self.0 | rhs.0)
18129     }
18130 }
18131 impl ::std::ops::BitAnd for CRYPT_XML_X509DATA_TYPE {
18132     type Output = Self;
bitand(self, rhs: Self) -> Self18133     fn bitand(self, rhs: Self) -> Self {
18134         Self(self.0 & rhs.0)
18135     }
18136 }
18137 impl ::std::ops::BitOrAssign for CRYPT_XML_X509DATA_TYPE {
bitor_assign(&mut self, rhs: Self)18138     fn bitor_assign(&mut self, rhs: Self) {
18139         self.0.bitor_assign(rhs.0)
18140     }
18141 }
18142 impl ::std::ops::BitAndAssign for CRYPT_XML_X509DATA_TYPE {
bitand_assign(&mut self, rhs: Self)18143     fn bitand_assign(&mut self, rhs: Self) {
18144         self.0.bitand_assign(rhs.0)
18145     }
18146 }
18147 impl ::std::ops::Not for CRYPT_XML_X509DATA_TYPE {
18148     type Output = Self;
not(self) -> Self18149     fn not(self) -> Self {
18150         Self(self.0.not())
18151     }
18152 }
18153 pub const CRYTPDLG_FLAGS_MASK: u32 = 4278190080u32;
18154 pub const CSS_SELECTCERT_MASK: u32 = 16777215u32;
18155 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18156 #[repr(C)]
18157 #[cfg(feature = "Win32_Foundation")]
18158 pub struct CTL_ANY_SUBJECT_INFO {
18159     pub SubjectAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
18160     pub SubjectIdentifier: CRYPTOAPI_BLOB,
18161 }
18162 #[cfg(feature = "Win32_Foundation")]
18163 impl CTL_ANY_SUBJECT_INFO {}
18164 #[cfg(feature = "Win32_Foundation")]
18165 impl ::std::default::Default for CTL_ANY_SUBJECT_INFO {
default() -> Self18166     fn default() -> Self {
18167         unsafe { ::std::mem::zeroed() }
18168     }
18169 }
18170 #[cfg(feature = "Win32_Foundation")]
18171 impl ::std::fmt::Debug for CTL_ANY_SUBJECT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result18172     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18173         fmt.debug_struct("CTL_ANY_SUBJECT_INFO").field("SubjectAlgorithm", &self.SubjectAlgorithm).field("SubjectIdentifier", &self.SubjectIdentifier).finish()
18174     }
18175 }
18176 #[cfg(feature = "Win32_Foundation")]
18177 impl ::std::cmp::PartialEq for CTL_ANY_SUBJECT_INFO {
eq(&self, other: &Self) -> bool18178     fn eq(&self, other: &Self) -> bool {
18179         self.SubjectAlgorithm == other.SubjectAlgorithm && self.SubjectIdentifier == other.SubjectIdentifier
18180     }
18181 }
18182 #[cfg(feature = "Win32_Foundation")]
18183 impl ::std::cmp::Eq for CTL_ANY_SUBJECT_INFO {}
18184 #[cfg(feature = "Win32_Foundation")]
18185 unsafe impl ::windows::runtime::Abi for CTL_ANY_SUBJECT_INFO {
18186     type Abi = Self;
18187     type DefaultType = Self;
18188 }
18189 pub const CTL_ANY_SUBJECT_TYPE: u32 = 1u32;
18190 pub const CTL_CERT_SUBJECT_TYPE: u32 = 2u32;
18191 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18192 #[repr(C)]
18193 #[cfg(feature = "Win32_Foundation")]
18194 pub struct CTL_CONTEXT {
18195     pub dwMsgAndCertEncodingType: u32,
18196     pub pbCtlEncoded: *mut u8,
18197     pub cbCtlEncoded: u32,
18198     pub pCtlInfo: *mut CTL_INFO,
18199     pub hCertStore: *mut ::std::ffi::c_void,
18200     pub hCryptMsg: *mut ::std::ffi::c_void,
18201     pub pbCtlContent: *mut u8,
18202     pub cbCtlContent: u32,
18203 }
18204 #[cfg(feature = "Win32_Foundation")]
18205 impl CTL_CONTEXT {}
18206 #[cfg(feature = "Win32_Foundation")]
18207 impl ::std::default::Default for CTL_CONTEXT {
default() -> Self18208     fn default() -> Self {
18209         unsafe { ::std::mem::zeroed() }
18210     }
18211 }
18212 #[cfg(feature = "Win32_Foundation")]
18213 impl ::std::fmt::Debug for CTL_CONTEXT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result18214     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18215         fmt.debug_struct("CTL_CONTEXT")
18216             .field("dwMsgAndCertEncodingType", &self.dwMsgAndCertEncodingType)
18217             .field("pbCtlEncoded", &self.pbCtlEncoded)
18218             .field("cbCtlEncoded", &self.cbCtlEncoded)
18219             .field("pCtlInfo", &self.pCtlInfo)
18220             .field("hCertStore", &self.hCertStore)
18221             .field("hCryptMsg", &self.hCryptMsg)
18222             .field("pbCtlContent", &self.pbCtlContent)
18223             .field("cbCtlContent", &self.cbCtlContent)
18224             .finish()
18225     }
18226 }
18227 #[cfg(feature = "Win32_Foundation")]
18228 impl ::std::cmp::PartialEq for CTL_CONTEXT {
eq(&self, other: &Self) -> bool18229     fn eq(&self, other: &Self) -> bool {
18230         self.dwMsgAndCertEncodingType == other.dwMsgAndCertEncodingType && self.pbCtlEncoded == other.pbCtlEncoded && self.cbCtlEncoded == other.cbCtlEncoded && self.pCtlInfo == other.pCtlInfo && self.hCertStore == other.hCertStore && self.hCryptMsg == other.hCryptMsg && self.pbCtlContent == other.pbCtlContent && self.cbCtlContent == other.cbCtlContent
18231     }
18232 }
18233 #[cfg(feature = "Win32_Foundation")]
18234 impl ::std::cmp::Eq for CTL_CONTEXT {}
18235 #[cfg(feature = "Win32_Foundation")]
18236 unsafe impl ::windows::runtime::Abi for CTL_CONTEXT {
18237     type Abi = Self;
18238     type DefaultType = Self;
18239 }
18240 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18241 #[repr(C)]
18242 #[cfg(feature = "Win32_Foundation")]
18243 pub struct CTL_ENTRY {
18244     pub SubjectIdentifier: CRYPTOAPI_BLOB,
18245     pub cAttribute: u32,
18246     pub rgAttribute: *mut CRYPT_ATTRIBUTE,
18247 }
18248 #[cfg(feature = "Win32_Foundation")]
18249 impl CTL_ENTRY {}
18250 #[cfg(feature = "Win32_Foundation")]
18251 impl ::std::default::Default for CTL_ENTRY {
default() -> Self18252     fn default() -> Self {
18253         unsafe { ::std::mem::zeroed() }
18254     }
18255 }
18256 #[cfg(feature = "Win32_Foundation")]
18257 impl ::std::fmt::Debug for CTL_ENTRY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result18258     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18259         fmt.debug_struct("CTL_ENTRY").field("SubjectIdentifier", &self.SubjectIdentifier).field("cAttribute", &self.cAttribute).field("rgAttribute", &self.rgAttribute).finish()
18260     }
18261 }
18262 #[cfg(feature = "Win32_Foundation")]
18263 impl ::std::cmp::PartialEq for CTL_ENTRY {
eq(&self, other: &Self) -> bool18264     fn eq(&self, other: &Self) -> bool {
18265         self.SubjectIdentifier == other.SubjectIdentifier && self.cAttribute == other.cAttribute && self.rgAttribute == other.rgAttribute
18266     }
18267 }
18268 #[cfg(feature = "Win32_Foundation")]
18269 impl ::std::cmp::Eq for CTL_ENTRY {}
18270 #[cfg(feature = "Win32_Foundation")]
18271 unsafe impl ::windows::runtime::Abi for CTL_ENTRY {
18272     type Abi = Self;
18273     type DefaultType = Self;
18274 }
18275 pub const CTL_ENTRY_FROM_PROP_CHAIN_FLAG: u32 = 1u32;
18276 pub const CTL_FIND_NO_LIST_ID_CBDATA: u32 = 4294967295u32;
18277 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18278 #[repr(C)]
18279 #[cfg(feature = "Win32_Foundation")]
18280 pub struct CTL_FIND_SUBJECT_PARA {
18281     pub cbSize: u32,
18282     pub pUsagePara: *mut CTL_FIND_USAGE_PARA,
18283     pub dwSubjectType: u32,
18284     pub pvSubject: *mut ::std::ffi::c_void,
18285 }
18286 #[cfg(feature = "Win32_Foundation")]
18287 impl CTL_FIND_SUBJECT_PARA {}
18288 #[cfg(feature = "Win32_Foundation")]
18289 impl ::std::default::Default for CTL_FIND_SUBJECT_PARA {
default() -> Self18290     fn default() -> Self {
18291         unsafe { ::std::mem::zeroed() }
18292     }
18293 }
18294 #[cfg(feature = "Win32_Foundation")]
18295 impl ::std::fmt::Debug for CTL_FIND_SUBJECT_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result18296     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18297         fmt.debug_struct("CTL_FIND_SUBJECT_PARA").field("cbSize", &self.cbSize).field("pUsagePara", &self.pUsagePara).field("dwSubjectType", &self.dwSubjectType).field("pvSubject", &self.pvSubject).finish()
18298     }
18299 }
18300 #[cfg(feature = "Win32_Foundation")]
18301 impl ::std::cmp::PartialEq for CTL_FIND_SUBJECT_PARA {
eq(&self, other: &Self) -> bool18302     fn eq(&self, other: &Self) -> bool {
18303         self.cbSize == other.cbSize && self.pUsagePara == other.pUsagePara && self.dwSubjectType == other.dwSubjectType && self.pvSubject == other.pvSubject
18304     }
18305 }
18306 #[cfg(feature = "Win32_Foundation")]
18307 impl ::std::cmp::Eq for CTL_FIND_SUBJECT_PARA {}
18308 #[cfg(feature = "Win32_Foundation")]
18309 unsafe impl ::windows::runtime::Abi for CTL_FIND_SUBJECT_PARA {
18310     type Abi = Self;
18311     type DefaultType = Self;
18312 }
18313 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18314 #[repr(C)]
18315 #[cfg(feature = "Win32_Foundation")]
18316 pub struct CTL_FIND_USAGE_PARA {
18317     pub cbSize: u32,
18318     pub SubjectUsage: CTL_USAGE,
18319     pub ListIdentifier: CRYPTOAPI_BLOB,
18320     pub pSigner: *mut CERT_INFO,
18321 }
18322 #[cfg(feature = "Win32_Foundation")]
18323 impl CTL_FIND_USAGE_PARA {}
18324 #[cfg(feature = "Win32_Foundation")]
18325 impl ::std::default::Default for CTL_FIND_USAGE_PARA {
default() -> Self18326     fn default() -> Self {
18327         unsafe { ::std::mem::zeroed() }
18328     }
18329 }
18330 #[cfg(feature = "Win32_Foundation")]
18331 impl ::std::fmt::Debug for CTL_FIND_USAGE_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result18332     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18333         fmt.debug_struct("CTL_FIND_USAGE_PARA").field("cbSize", &self.cbSize).field("SubjectUsage", &self.SubjectUsage).field("ListIdentifier", &self.ListIdentifier).field("pSigner", &self.pSigner).finish()
18334     }
18335 }
18336 #[cfg(feature = "Win32_Foundation")]
18337 impl ::std::cmp::PartialEq for CTL_FIND_USAGE_PARA {
eq(&self, other: &Self) -> bool18338     fn eq(&self, other: &Self) -> bool {
18339         self.cbSize == other.cbSize && self.SubjectUsage == other.SubjectUsage && self.ListIdentifier == other.ListIdentifier && self.pSigner == other.pSigner
18340     }
18341 }
18342 #[cfg(feature = "Win32_Foundation")]
18343 impl ::std::cmp::Eq for CTL_FIND_USAGE_PARA {}
18344 #[cfg(feature = "Win32_Foundation")]
18345 unsafe impl ::windows::runtime::Abi for CTL_FIND_USAGE_PARA {
18346     type Abi = Self;
18347     type DefaultType = Self;
18348 }
18349 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18350 #[repr(C)]
18351 #[cfg(feature = "Win32_Foundation")]
18352 pub struct CTL_INFO {
18353     pub dwVersion: u32,
18354     pub SubjectUsage: CTL_USAGE,
18355     pub ListIdentifier: CRYPTOAPI_BLOB,
18356     pub SequenceNumber: CRYPTOAPI_BLOB,
18357     pub ThisUpdate: super::super::Foundation::FILETIME,
18358     pub NextUpdate: super::super::Foundation::FILETIME,
18359     pub SubjectAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
18360     pub cCTLEntry: u32,
18361     pub rgCTLEntry: *mut CTL_ENTRY,
18362     pub cExtension: u32,
18363     pub rgExtension: *mut CERT_EXTENSION,
18364 }
18365 #[cfg(feature = "Win32_Foundation")]
18366 impl CTL_INFO {}
18367 #[cfg(feature = "Win32_Foundation")]
18368 impl ::std::default::Default for CTL_INFO {
default() -> Self18369     fn default() -> Self {
18370         unsafe { ::std::mem::zeroed() }
18371     }
18372 }
18373 #[cfg(feature = "Win32_Foundation")]
18374 impl ::std::fmt::Debug for CTL_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result18375     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18376         fmt.debug_struct("CTL_INFO")
18377             .field("dwVersion", &self.dwVersion)
18378             .field("SubjectUsage", &self.SubjectUsage)
18379             .field("ListIdentifier", &self.ListIdentifier)
18380             .field("SequenceNumber", &self.SequenceNumber)
18381             .field("ThisUpdate", &self.ThisUpdate)
18382             .field("NextUpdate", &self.NextUpdate)
18383             .field("SubjectAlgorithm", &self.SubjectAlgorithm)
18384             .field("cCTLEntry", &self.cCTLEntry)
18385             .field("rgCTLEntry", &self.rgCTLEntry)
18386             .field("cExtension", &self.cExtension)
18387             .field("rgExtension", &self.rgExtension)
18388             .finish()
18389     }
18390 }
18391 #[cfg(feature = "Win32_Foundation")]
18392 impl ::std::cmp::PartialEq for CTL_INFO {
eq(&self, other: &Self) -> bool18393     fn eq(&self, other: &Self) -> bool {
18394         self.dwVersion == other.dwVersion && self.SubjectUsage == other.SubjectUsage && self.ListIdentifier == other.ListIdentifier && self.SequenceNumber == other.SequenceNumber && self.ThisUpdate == other.ThisUpdate && self.NextUpdate == other.NextUpdate && self.SubjectAlgorithm == other.SubjectAlgorithm && self.cCTLEntry == other.cCTLEntry && self.rgCTLEntry == other.rgCTLEntry && self.cExtension == other.cExtension && self.rgExtension == other.rgExtension
18395     }
18396 }
18397 #[cfg(feature = "Win32_Foundation")]
18398 impl ::std::cmp::Eq for CTL_INFO {}
18399 #[cfg(feature = "Win32_Foundation")]
18400 unsafe impl ::windows::runtime::Abi for CTL_INFO {
18401     type Abi = Self;
18402     type DefaultType = Self;
18403 }
18404 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18405 #[repr(C)]
18406 #[cfg(feature = "Win32_Foundation")]
18407 pub struct CTL_MODIFY_REQUEST {
18408     pub pccert: *mut CERT_CONTEXT,
18409     pub dwOperation: CTL_MODIFY_REQUEST_OPERATION,
18410     pub dwError: u32,
18411 }
18412 #[cfg(feature = "Win32_Foundation")]
18413 impl CTL_MODIFY_REQUEST {}
18414 #[cfg(feature = "Win32_Foundation")]
18415 impl ::std::default::Default for CTL_MODIFY_REQUEST {
default() -> Self18416     fn default() -> Self {
18417         unsafe { ::std::mem::zeroed() }
18418     }
18419 }
18420 #[cfg(feature = "Win32_Foundation")]
18421 impl ::std::fmt::Debug for CTL_MODIFY_REQUEST {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result18422     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18423         fmt.debug_struct("CTL_MODIFY_REQUEST").field("pccert", &self.pccert).field("dwOperation", &self.dwOperation).field("dwError", &self.dwError).finish()
18424     }
18425 }
18426 #[cfg(feature = "Win32_Foundation")]
18427 impl ::std::cmp::PartialEq for CTL_MODIFY_REQUEST {
eq(&self, other: &Self) -> bool18428     fn eq(&self, other: &Self) -> bool {
18429         self.pccert == other.pccert && self.dwOperation == other.dwOperation && self.dwError == other.dwError
18430     }
18431 }
18432 #[cfg(feature = "Win32_Foundation")]
18433 impl ::std::cmp::Eq for CTL_MODIFY_REQUEST {}
18434 #[cfg(feature = "Win32_Foundation")]
18435 unsafe impl ::windows::runtime::Abi for CTL_MODIFY_REQUEST {
18436     type Abi = Self;
18437     type DefaultType = Self;
18438 }
18439 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
18440 #[repr(transparent)]
18441 pub struct CTL_MODIFY_REQUEST_OPERATION(pub u32);
18442 pub const CTL_MODIFY_REQUEST_ADD_TRUSTED: CTL_MODIFY_REQUEST_OPERATION = CTL_MODIFY_REQUEST_OPERATION(3u32);
18443 pub const CTL_MODIFY_REQUEST_ADD_NOT_TRUSTED: CTL_MODIFY_REQUEST_OPERATION = CTL_MODIFY_REQUEST_OPERATION(1u32);
18444 pub const CTL_MODIFY_REQUEST_REMOVE: CTL_MODIFY_REQUEST_OPERATION = CTL_MODIFY_REQUEST_OPERATION(2u32);
18445 impl ::std::convert::From<u32> for CTL_MODIFY_REQUEST_OPERATION {
from(value: u32) -> Self18446     fn from(value: u32) -> Self {
18447         Self(value)
18448     }
18449 }
18450 unsafe impl ::windows::runtime::Abi for CTL_MODIFY_REQUEST_OPERATION {
18451     type Abi = Self;
18452     type DefaultType = Self;
18453 }
18454 impl ::std::ops::BitOr for CTL_MODIFY_REQUEST_OPERATION {
18455     type Output = Self;
bitor(self, rhs: Self) -> Self18456     fn bitor(self, rhs: Self) -> Self {
18457         Self(self.0 | rhs.0)
18458     }
18459 }
18460 impl ::std::ops::BitAnd for CTL_MODIFY_REQUEST_OPERATION {
18461     type Output = Self;
bitand(self, rhs: Self) -> Self18462     fn bitand(self, rhs: Self) -> Self {
18463         Self(self.0 & rhs.0)
18464     }
18465 }
18466 impl ::std::ops::BitOrAssign for CTL_MODIFY_REQUEST_OPERATION {
bitor_assign(&mut self, rhs: Self)18467     fn bitor_assign(&mut self, rhs: Self) {
18468         self.0.bitor_assign(rhs.0)
18469     }
18470 }
18471 impl ::std::ops::BitAndAssign for CTL_MODIFY_REQUEST_OPERATION {
bitand_assign(&mut self, rhs: Self)18472     fn bitand_assign(&mut self, rhs: Self) {
18473         self.0.bitand_assign(rhs.0)
18474     }
18475 }
18476 impl ::std::ops::Not for CTL_MODIFY_REQUEST_OPERATION {
18477     type Output = Self;
not(self) -> Self18478     fn not(self) -> Self {
18479         Self(self.0.not())
18480     }
18481 }
18482 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18483 #[repr(C)]
18484 #[cfg(feature = "Win32_Foundation")]
18485 pub struct CTL_USAGE {
18486     pub cUsageIdentifier: u32,
18487     pub rgpszUsageIdentifier: *mut super::super::Foundation::PSTR,
18488 }
18489 #[cfg(feature = "Win32_Foundation")]
18490 impl CTL_USAGE {}
18491 #[cfg(feature = "Win32_Foundation")]
18492 impl ::std::default::Default for CTL_USAGE {
default() -> Self18493     fn default() -> Self {
18494         unsafe { ::std::mem::zeroed() }
18495     }
18496 }
18497 #[cfg(feature = "Win32_Foundation")]
18498 impl ::std::fmt::Debug for CTL_USAGE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result18499     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18500         fmt.debug_struct("CTL_USAGE").field("cUsageIdentifier", &self.cUsageIdentifier).field("rgpszUsageIdentifier", &self.rgpszUsageIdentifier).finish()
18501     }
18502 }
18503 #[cfg(feature = "Win32_Foundation")]
18504 impl ::std::cmp::PartialEq for CTL_USAGE {
eq(&self, other: &Self) -> bool18505     fn eq(&self, other: &Self) -> bool {
18506         self.cUsageIdentifier == other.cUsageIdentifier && self.rgpszUsageIdentifier == other.rgpszUsageIdentifier
18507     }
18508 }
18509 #[cfg(feature = "Win32_Foundation")]
18510 impl ::std::cmp::Eq for CTL_USAGE {}
18511 #[cfg(feature = "Win32_Foundation")]
18512 unsafe impl ::windows::runtime::Abi for CTL_USAGE {
18513     type Abi = Self;
18514     type DefaultType = Self;
18515 }
18516 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18517 #[repr(C)]
18518 #[cfg(feature = "Win32_Foundation")]
18519 pub struct CTL_USAGE_MATCH {
18520     pub dwType: u32,
18521     pub Usage: CTL_USAGE,
18522 }
18523 #[cfg(feature = "Win32_Foundation")]
18524 impl CTL_USAGE_MATCH {}
18525 #[cfg(feature = "Win32_Foundation")]
18526 impl ::std::default::Default for CTL_USAGE_MATCH {
default() -> Self18527     fn default() -> Self {
18528         unsafe { ::std::mem::zeroed() }
18529     }
18530 }
18531 #[cfg(feature = "Win32_Foundation")]
18532 impl ::std::fmt::Debug for CTL_USAGE_MATCH {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result18533     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18534         fmt.debug_struct("CTL_USAGE_MATCH").field("dwType", &self.dwType).field("Usage", &self.Usage).finish()
18535     }
18536 }
18537 #[cfg(feature = "Win32_Foundation")]
18538 impl ::std::cmp::PartialEq for CTL_USAGE_MATCH {
eq(&self, other: &Self) -> bool18539     fn eq(&self, other: &Self) -> bool {
18540         self.dwType == other.dwType && self.Usage == other.Usage
18541     }
18542 }
18543 #[cfg(feature = "Win32_Foundation")]
18544 impl ::std::cmp::Eq for CTL_USAGE_MATCH {}
18545 #[cfg(feature = "Win32_Foundation")]
18546 unsafe impl ::windows::runtime::Abi for CTL_USAGE_MATCH {
18547     type Abi = Self;
18548     type DefaultType = Self;
18549 }
18550 pub const CTL_V1: u32 = 0u32;
18551 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18552 #[repr(C)]
18553 pub struct CTL_VERIFY_USAGE_PARA {
18554     pub cbSize: u32,
18555     pub ListIdentifier: CRYPTOAPI_BLOB,
18556     pub cCtlStore: u32,
18557     pub rghCtlStore: *mut *mut ::std::ffi::c_void,
18558     pub cSignerStore: u32,
18559     pub rghSignerStore: *mut *mut ::std::ffi::c_void,
18560 }
18561 impl CTL_VERIFY_USAGE_PARA {}
18562 impl ::std::default::Default for CTL_VERIFY_USAGE_PARA {
default() -> Self18563     fn default() -> Self {
18564         unsafe { ::std::mem::zeroed() }
18565     }
18566 }
18567 impl ::std::fmt::Debug for CTL_VERIFY_USAGE_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result18568     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18569         fmt.debug_struct("CTL_VERIFY_USAGE_PARA").field("cbSize", &self.cbSize).field("ListIdentifier", &self.ListIdentifier).field("cCtlStore", &self.cCtlStore).field("rghCtlStore", &self.rghCtlStore).field("cSignerStore", &self.cSignerStore).field("rghSignerStore", &self.rghSignerStore).finish()
18570     }
18571 }
18572 impl ::std::cmp::PartialEq for CTL_VERIFY_USAGE_PARA {
eq(&self, other: &Self) -> bool18573     fn eq(&self, other: &Self) -> bool {
18574         self.cbSize == other.cbSize && self.ListIdentifier == other.ListIdentifier && self.cCtlStore == other.cCtlStore && self.rghCtlStore == other.rghCtlStore && self.cSignerStore == other.cSignerStore && self.rghSignerStore == other.rghSignerStore
18575     }
18576 }
18577 impl ::std::cmp::Eq for CTL_VERIFY_USAGE_PARA {}
18578 unsafe impl ::windows::runtime::Abi for CTL_VERIFY_USAGE_PARA {
18579     type Abi = Self;
18580     type DefaultType = Self;
18581 }
18582 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18583 #[repr(C)]
18584 #[cfg(feature = "Win32_Foundation")]
18585 pub struct CTL_VERIFY_USAGE_STATUS {
18586     pub cbSize: u32,
18587     pub dwError: u32,
18588     pub dwFlags: u32,
18589     pub ppCtl: *mut *mut CTL_CONTEXT,
18590     pub dwCtlEntryIndex: u32,
18591     pub ppSigner: *mut *mut CERT_CONTEXT,
18592     pub dwSignerIndex: u32,
18593 }
18594 #[cfg(feature = "Win32_Foundation")]
18595 impl CTL_VERIFY_USAGE_STATUS {}
18596 #[cfg(feature = "Win32_Foundation")]
18597 impl ::std::default::Default for CTL_VERIFY_USAGE_STATUS {
default() -> Self18598     fn default() -> Self {
18599         unsafe { ::std::mem::zeroed() }
18600     }
18601 }
18602 #[cfg(feature = "Win32_Foundation")]
18603 impl ::std::fmt::Debug for CTL_VERIFY_USAGE_STATUS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result18604     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18605         fmt.debug_struct("CTL_VERIFY_USAGE_STATUS").field("cbSize", &self.cbSize).field("dwError", &self.dwError).field("dwFlags", &self.dwFlags).field("ppCtl", &self.ppCtl).field("dwCtlEntryIndex", &self.dwCtlEntryIndex).field("ppSigner", &self.ppSigner).field("dwSignerIndex", &self.dwSignerIndex).finish()
18606     }
18607 }
18608 #[cfg(feature = "Win32_Foundation")]
18609 impl ::std::cmp::PartialEq for CTL_VERIFY_USAGE_STATUS {
eq(&self, other: &Self) -> bool18610     fn eq(&self, other: &Self) -> bool {
18611         self.cbSize == other.cbSize && self.dwError == other.dwError && self.dwFlags == other.dwFlags && self.ppCtl == other.ppCtl && self.dwCtlEntryIndex == other.dwCtlEntryIndex && self.ppSigner == other.ppSigner && self.dwSignerIndex == other.dwSignerIndex
18612     }
18613 }
18614 #[cfg(feature = "Win32_Foundation")]
18615 impl ::std::cmp::Eq for CTL_VERIFY_USAGE_STATUS {}
18616 #[cfg(feature = "Win32_Foundation")]
18617 unsafe impl ::windows::runtime::Abi for CTL_VERIFY_USAGE_STATUS {
18618     type Abi = Self;
18619     type DefaultType = Self;
18620 }
18621 pub const CUR_BLOB_VERSION: u32 = 2u32;
18622 #[cfg(feature = "Win32_Foundation")]
18623 #[inline]
CertAddCRLContextToStore(hcertstore: *const ::std::ffi::c_void, pcrlcontext: *const CRL_CONTEXT, dwadddisposition: u32, ppstorecontext: *mut *mut CRL_CONTEXT) -> super::super::Foundation::BOOL18624 pub unsafe fn CertAddCRLContextToStore(hcertstore: *const ::std::ffi::c_void, pcrlcontext: *const CRL_CONTEXT, dwadddisposition: u32, ppstorecontext: *mut *mut CRL_CONTEXT) -> super::super::Foundation::BOOL {
18625     #[cfg(windows)]
18626     {
18627         #[link(name = "windows")]
18628         extern "system" {
18629             fn CertAddCRLContextToStore(hcertstore: *const ::std::ffi::c_void, pcrlcontext: *const CRL_CONTEXT, dwadddisposition: u32, ppstorecontext: *mut *mut CRL_CONTEXT) -> super::super::Foundation::BOOL;
18630         }
18631         ::std::mem::transmute(CertAddCRLContextToStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(pcrlcontext), ::std::mem::transmute(dwadddisposition), ::std::mem::transmute(ppstorecontext)))
18632     }
18633     #[cfg(not(windows))]
18634     unimplemented!("Unsupported target OS");
18635 }
18636 #[cfg(feature = "Win32_Foundation")]
18637 #[inline]
CertAddCRLLinkToStore(hcertstore: *const ::std::ffi::c_void, pcrlcontext: *const CRL_CONTEXT, dwadddisposition: u32, ppstorecontext: *mut *mut CRL_CONTEXT) -> super::super::Foundation::BOOL18638 pub unsafe fn CertAddCRLLinkToStore(hcertstore: *const ::std::ffi::c_void, pcrlcontext: *const CRL_CONTEXT, dwadddisposition: u32, ppstorecontext: *mut *mut CRL_CONTEXT) -> super::super::Foundation::BOOL {
18639     #[cfg(windows)]
18640     {
18641         #[link(name = "windows")]
18642         extern "system" {
18643             fn CertAddCRLLinkToStore(hcertstore: *const ::std::ffi::c_void, pcrlcontext: *const CRL_CONTEXT, dwadddisposition: u32, ppstorecontext: *mut *mut CRL_CONTEXT) -> super::super::Foundation::BOOL;
18644         }
18645         ::std::mem::transmute(CertAddCRLLinkToStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(pcrlcontext), ::std::mem::transmute(dwadddisposition), ::std::mem::transmute(ppstorecontext)))
18646     }
18647     #[cfg(not(windows))]
18648     unimplemented!("Unsupported target OS");
18649 }
18650 #[cfg(feature = "Win32_Foundation")]
18651 #[inline]
CertAddCTLContextToStore(hcertstore: *const ::std::ffi::c_void, pctlcontext: *const CTL_CONTEXT, dwadddisposition: u32, ppstorecontext: *mut *mut CTL_CONTEXT) -> super::super::Foundation::BOOL18652 pub unsafe fn CertAddCTLContextToStore(hcertstore: *const ::std::ffi::c_void, pctlcontext: *const CTL_CONTEXT, dwadddisposition: u32, ppstorecontext: *mut *mut CTL_CONTEXT) -> super::super::Foundation::BOOL {
18653     #[cfg(windows)]
18654     {
18655         #[link(name = "windows")]
18656         extern "system" {
18657             fn CertAddCTLContextToStore(hcertstore: *const ::std::ffi::c_void, pctlcontext: *const CTL_CONTEXT, dwadddisposition: u32, ppstorecontext: *mut *mut CTL_CONTEXT) -> super::super::Foundation::BOOL;
18658         }
18659         ::std::mem::transmute(CertAddCTLContextToStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(pctlcontext), ::std::mem::transmute(dwadddisposition), ::std::mem::transmute(ppstorecontext)))
18660     }
18661     #[cfg(not(windows))]
18662     unimplemented!("Unsupported target OS");
18663 }
18664 #[cfg(feature = "Win32_Foundation")]
18665 #[inline]
CertAddCTLLinkToStore(hcertstore: *const ::std::ffi::c_void, pctlcontext: *const CTL_CONTEXT, dwadddisposition: u32, ppstorecontext: *mut *mut CTL_CONTEXT) -> super::super::Foundation::BOOL18666 pub unsafe fn CertAddCTLLinkToStore(hcertstore: *const ::std::ffi::c_void, pctlcontext: *const CTL_CONTEXT, dwadddisposition: u32, ppstorecontext: *mut *mut CTL_CONTEXT) -> super::super::Foundation::BOOL {
18667     #[cfg(windows)]
18668     {
18669         #[link(name = "windows")]
18670         extern "system" {
18671             fn CertAddCTLLinkToStore(hcertstore: *const ::std::ffi::c_void, pctlcontext: *const CTL_CONTEXT, dwadddisposition: u32, ppstorecontext: *mut *mut CTL_CONTEXT) -> super::super::Foundation::BOOL;
18672         }
18673         ::std::mem::transmute(CertAddCTLLinkToStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(pctlcontext), ::std::mem::transmute(dwadddisposition), ::std::mem::transmute(ppstorecontext)))
18674     }
18675     #[cfg(not(windows))]
18676     unimplemented!("Unsupported target OS");
18677 }
18678 #[cfg(feature = "Win32_Foundation")]
18679 #[inline]
CertAddCertificateContextToStore(hcertstore: *const ::std::ffi::c_void, pcertcontext: *const CERT_CONTEXT, dwadddisposition: u32, ppstorecontext: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL18680 pub unsafe fn CertAddCertificateContextToStore(hcertstore: *const ::std::ffi::c_void, pcertcontext: *const CERT_CONTEXT, dwadddisposition: u32, ppstorecontext: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL {
18681     #[cfg(windows)]
18682     {
18683         #[link(name = "windows")]
18684         extern "system" {
18685             fn CertAddCertificateContextToStore(hcertstore: *const ::std::ffi::c_void, pcertcontext: *const CERT_CONTEXT, dwadddisposition: u32, ppstorecontext: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL;
18686         }
18687         ::std::mem::transmute(CertAddCertificateContextToStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(pcertcontext), ::std::mem::transmute(dwadddisposition), ::std::mem::transmute(ppstorecontext)))
18688     }
18689     #[cfg(not(windows))]
18690     unimplemented!("Unsupported target OS");
18691 }
18692 #[cfg(feature = "Win32_Foundation")]
18693 #[inline]
CertAddCertificateLinkToStore(hcertstore: *const ::std::ffi::c_void, pcertcontext: *const CERT_CONTEXT, dwadddisposition: u32, ppstorecontext: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL18694 pub unsafe fn CertAddCertificateLinkToStore(hcertstore: *const ::std::ffi::c_void, pcertcontext: *const CERT_CONTEXT, dwadddisposition: u32, ppstorecontext: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL {
18695     #[cfg(windows)]
18696     {
18697         #[link(name = "windows")]
18698         extern "system" {
18699             fn CertAddCertificateLinkToStore(hcertstore: *const ::std::ffi::c_void, pcertcontext: *const CERT_CONTEXT, dwadddisposition: u32, ppstorecontext: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL;
18700         }
18701         ::std::mem::transmute(CertAddCertificateLinkToStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(pcertcontext), ::std::mem::transmute(dwadddisposition), ::std::mem::transmute(ppstorecontext)))
18702     }
18703     #[cfg(not(windows))]
18704     unimplemented!("Unsupported target OS");
18705 }
18706 #[cfg(feature = "Win32_Foundation")]
18707 #[inline]
CertAddEncodedCRLToStore(hcertstore: *const ::std::ffi::c_void, dwcertencodingtype: u32, pbcrlencoded: *const u8, cbcrlencoded: u32, dwadddisposition: u32, ppcrlcontext: *mut *mut CRL_CONTEXT) -> super::super::Foundation::BOOL18708 pub unsafe fn CertAddEncodedCRLToStore(hcertstore: *const ::std::ffi::c_void, dwcertencodingtype: u32, pbcrlencoded: *const u8, cbcrlencoded: u32, dwadddisposition: u32, ppcrlcontext: *mut *mut CRL_CONTEXT) -> super::super::Foundation::BOOL {
18709     #[cfg(windows)]
18710     {
18711         #[link(name = "windows")]
18712         extern "system" {
18713             fn CertAddEncodedCRLToStore(hcertstore: *const ::std::ffi::c_void, dwcertencodingtype: u32, pbcrlencoded: *const u8, cbcrlencoded: u32, dwadddisposition: u32, ppcrlcontext: *mut *mut CRL_CONTEXT) -> super::super::Foundation::BOOL;
18714         }
18715         ::std::mem::transmute(CertAddEncodedCRLToStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(pbcrlencoded), ::std::mem::transmute(cbcrlencoded), ::std::mem::transmute(dwadddisposition), ::std::mem::transmute(ppcrlcontext)))
18716     }
18717     #[cfg(not(windows))]
18718     unimplemented!("Unsupported target OS");
18719 }
18720 #[cfg(feature = "Win32_Foundation")]
18721 #[inline]
CertAddEncodedCTLToStore(hcertstore: *const ::std::ffi::c_void, dwmsgandcertencodingtype: u32, pbctlencoded: *const u8, cbctlencoded: u32, dwadddisposition: u32, ppctlcontext: *mut *mut CTL_CONTEXT) -> super::super::Foundation::BOOL18722 pub unsafe fn CertAddEncodedCTLToStore(hcertstore: *const ::std::ffi::c_void, dwmsgandcertencodingtype: u32, pbctlencoded: *const u8, cbctlencoded: u32, dwadddisposition: u32, ppctlcontext: *mut *mut CTL_CONTEXT) -> super::super::Foundation::BOOL {
18723     #[cfg(windows)]
18724     {
18725         #[link(name = "windows")]
18726         extern "system" {
18727             fn CertAddEncodedCTLToStore(hcertstore: *const ::std::ffi::c_void, dwmsgandcertencodingtype: u32, pbctlencoded: *const u8, cbctlencoded: u32, dwadddisposition: u32, ppctlcontext: *mut *mut CTL_CONTEXT) -> super::super::Foundation::BOOL;
18728         }
18729         ::std::mem::transmute(CertAddEncodedCTLToStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(dwmsgandcertencodingtype), ::std::mem::transmute(pbctlencoded), ::std::mem::transmute(cbctlencoded), ::std::mem::transmute(dwadddisposition), ::std::mem::transmute(ppctlcontext)))
18730     }
18731     #[cfg(not(windows))]
18732     unimplemented!("Unsupported target OS");
18733 }
18734 #[cfg(feature = "Win32_Foundation")]
18735 #[inline]
CertAddEncodedCertificateToStore(hcertstore: *const ::std::ffi::c_void, dwcertencodingtype: u32, pbcertencoded: *const u8, cbcertencoded: u32, dwadddisposition: u32, ppcertcontext: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL18736 pub unsafe fn CertAddEncodedCertificateToStore(hcertstore: *const ::std::ffi::c_void, dwcertencodingtype: u32, pbcertencoded: *const u8, cbcertencoded: u32, dwadddisposition: u32, ppcertcontext: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL {
18737     #[cfg(windows)]
18738     {
18739         #[link(name = "windows")]
18740         extern "system" {
18741             fn CertAddEncodedCertificateToStore(hcertstore: *const ::std::ffi::c_void, dwcertencodingtype: u32, pbcertencoded: *const u8, cbcertencoded: u32, dwadddisposition: u32, ppcertcontext: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL;
18742         }
18743         ::std::mem::transmute(CertAddEncodedCertificateToStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(pbcertencoded), ::std::mem::transmute(cbcertencoded), ::std::mem::transmute(dwadddisposition), ::std::mem::transmute(ppcertcontext)))
18744     }
18745     #[cfg(not(windows))]
18746     unimplemented!("Unsupported target OS");
18747 }
18748 #[cfg(feature = "Win32_Foundation")]
18749 #[inline]
CertAddEncodedCertificateToSystemStoreA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szcertstorename: Param0, pbcertencoded: *const u8, cbcertencoded: u32) -> super::super::Foundation::BOOL18750 pub unsafe fn CertAddEncodedCertificateToSystemStoreA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(szcertstorename: Param0, pbcertencoded: *const u8, cbcertencoded: u32) -> super::super::Foundation::BOOL {
18751     #[cfg(windows)]
18752     {
18753         #[link(name = "windows")]
18754         extern "system" {
18755             fn CertAddEncodedCertificateToSystemStoreA(szcertstorename: super::super::Foundation::PSTR, pbcertencoded: *const u8, cbcertencoded: u32) -> super::super::Foundation::BOOL;
18756         }
18757         ::std::mem::transmute(CertAddEncodedCertificateToSystemStoreA(szcertstorename.into_param().abi(), ::std::mem::transmute(pbcertencoded), ::std::mem::transmute(cbcertencoded)))
18758     }
18759     #[cfg(not(windows))]
18760     unimplemented!("Unsupported target OS");
18761 }
18762 #[cfg(feature = "Win32_Foundation")]
18763 #[inline]
CertAddEncodedCertificateToSystemStoreW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szcertstorename: Param0, pbcertencoded: *const u8, cbcertencoded: u32) -> super::super::Foundation::BOOL18764 pub unsafe fn CertAddEncodedCertificateToSystemStoreW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(szcertstorename: Param0, pbcertencoded: *const u8, cbcertencoded: u32) -> super::super::Foundation::BOOL {
18765     #[cfg(windows)]
18766     {
18767         #[link(name = "windows")]
18768         extern "system" {
18769             fn CertAddEncodedCertificateToSystemStoreW(szcertstorename: super::super::Foundation::PWSTR, pbcertencoded: *const u8, cbcertencoded: u32) -> super::super::Foundation::BOOL;
18770         }
18771         ::std::mem::transmute(CertAddEncodedCertificateToSystemStoreW(szcertstorename.into_param().abi(), ::std::mem::transmute(pbcertencoded), ::std::mem::transmute(cbcertencoded)))
18772     }
18773     #[cfg(not(windows))]
18774     unimplemented!("Unsupported target OS");
18775 }
18776 #[cfg(feature = "Win32_Foundation")]
18777 #[inline]
CertAddEnhancedKeyUsageIdentifier<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pcertcontext: *const CERT_CONTEXT, pszusageidentifier: Param1) -> super::super::Foundation::BOOL18778 pub unsafe fn CertAddEnhancedKeyUsageIdentifier<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pcertcontext: *const CERT_CONTEXT, pszusageidentifier: Param1) -> super::super::Foundation::BOOL {
18779     #[cfg(windows)]
18780     {
18781         #[link(name = "windows")]
18782         extern "system" {
18783             fn CertAddEnhancedKeyUsageIdentifier(pcertcontext: *const CERT_CONTEXT, pszusageidentifier: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
18784         }
18785         ::std::mem::transmute(CertAddEnhancedKeyUsageIdentifier(::std::mem::transmute(pcertcontext), pszusageidentifier.into_param().abi()))
18786     }
18787     #[cfg(not(windows))]
18788     unimplemented!("Unsupported target OS");
18789 }
18790 #[inline]
CertAddRefServerOcspResponse(hserverocspresponse: *const ::std::ffi::c_void)18791 pub unsafe fn CertAddRefServerOcspResponse(hserverocspresponse: *const ::std::ffi::c_void) {
18792     #[cfg(windows)]
18793     {
18794         #[link(name = "windows")]
18795         extern "system" {
18796             fn CertAddRefServerOcspResponse(hserverocspresponse: *const ::std::ffi::c_void);
18797         }
18798         ::std::mem::transmute(CertAddRefServerOcspResponse(::std::mem::transmute(hserverocspresponse)))
18799     }
18800     #[cfg(not(windows))]
18801     unimplemented!("Unsupported target OS");
18802 }
18803 #[inline]
CertAddRefServerOcspResponseContext(pserverocspresponsecontext: *const CERT_SERVER_OCSP_RESPONSE_CONTEXT)18804 pub unsafe fn CertAddRefServerOcspResponseContext(pserverocspresponsecontext: *const CERT_SERVER_OCSP_RESPONSE_CONTEXT) {
18805     #[cfg(windows)]
18806     {
18807         #[link(name = "windows")]
18808         extern "system" {
18809             fn CertAddRefServerOcspResponseContext(pserverocspresponsecontext: *const CERT_SERVER_OCSP_RESPONSE_CONTEXT);
18810         }
18811         ::std::mem::transmute(CertAddRefServerOcspResponseContext(::std::mem::transmute(pserverocspresponsecontext)))
18812     }
18813     #[cfg(not(windows))]
18814     unimplemented!("Unsupported target OS");
18815 }
18816 #[cfg(feature = "Win32_Foundation")]
18817 #[inline]
CertAddSerializedElementToStore(hcertstore: *const ::std::ffi::c_void, pbelement: *const u8, cbelement: u32, dwadddisposition: u32, dwflags: u32, dwcontexttypeflags: u32, pdwcontexttype: *mut u32, ppvcontext: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL18818 pub unsafe fn CertAddSerializedElementToStore(hcertstore: *const ::std::ffi::c_void, pbelement: *const u8, cbelement: u32, dwadddisposition: u32, dwflags: u32, dwcontexttypeflags: u32, pdwcontexttype: *mut u32, ppvcontext: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
18819     #[cfg(windows)]
18820     {
18821         #[link(name = "windows")]
18822         extern "system" {
18823             fn CertAddSerializedElementToStore(hcertstore: *const ::std::ffi::c_void, pbelement: *const u8, cbelement: u32, dwadddisposition: u32, dwflags: u32, dwcontexttypeflags: u32, pdwcontexttype: *mut u32, ppvcontext: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
18824         }
18825         ::std::mem::transmute(CertAddSerializedElementToStore(
18826             ::std::mem::transmute(hcertstore),
18827             ::std::mem::transmute(pbelement),
18828             ::std::mem::transmute(cbelement),
18829             ::std::mem::transmute(dwadddisposition),
18830             ::std::mem::transmute(dwflags),
18831             ::std::mem::transmute(dwcontexttypeflags),
18832             ::std::mem::transmute(pdwcontexttype),
18833             ::std::mem::transmute(ppvcontext),
18834         ))
18835     }
18836     #[cfg(not(windows))]
18837     unimplemented!("Unsupported target OS");
18838 }
18839 #[cfg(feature = "Win32_Foundation")]
18840 #[inline]
CertAddStoreToCollection(hcollectionstore: *const ::std::ffi::c_void, hsiblingstore: *const ::std::ffi::c_void, dwupdateflags: u32, dwpriority: u32) -> super::super::Foundation::BOOL18841 pub unsafe fn CertAddStoreToCollection(hcollectionstore: *const ::std::ffi::c_void, hsiblingstore: *const ::std::ffi::c_void, dwupdateflags: u32, dwpriority: u32) -> super::super::Foundation::BOOL {
18842     #[cfg(windows)]
18843     {
18844         #[link(name = "windows")]
18845         extern "system" {
18846             fn CertAddStoreToCollection(hcollectionstore: *const ::std::ffi::c_void, hsiblingstore: *const ::std::ffi::c_void, dwupdateflags: u32, dwpriority: u32) -> super::super::Foundation::BOOL;
18847         }
18848         ::std::mem::transmute(CertAddStoreToCollection(::std::mem::transmute(hcollectionstore), ::std::mem::transmute(hsiblingstore), ::std::mem::transmute(dwupdateflags), ::std::mem::transmute(dwpriority)))
18849     }
18850     #[cfg(not(windows))]
18851     unimplemented!("Unsupported target OS");
18852 }
18853 #[cfg(feature = "Win32_Foundation")]
18854 #[inline]
CertAlgIdToOID(dwalgid: u32) -> super::super::Foundation::PSTR18855 pub unsafe fn CertAlgIdToOID(dwalgid: u32) -> super::super::Foundation::PSTR {
18856     #[cfg(windows)]
18857     {
18858         #[link(name = "windows")]
18859         extern "system" {
18860             fn CertAlgIdToOID(dwalgid: u32) -> super::super::Foundation::PSTR;
18861         }
18862         ::std::mem::transmute(CertAlgIdToOID(::std::mem::transmute(dwalgid)))
18863     }
18864     #[cfg(not(windows))]
18865     unimplemented!("Unsupported target OS");
18866 }
18867 #[inline]
CertCloseServerOcspResponse(hserverocspresponse: *const ::std::ffi::c_void, dwflags: u32)18868 pub unsafe fn CertCloseServerOcspResponse(hserverocspresponse: *const ::std::ffi::c_void, dwflags: u32) {
18869     #[cfg(windows)]
18870     {
18871         #[link(name = "windows")]
18872         extern "system" {
18873             fn CertCloseServerOcspResponse(hserverocspresponse: *const ::std::ffi::c_void, dwflags: u32);
18874         }
18875         ::std::mem::transmute(CertCloseServerOcspResponse(::std::mem::transmute(hserverocspresponse), ::std::mem::transmute(dwflags)))
18876     }
18877     #[cfg(not(windows))]
18878     unimplemented!("Unsupported target OS");
18879 }
18880 #[cfg(feature = "Win32_Foundation")]
18881 #[inline]
CertCloseStore(hcertstore: *const ::std::ffi::c_void, dwflags: u32) -> super::super::Foundation::BOOL18882 pub unsafe fn CertCloseStore(hcertstore: *const ::std::ffi::c_void, dwflags: u32) -> super::super::Foundation::BOOL {
18883     #[cfg(windows)]
18884     {
18885         #[link(name = "windows")]
18886         extern "system" {
18887             fn CertCloseStore(hcertstore: *const ::std::ffi::c_void, dwflags: u32) -> super::super::Foundation::BOOL;
18888         }
18889         ::std::mem::transmute(CertCloseStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(dwflags)))
18890     }
18891     #[cfg(not(windows))]
18892     unimplemented!("Unsupported target OS");
18893 }
18894 #[cfg(feature = "Win32_Foundation")]
18895 #[inline]
CertCompareCertificate(dwcertencodingtype: u32, pcertid1: *const CERT_INFO, pcertid2: *const CERT_INFO) -> super::super::Foundation::BOOL18896 pub unsafe fn CertCompareCertificate(dwcertencodingtype: u32, pcertid1: *const CERT_INFO, pcertid2: *const CERT_INFO) -> super::super::Foundation::BOOL {
18897     #[cfg(windows)]
18898     {
18899         #[link(name = "windows")]
18900         extern "system" {
18901             fn CertCompareCertificate(dwcertencodingtype: u32, pcertid1: *const CERT_INFO, pcertid2: *const CERT_INFO) -> super::super::Foundation::BOOL;
18902         }
18903         ::std::mem::transmute(CertCompareCertificate(::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(pcertid1), ::std::mem::transmute(pcertid2)))
18904     }
18905     #[cfg(not(windows))]
18906     unimplemented!("Unsupported target OS");
18907 }
18908 #[cfg(feature = "Win32_Foundation")]
18909 #[inline]
CertCompareCertificateName(dwcertencodingtype: u32, pcertname1: *const CRYPTOAPI_BLOB, pcertname2: *const CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL18910 pub unsafe fn CertCompareCertificateName(dwcertencodingtype: u32, pcertname1: *const CRYPTOAPI_BLOB, pcertname2: *const CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL {
18911     #[cfg(windows)]
18912     {
18913         #[link(name = "windows")]
18914         extern "system" {
18915             fn CertCompareCertificateName(dwcertencodingtype: u32, pcertname1: *const CRYPTOAPI_BLOB, pcertname2: *const CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL;
18916         }
18917         ::std::mem::transmute(CertCompareCertificateName(::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(pcertname1), ::std::mem::transmute(pcertname2)))
18918     }
18919     #[cfg(not(windows))]
18920     unimplemented!("Unsupported target OS");
18921 }
18922 #[cfg(feature = "Win32_Foundation")]
18923 #[inline]
CertCompareIntegerBlob(pint1: *const CRYPTOAPI_BLOB, pint2: *const CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL18924 pub unsafe fn CertCompareIntegerBlob(pint1: *const CRYPTOAPI_BLOB, pint2: *const CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL {
18925     #[cfg(windows)]
18926     {
18927         #[link(name = "windows")]
18928         extern "system" {
18929             fn CertCompareIntegerBlob(pint1: *const CRYPTOAPI_BLOB, pint2: *const CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL;
18930         }
18931         ::std::mem::transmute(CertCompareIntegerBlob(::std::mem::transmute(pint1), ::std::mem::transmute(pint2)))
18932     }
18933     #[cfg(not(windows))]
18934     unimplemented!("Unsupported target OS");
18935 }
18936 #[cfg(feature = "Win32_Foundation")]
18937 #[inline]
CertComparePublicKeyInfo(dwcertencodingtype: u32, ppublickey1: *const CERT_PUBLIC_KEY_INFO, ppublickey2: *const CERT_PUBLIC_KEY_INFO) -> super::super::Foundation::BOOL18938 pub unsafe fn CertComparePublicKeyInfo(dwcertencodingtype: u32, ppublickey1: *const CERT_PUBLIC_KEY_INFO, ppublickey2: *const CERT_PUBLIC_KEY_INFO) -> super::super::Foundation::BOOL {
18939     #[cfg(windows)]
18940     {
18941         #[link(name = "windows")]
18942         extern "system" {
18943             fn CertComparePublicKeyInfo(dwcertencodingtype: u32, ppublickey1: *const CERT_PUBLIC_KEY_INFO, ppublickey2: *const CERT_PUBLIC_KEY_INFO) -> super::super::Foundation::BOOL;
18944         }
18945         ::std::mem::transmute(CertComparePublicKeyInfo(::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(ppublickey1), ::std::mem::transmute(ppublickey2)))
18946     }
18947     #[cfg(not(windows))]
18948     unimplemented!("Unsupported target OS");
18949 }
18950 #[cfg(feature = "Win32_Foundation")]
18951 #[inline]
CertControlStore(hcertstore: *const ::std::ffi::c_void, dwflags: CERT_CONTROL_STORE_FLAGS, dwctrltype: u32, pvctrlpara: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL18952 pub unsafe fn CertControlStore(hcertstore: *const ::std::ffi::c_void, dwflags: CERT_CONTROL_STORE_FLAGS, dwctrltype: u32, pvctrlpara: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL {
18953     #[cfg(windows)]
18954     {
18955         #[link(name = "windows")]
18956         extern "system" {
18957             fn CertControlStore(hcertstore: *const ::std::ffi::c_void, dwflags: CERT_CONTROL_STORE_FLAGS, dwctrltype: u32, pvctrlpara: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
18958         }
18959         ::std::mem::transmute(CertControlStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(dwflags), ::std::mem::transmute(dwctrltype), ::std::mem::transmute(pvctrlpara)))
18960     }
18961     #[cfg(not(windows))]
18962     unimplemented!("Unsupported target OS");
18963 }
18964 #[cfg(feature = "Win32_Foundation")]
18965 #[inline]
CertCreateCRLContext(dwcertencodingtype: u32, pbcrlencoded: *const u8, cbcrlencoded: u32) -> *mut CRL_CONTEXT18966 pub unsafe fn CertCreateCRLContext(dwcertencodingtype: u32, pbcrlencoded: *const u8, cbcrlencoded: u32) -> *mut CRL_CONTEXT {
18967     #[cfg(windows)]
18968     {
18969         #[link(name = "windows")]
18970         extern "system" {
18971             fn CertCreateCRLContext(dwcertencodingtype: u32, pbcrlencoded: *const u8, cbcrlencoded: u32) -> *mut CRL_CONTEXT;
18972         }
18973         ::std::mem::transmute(CertCreateCRLContext(::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(pbcrlencoded), ::std::mem::transmute(cbcrlencoded)))
18974     }
18975     #[cfg(not(windows))]
18976     unimplemented!("Unsupported target OS");
18977 }
18978 #[cfg(feature = "Win32_Foundation")]
18979 #[inline]
CertCreateCTLContext(dwmsgandcertencodingtype: u32, pbctlencoded: *const u8, cbctlencoded: u32) -> *mut CTL_CONTEXT18980 pub unsafe fn CertCreateCTLContext(dwmsgandcertencodingtype: u32, pbctlencoded: *const u8, cbctlencoded: u32) -> *mut CTL_CONTEXT {
18981     #[cfg(windows)]
18982     {
18983         #[link(name = "windows")]
18984         extern "system" {
18985             fn CertCreateCTLContext(dwmsgandcertencodingtype: u32, pbctlencoded: *const u8, cbctlencoded: u32) -> *mut CTL_CONTEXT;
18986         }
18987         ::std::mem::transmute(CertCreateCTLContext(::std::mem::transmute(dwmsgandcertencodingtype), ::std::mem::transmute(pbctlencoded), ::std::mem::transmute(cbctlencoded)))
18988     }
18989     #[cfg(not(windows))]
18990     unimplemented!("Unsupported target OS");
18991 }
18992 #[cfg(feature = "Win32_Foundation")]
18993 #[inline]
CertCreateCTLEntryFromCertificateContextProperties(pcertcontext: *const CERT_CONTEXT, coptattr: u32, rgoptattr: *const CRYPT_ATTRIBUTE, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, pctlentry: *mut CTL_ENTRY, pcbctlentry: *mut u32) -> super::super::Foundation::BOOL18994 pub unsafe fn CertCreateCTLEntryFromCertificateContextProperties(pcertcontext: *const CERT_CONTEXT, coptattr: u32, rgoptattr: *const CRYPT_ATTRIBUTE, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, pctlentry: *mut CTL_ENTRY, pcbctlentry: *mut u32) -> super::super::Foundation::BOOL {
18995     #[cfg(windows)]
18996     {
18997         #[link(name = "windows")]
18998         extern "system" {
18999             fn CertCreateCTLEntryFromCertificateContextProperties(pcertcontext: *const CERT_CONTEXT, coptattr: u32, rgoptattr: *const CRYPT_ATTRIBUTE, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, pctlentry: *mut CTL_ENTRY, pcbctlentry: *mut u32) -> super::super::Foundation::BOOL;
19000         }
19001         ::std::mem::transmute(CertCreateCTLEntryFromCertificateContextProperties(::std::mem::transmute(pcertcontext), ::std::mem::transmute(coptattr), ::std::mem::transmute(rgoptattr), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvreserved), ::std::mem::transmute(pctlentry), ::std::mem::transmute(pcbctlentry)))
19002     }
19003     #[cfg(not(windows))]
19004     unimplemented!("Unsupported target OS");
19005 }
19006 #[cfg(feature = "Win32_Foundation")]
19007 #[inline]
CertCreateCertificateChainEngine(pconfig: *const CERT_CHAIN_ENGINE_CONFIG, phchainengine: *mut HCERTCHAINENGINE) -> super::super::Foundation::BOOL19008 pub unsafe fn CertCreateCertificateChainEngine(pconfig: *const CERT_CHAIN_ENGINE_CONFIG, phchainengine: *mut HCERTCHAINENGINE) -> super::super::Foundation::BOOL {
19009     #[cfg(windows)]
19010     {
19011         #[link(name = "windows")]
19012         extern "system" {
19013             fn CertCreateCertificateChainEngine(pconfig: *const CERT_CHAIN_ENGINE_CONFIG, phchainengine: *mut HCERTCHAINENGINE) -> super::super::Foundation::BOOL;
19014         }
19015         ::std::mem::transmute(CertCreateCertificateChainEngine(::std::mem::transmute(pconfig), ::std::mem::transmute(phchainengine)))
19016     }
19017     #[cfg(not(windows))]
19018     unimplemented!("Unsupported target OS");
19019 }
19020 #[cfg(feature = "Win32_Foundation")]
19021 #[inline]
CertCreateCertificateContext(dwcertencodingtype: u32, pbcertencoded: *const u8, cbcertencoded: u32) -> *mut CERT_CONTEXT19022 pub unsafe fn CertCreateCertificateContext(dwcertencodingtype: u32, pbcertencoded: *const u8, cbcertencoded: u32) -> *mut CERT_CONTEXT {
19023     #[cfg(windows)]
19024     {
19025         #[link(name = "windows")]
19026         extern "system" {
19027             fn CertCreateCertificateContext(dwcertencodingtype: u32, pbcertencoded: *const u8, cbcertencoded: u32) -> *mut CERT_CONTEXT;
19028         }
19029         ::std::mem::transmute(CertCreateCertificateContext(::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(pbcertencoded), ::std::mem::transmute(cbcertencoded)))
19030     }
19031     #[cfg(not(windows))]
19032     unimplemented!("Unsupported target OS");
19033 }
19034 #[cfg(feature = "Win32_Foundation")]
19035 #[inline]
CertCreateContext(dwcontexttype: u32, dwencodingtype: u32, pbencoded: *const u8, cbencoded: u32, dwflags: u32, pcreatepara: *const CERT_CREATE_CONTEXT_PARA) -> *mut ::std::ffi::c_void19036 pub unsafe fn CertCreateContext(dwcontexttype: u32, dwencodingtype: u32, pbencoded: *const u8, cbencoded: u32, dwflags: u32, pcreatepara: *const CERT_CREATE_CONTEXT_PARA) -> *mut ::std::ffi::c_void {
19037     #[cfg(windows)]
19038     {
19039         #[link(name = "windows")]
19040         extern "system" {
19041             fn CertCreateContext(dwcontexttype: u32, dwencodingtype: u32, pbencoded: *const u8, cbencoded: u32, dwflags: u32, pcreatepara: *const ::std::mem::ManuallyDrop<CERT_CREATE_CONTEXT_PARA>) -> *mut ::std::ffi::c_void;
19042         }
19043         ::std::mem::transmute(CertCreateContext(::std::mem::transmute(dwcontexttype), ::std::mem::transmute(dwencodingtype), ::std::mem::transmute(pbencoded), ::std::mem::transmute(cbencoded), ::std::mem::transmute(dwflags), ::std::mem::transmute(pcreatepara)))
19044     }
19045     #[cfg(not(windows))]
19046     unimplemented!("Unsupported target OS");
19047 }
19048 #[cfg(feature = "Win32_Foundation")]
19049 #[inline]
CertCreateSelfSignCertificate(hcryptprovorncryptkey: usize, psubjectissuerblob: *const CRYPTOAPI_BLOB, dwflags: CERT_CREATE_SELFSIGN_FLAGS, pkeyprovinfo: *const CRYPT_KEY_PROV_INFO, psignaturealgorithm: *const CRYPT_ALGORITHM_IDENTIFIER, pstarttime: *const super::super::Foundation::SYSTEMTIME, pendtime: *const super::super::Foundation::SYSTEMTIME, pextensions: *const CERT_EXTENSIONS) -> *mut CERT_CONTEXT19050 pub unsafe fn CertCreateSelfSignCertificate(hcryptprovorncryptkey: usize, psubjectissuerblob: *const CRYPTOAPI_BLOB, dwflags: CERT_CREATE_SELFSIGN_FLAGS, pkeyprovinfo: *const CRYPT_KEY_PROV_INFO, psignaturealgorithm: *const CRYPT_ALGORITHM_IDENTIFIER, pstarttime: *const super::super::Foundation::SYSTEMTIME, pendtime: *const super::super::Foundation::SYSTEMTIME, pextensions: *const CERT_EXTENSIONS) -> *mut CERT_CONTEXT {
19051     #[cfg(windows)]
19052     {
19053         #[link(name = "windows")]
19054         extern "system" {
19055             fn CertCreateSelfSignCertificate(hcryptprovorncryptkey: usize, psubjectissuerblob: *const CRYPTOAPI_BLOB, dwflags: CERT_CREATE_SELFSIGN_FLAGS, pkeyprovinfo: *const CRYPT_KEY_PROV_INFO, psignaturealgorithm: *const CRYPT_ALGORITHM_IDENTIFIER, pstarttime: *const super::super::Foundation::SYSTEMTIME, pendtime: *const super::super::Foundation::SYSTEMTIME, pextensions: *const CERT_EXTENSIONS) -> *mut CERT_CONTEXT;
19056         }
19057         ::std::mem::transmute(CertCreateSelfSignCertificate(
19058             ::std::mem::transmute(hcryptprovorncryptkey),
19059             ::std::mem::transmute(psubjectissuerblob),
19060             ::std::mem::transmute(dwflags),
19061             ::std::mem::transmute(pkeyprovinfo),
19062             ::std::mem::transmute(psignaturealgorithm),
19063             ::std::mem::transmute(pstarttime),
19064             ::std::mem::transmute(pendtime),
19065             ::std::mem::transmute(pextensions),
19066         ))
19067     }
19068     #[cfg(not(windows))]
19069     unimplemented!("Unsupported target OS");
19070 }
19071 #[cfg(feature = "Win32_Foundation")]
19072 #[inline]
CertDeleteCRLFromStore(pcrlcontext: *const CRL_CONTEXT) -> super::super::Foundation::BOOL19073 pub unsafe fn CertDeleteCRLFromStore(pcrlcontext: *const CRL_CONTEXT) -> super::super::Foundation::BOOL {
19074     #[cfg(windows)]
19075     {
19076         #[link(name = "windows")]
19077         extern "system" {
19078             fn CertDeleteCRLFromStore(pcrlcontext: *const CRL_CONTEXT) -> super::super::Foundation::BOOL;
19079         }
19080         ::std::mem::transmute(CertDeleteCRLFromStore(::std::mem::transmute(pcrlcontext)))
19081     }
19082     #[cfg(not(windows))]
19083     unimplemented!("Unsupported target OS");
19084 }
19085 #[cfg(feature = "Win32_Foundation")]
19086 #[inline]
CertDeleteCTLFromStore(pctlcontext: *const CTL_CONTEXT) -> super::super::Foundation::BOOL19087 pub unsafe fn CertDeleteCTLFromStore(pctlcontext: *const CTL_CONTEXT) -> super::super::Foundation::BOOL {
19088     #[cfg(windows)]
19089     {
19090         #[link(name = "windows")]
19091         extern "system" {
19092             fn CertDeleteCTLFromStore(pctlcontext: *const CTL_CONTEXT) -> super::super::Foundation::BOOL;
19093         }
19094         ::std::mem::transmute(CertDeleteCTLFromStore(::std::mem::transmute(pctlcontext)))
19095     }
19096     #[cfg(not(windows))]
19097     unimplemented!("Unsupported target OS");
19098 }
19099 #[cfg(feature = "Win32_Foundation")]
19100 #[inline]
CertDeleteCertificateFromStore(pcertcontext: *const CERT_CONTEXT) -> super::super::Foundation::BOOL19101 pub unsafe fn CertDeleteCertificateFromStore(pcertcontext: *const CERT_CONTEXT) -> super::super::Foundation::BOOL {
19102     #[cfg(windows)]
19103     {
19104         #[link(name = "windows")]
19105         extern "system" {
19106             fn CertDeleteCertificateFromStore(pcertcontext: *const CERT_CONTEXT) -> super::super::Foundation::BOOL;
19107         }
19108         ::std::mem::transmute(CertDeleteCertificateFromStore(::std::mem::transmute(pcertcontext)))
19109     }
19110     #[cfg(not(windows))]
19111     unimplemented!("Unsupported target OS");
19112 }
19113 #[cfg(feature = "Win32_Foundation")]
19114 #[inline]
CertDuplicateCRLContext(pcrlcontext: *const CRL_CONTEXT) -> *mut CRL_CONTEXT19115 pub unsafe fn CertDuplicateCRLContext(pcrlcontext: *const CRL_CONTEXT) -> *mut CRL_CONTEXT {
19116     #[cfg(windows)]
19117     {
19118         #[link(name = "windows")]
19119         extern "system" {
19120             fn CertDuplicateCRLContext(pcrlcontext: *const CRL_CONTEXT) -> *mut CRL_CONTEXT;
19121         }
19122         ::std::mem::transmute(CertDuplicateCRLContext(::std::mem::transmute(pcrlcontext)))
19123     }
19124     #[cfg(not(windows))]
19125     unimplemented!("Unsupported target OS");
19126 }
19127 #[cfg(feature = "Win32_Foundation")]
19128 #[inline]
CertDuplicateCTLContext(pctlcontext: *const CTL_CONTEXT) -> *mut CTL_CONTEXT19129 pub unsafe fn CertDuplicateCTLContext(pctlcontext: *const CTL_CONTEXT) -> *mut CTL_CONTEXT {
19130     #[cfg(windows)]
19131     {
19132         #[link(name = "windows")]
19133         extern "system" {
19134             fn CertDuplicateCTLContext(pctlcontext: *const CTL_CONTEXT) -> *mut CTL_CONTEXT;
19135         }
19136         ::std::mem::transmute(CertDuplicateCTLContext(::std::mem::transmute(pctlcontext)))
19137     }
19138     #[cfg(not(windows))]
19139     unimplemented!("Unsupported target OS");
19140 }
19141 #[cfg(feature = "Win32_Foundation")]
19142 #[inline]
CertDuplicateCertificateChain(pchaincontext: *const CERT_CHAIN_CONTEXT) -> *mut CERT_CHAIN_CONTEXT19143 pub unsafe fn CertDuplicateCertificateChain(pchaincontext: *const CERT_CHAIN_CONTEXT) -> *mut CERT_CHAIN_CONTEXT {
19144     #[cfg(windows)]
19145     {
19146         #[link(name = "windows")]
19147         extern "system" {
19148             fn CertDuplicateCertificateChain(pchaincontext: *const CERT_CHAIN_CONTEXT) -> *mut CERT_CHAIN_CONTEXT;
19149         }
19150         ::std::mem::transmute(CertDuplicateCertificateChain(::std::mem::transmute(pchaincontext)))
19151     }
19152     #[cfg(not(windows))]
19153     unimplemented!("Unsupported target OS");
19154 }
19155 #[cfg(feature = "Win32_Foundation")]
19156 #[inline]
CertDuplicateCertificateContext(pcertcontext: *const CERT_CONTEXT) -> *mut CERT_CONTEXT19157 pub unsafe fn CertDuplicateCertificateContext(pcertcontext: *const CERT_CONTEXT) -> *mut CERT_CONTEXT {
19158     #[cfg(windows)]
19159     {
19160         #[link(name = "windows")]
19161         extern "system" {
19162             fn CertDuplicateCertificateContext(pcertcontext: *const CERT_CONTEXT) -> *mut CERT_CONTEXT;
19163         }
19164         ::std::mem::transmute(CertDuplicateCertificateContext(::std::mem::transmute(pcertcontext)))
19165     }
19166     #[cfg(not(windows))]
19167     unimplemented!("Unsupported target OS");
19168 }
19169 #[inline]
CertDuplicateStore(hcertstore: *const ::std::ffi::c_void) -> *mut ::std::ffi::c_void19170 pub unsafe fn CertDuplicateStore(hcertstore: *const ::std::ffi::c_void) -> *mut ::std::ffi::c_void {
19171     #[cfg(windows)]
19172     {
19173         #[link(name = "windows")]
19174         extern "system" {
19175             fn CertDuplicateStore(hcertstore: *const ::std::ffi::c_void) -> *mut ::std::ffi::c_void;
19176         }
19177         ::std::mem::transmute(CertDuplicateStore(::std::mem::transmute(hcertstore)))
19178     }
19179     #[cfg(not(windows))]
19180     unimplemented!("Unsupported target OS");
19181 }
19182 #[cfg(feature = "Win32_Foundation")]
19183 #[inline]
CertEnumCRLContextProperties(pcrlcontext: *const CRL_CONTEXT, dwpropid: u32) -> u3219184 pub unsafe fn CertEnumCRLContextProperties(pcrlcontext: *const CRL_CONTEXT, dwpropid: u32) -> u32 {
19185     #[cfg(windows)]
19186     {
19187         #[link(name = "windows")]
19188         extern "system" {
19189             fn CertEnumCRLContextProperties(pcrlcontext: *const CRL_CONTEXT, dwpropid: u32) -> u32;
19190         }
19191         ::std::mem::transmute(CertEnumCRLContextProperties(::std::mem::transmute(pcrlcontext), ::std::mem::transmute(dwpropid)))
19192     }
19193     #[cfg(not(windows))]
19194     unimplemented!("Unsupported target OS");
19195 }
19196 #[cfg(feature = "Win32_Foundation")]
19197 #[inline]
CertEnumCRLsInStore(hcertstore: *const ::std::ffi::c_void, pprevcrlcontext: *const CRL_CONTEXT) -> *mut CRL_CONTEXT19198 pub unsafe fn CertEnumCRLsInStore(hcertstore: *const ::std::ffi::c_void, pprevcrlcontext: *const CRL_CONTEXT) -> *mut CRL_CONTEXT {
19199     #[cfg(windows)]
19200     {
19201         #[link(name = "windows")]
19202         extern "system" {
19203             fn CertEnumCRLsInStore(hcertstore: *const ::std::ffi::c_void, pprevcrlcontext: *const CRL_CONTEXT) -> *mut CRL_CONTEXT;
19204         }
19205         ::std::mem::transmute(CertEnumCRLsInStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(pprevcrlcontext)))
19206     }
19207     #[cfg(not(windows))]
19208     unimplemented!("Unsupported target OS");
19209 }
19210 #[cfg(feature = "Win32_Foundation")]
19211 #[inline]
CertEnumCTLContextProperties(pctlcontext: *const CTL_CONTEXT, dwpropid: u32) -> u3219212 pub unsafe fn CertEnumCTLContextProperties(pctlcontext: *const CTL_CONTEXT, dwpropid: u32) -> u32 {
19213     #[cfg(windows)]
19214     {
19215         #[link(name = "windows")]
19216         extern "system" {
19217             fn CertEnumCTLContextProperties(pctlcontext: *const CTL_CONTEXT, dwpropid: u32) -> u32;
19218         }
19219         ::std::mem::transmute(CertEnumCTLContextProperties(::std::mem::transmute(pctlcontext), ::std::mem::transmute(dwpropid)))
19220     }
19221     #[cfg(not(windows))]
19222     unimplemented!("Unsupported target OS");
19223 }
19224 #[cfg(feature = "Win32_Foundation")]
19225 #[inline]
CertEnumCTLsInStore(hcertstore: *const ::std::ffi::c_void, pprevctlcontext: *const CTL_CONTEXT) -> *mut CTL_CONTEXT19226 pub unsafe fn CertEnumCTLsInStore(hcertstore: *const ::std::ffi::c_void, pprevctlcontext: *const CTL_CONTEXT) -> *mut CTL_CONTEXT {
19227     #[cfg(windows)]
19228     {
19229         #[link(name = "windows")]
19230         extern "system" {
19231             fn CertEnumCTLsInStore(hcertstore: *const ::std::ffi::c_void, pprevctlcontext: *const CTL_CONTEXT) -> *mut CTL_CONTEXT;
19232         }
19233         ::std::mem::transmute(CertEnumCTLsInStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(pprevctlcontext)))
19234     }
19235     #[cfg(not(windows))]
19236     unimplemented!("Unsupported target OS");
19237 }
19238 #[cfg(feature = "Win32_Foundation")]
19239 #[inline]
CertEnumCertificateContextProperties(pcertcontext: *const CERT_CONTEXT, dwpropid: u32) -> u3219240 pub unsafe fn CertEnumCertificateContextProperties(pcertcontext: *const CERT_CONTEXT, dwpropid: u32) -> u32 {
19241     #[cfg(windows)]
19242     {
19243         #[link(name = "windows")]
19244         extern "system" {
19245             fn CertEnumCertificateContextProperties(pcertcontext: *const CERT_CONTEXT, dwpropid: u32) -> u32;
19246         }
19247         ::std::mem::transmute(CertEnumCertificateContextProperties(::std::mem::transmute(pcertcontext), ::std::mem::transmute(dwpropid)))
19248     }
19249     #[cfg(not(windows))]
19250     unimplemented!("Unsupported target OS");
19251 }
19252 #[cfg(feature = "Win32_Foundation")]
19253 #[inline]
CertEnumCertificatesInStore(hcertstore: *const ::std::ffi::c_void, pprevcertcontext: *const CERT_CONTEXT) -> *mut CERT_CONTEXT19254 pub unsafe fn CertEnumCertificatesInStore(hcertstore: *const ::std::ffi::c_void, pprevcertcontext: *const CERT_CONTEXT) -> *mut CERT_CONTEXT {
19255     #[cfg(windows)]
19256     {
19257         #[link(name = "windows")]
19258         extern "system" {
19259             fn CertEnumCertificatesInStore(hcertstore: *const ::std::ffi::c_void, pprevcertcontext: *const CERT_CONTEXT) -> *mut CERT_CONTEXT;
19260         }
19261         ::std::mem::transmute(CertEnumCertificatesInStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(pprevcertcontext)))
19262     }
19263     #[cfg(not(windows))]
19264     unimplemented!("Unsupported target OS");
19265 }
19266 #[cfg(feature = "Win32_Foundation")]
19267 #[inline]
CertEnumPhysicalStore(pvsystemstore: *const ::std::ffi::c_void, dwflags: u32, pvarg: *mut ::std::ffi::c_void, pfnenum: ::std::option::Option<PFN_CERT_ENUM_PHYSICAL_STORE>) -> super::super::Foundation::BOOL19268 pub unsafe fn CertEnumPhysicalStore(pvsystemstore: *const ::std::ffi::c_void, dwflags: u32, pvarg: *mut ::std::ffi::c_void, pfnenum: ::std::option::Option<PFN_CERT_ENUM_PHYSICAL_STORE>) -> super::super::Foundation::BOOL {
19269     #[cfg(windows)]
19270     {
19271         #[link(name = "windows")]
19272         extern "system" {
19273             fn CertEnumPhysicalStore(pvsystemstore: *const ::std::ffi::c_void, dwflags: u32, pvarg: *mut ::std::ffi::c_void, pfnenum: ::windows::runtime::RawPtr) -> super::super::Foundation::BOOL;
19274         }
19275         ::std::mem::transmute(CertEnumPhysicalStore(::std::mem::transmute(pvsystemstore), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvarg), ::std::mem::transmute(pfnenum)))
19276     }
19277     #[cfg(not(windows))]
19278     unimplemented!("Unsupported target OS");
19279 }
19280 #[cfg(feature = "Win32_Foundation")]
19281 #[inline]
CertEnumSubjectInSortedCTL(pctlcontext: *const CTL_CONTEXT, ppvnextsubject: *mut *mut ::std::ffi::c_void, psubjectidentifier: *mut CRYPTOAPI_BLOB, pencodedattributes: *mut CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL19282 pub unsafe fn CertEnumSubjectInSortedCTL(pctlcontext: *const CTL_CONTEXT, ppvnextsubject: *mut *mut ::std::ffi::c_void, psubjectidentifier: *mut CRYPTOAPI_BLOB, pencodedattributes: *mut CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL {
19283     #[cfg(windows)]
19284     {
19285         #[link(name = "windows")]
19286         extern "system" {
19287             fn CertEnumSubjectInSortedCTL(pctlcontext: *const CTL_CONTEXT, ppvnextsubject: *mut *mut ::std::ffi::c_void, psubjectidentifier: *mut CRYPTOAPI_BLOB, pencodedattributes: *mut CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL;
19288         }
19289         ::std::mem::transmute(CertEnumSubjectInSortedCTL(::std::mem::transmute(pctlcontext), ::std::mem::transmute(ppvnextsubject), ::std::mem::transmute(psubjectidentifier), ::std::mem::transmute(pencodedattributes)))
19290     }
19291     #[cfg(not(windows))]
19292     unimplemented!("Unsupported target OS");
19293 }
19294 #[cfg(feature = "Win32_Foundation")]
19295 #[inline]
CertEnumSystemStore(dwflags: u32, pvsystemstorelocationpara: *const ::std::ffi::c_void, pvarg: *mut ::std::ffi::c_void, pfnenum: ::std::option::Option<PFN_CERT_ENUM_SYSTEM_STORE>) -> super::super::Foundation::BOOL19296 pub unsafe fn CertEnumSystemStore(dwflags: u32, pvsystemstorelocationpara: *const ::std::ffi::c_void, pvarg: *mut ::std::ffi::c_void, pfnenum: ::std::option::Option<PFN_CERT_ENUM_SYSTEM_STORE>) -> super::super::Foundation::BOOL {
19297     #[cfg(windows)]
19298     {
19299         #[link(name = "windows")]
19300         extern "system" {
19301             fn CertEnumSystemStore(dwflags: u32, pvsystemstorelocationpara: *const ::std::ffi::c_void, pvarg: *mut ::std::ffi::c_void, pfnenum: ::windows::runtime::RawPtr) -> super::super::Foundation::BOOL;
19302         }
19303         ::std::mem::transmute(CertEnumSystemStore(::std::mem::transmute(dwflags), ::std::mem::transmute(pvsystemstorelocationpara), ::std::mem::transmute(pvarg), ::std::mem::transmute(pfnenum)))
19304     }
19305     #[cfg(not(windows))]
19306     unimplemented!("Unsupported target OS");
19307 }
19308 #[cfg(feature = "Win32_Foundation")]
19309 #[inline]
CertEnumSystemStoreLocation(dwflags: u32, pvarg: *mut ::std::ffi::c_void, pfnenum: ::std::option::Option<PFN_CERT_ENUM_SYSTEM_STORE_LOCATION>) -> super::super::Foundation::BOOL19310 pub unsafe fn CertEnumSystemStoreLocation(dwflags: u32, pvarg: *mut ::std::ffi::c_void, pfnenum: ::std::option::Option<PFN_CERT_ENUM_SYSTEM_STORE_LOCATION>) -> super::super::Foundation::BOOL {
19311     #[cfg(windows)]
19312     {
19313         #[link(name = "windows")]
19314         extern "system" {
19315             fn CertEnumSystemStoreLocation(dwflags: u32, pvarg: *mut ::std::ffi::c_void, pfnenum: ::windows::runtime::RawPtr) -> super::super::Foundation::BOOL;
19316         }
19317         ::std::mem::transmute(CertEnumSystemStoreLocation(::std::mem::transmute(dwflags), ::std::mem::transmute(pvarg), ::std::mem::transmute(pfnenum)))
19318     }
19319     #[cfg(not(windows))]
19320     unimplemented!("Unsupported target OS");
19321 }
19322 #[cfg(feature = "Win32_Foundation")]
19323 #[inline]
CertFindAttribute<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszobjid: Param0, cattr: u32, rgattr: *const CRYPT_ATTRIBUTE) -> *mut CRYPT_ATTRIBUTE19324 pub unsafe fn CertFindAttribute<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszobjid: Param0, cattr: u32, rgattr: *const CRYPT_ATTRIBUTE) -> *mut CRYPT_ATTRIBUTE {
19325     #[cfg(windows)]
19326     {
19327         #[link(name = "windows")]
19328         extern "system" {
19329             fn CertFindAttribute(pszobjid: super::super::Foundation::PSTR, cattr: u32, rgattr: *const CRYPT_ATTRIBUTE) -> *mut CRYPT_ATTRIBUTE;
19330         }
19331         ::std::mem::transmute(CertFindAttribute(pszobjid.into_param().abi(), ::std::mem::transmute(cattr), ::std::mem::transmute(rgattr)))
19332     }
19333     #[cfg(not(windows))]
19334     unimplemented!("Unsupported target OS");
19335 }
19336 #[cfg(feature = "Win32_Foundation")]
19337 #[inline]
CertFindCRLInStore(hcertstore: *const ::std::ffi::c_void, dwcertencodingtype: u32, dwfindflags: u32, dwfindtype: u32, pvfindpara: *const ::std::ffi::c_void, pprevcrlcontext: *const CRL_CONTEXT) -> *mut CRL_CONTEXT19338 pub unsafe fn CertFindCRLInStore(hcertstore: *const ::std::ffi::c_void, dwcertencodingtype: u32, dwfindflags: u32, dwfindtype: u32, pvfindpara: *const ::std::ffi::c_void, pprevcrlcontext: *const CRL_CONTEXT) -> *mut CRL_CONTEXT {
19339     #[cfg(windows)]
19340     {
19341         #[link(name = "windows")]
19342         extern "system" {
19343             fn CertFindCRLInStore(hcertstore: *const ::std::ffi::c_void, dwcertencodingtype: u32, dwfindflags: u32, dwfindtype: u32, pvfindpara: *const ::std::ffi::c_void, pprevcrlcontext: *const CRL_CONTEXT) -> *mut CRL_CONTEXT;
19344         }
19345         ::std::mem::transmute(CertFindCRLInStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(dwfindflags), ::std::mem::transmute(dwfindtype), ::std::mem::transmute(pvfindpara), ::std::mem::transmute(pprevcrlcontext)))
19346     }
19347     #[cfg(not(windows))]
19348     unimplemented!("Unsupported target OS");
19349 }
19350 #[cfg(feature = "Win32_Foundation")]
19351 #[inline]
CertFindCTLInStore(hcertstore: *const ::std::ffi::c_void, dwmsgandcertencodingtype: u32, dwfindflags: u32, dwfindtype: CERT_FIND_TYPE, pvfindpara: *const ::std::ffi::c_void, pprevctlcontext: *const CTL_CONTEXT) -> *mut CTL_CONTEXT19352 pub unsafe fn CertFindCTLInStore(hcertstore: *const ::std::ffi::c_void, dwmsgandcertencodingtype: u32, dwfindflags: u32, dwfindtype: CERT_FIND_TYPE, pvfindpara: *const ::std::ffi::c_void, pprevctlcontext: *const CTL_CONTEXT) -> *mut CTL_CONTEXT {
19353     #[cfg(windows)]
19354     {
19355         #[link(name = "windows")]
19356         extern "system" {
19357             fn CertFindCTLInStore(hcertstore: *const ::std::ffi::c_void, dwmsgandcertencodingtype: u32, dwfindflags: u32, dwfindtype: CERT_FIND_TYPE, pvfindpara: *const ::std::ffi::c_void, pprevctlcontext: *const CTL_CONTEXT) -> *mut CTL_CONTEXT;
19358         }
19359         ::std::mem::transmute(CertFindCTLInStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(dwmsgandcertencodingtype), ::std::mem::transmute(dwfindflags), ::std::mem::transmute(dwfindtype), ::std::mem::transmute(pvfindpara), ::std::mem::transmute(pprevctlcontext)))
19360     }
19361     #[cfg(not(windows))]
19362     unimplemented!("Unsupported target OS");
19363 }
19364 #[cfg(feature = "Win32_Foundation")]
19365 #[inline]
CertFindCertificateInCRL(pcert: *const CERT_CONTEXT, pcrlcontext: *const CRL_CONTEXT, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, ppcrlentry: *mut *mut CRL_ENTRY) -> super::super::Foundation::BOOL19366 pub unsafe fn CertFindCertificateInCRL(pcert: *const CERT_CONTEXT, pcrlcontext: *const CRL_CONTEXT, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, ppcrlentry: *mut *mut CRL_ENTRY) -> super::super::Foundation::BOOL {
19367     #[cfg(windows)]
19368     {
19369         #[link(name = "windows")]
19370         extern "system" {
19371             fn CertFindCertificateInCRL(pcert: *const CERT_CONTEXT, pcrlcontext: *const CRL_CONTEXT, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, ppcrlentry: *mut *mut CRL_ENTRY) -> super::super::Foundation::BOOL;
19372         }
19373         ::std::mem::transmute(CertFindCertificateInCRL(::std::mem::transmute(pcert), ::std::mem::transmute(pcrlcontext), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvreserved), ::std::mem::transmute(ppcrlentry)))
19374     }
19375     #[cfg(not(windows))]
19376     unimplemented!("Unsupported target OS");
19377 }
19378 #[cfg(feature = "Win32_Foundation")]
19379 #[inline]
CertFindCertificateInStore(hcertstore: *const ::std::ffi::c_void, dwcertencodingtype: u32, dwfindflags: u32, dwfindtype: CERT_FIND_FLAGS, pvfindpara: *const ::std::ffi::c_void, pprevcertcontext: *const CERT_CONTEXT) -> *mut CERT_CONTEXT19380 pub unsafe fn CertFindCertificateInStore(hcertstore: *const ::std::ffi::c_void, dwcertencodingtype: u32, dwfindflags: u32, dwfindtype: CERT_FIND_FLAGS, pvfindpara: *const ::std::ffi::c_void, pprevcertcontext: *const CERT_CONTEXT) -> *mut CERT_CONTEXT {
19381     #[cfg(windows)]
19382     {
19383         #[link(name = "windows")]
19384         extern "system" {
19385             fn CertFindCertificateInStore(hcertstore: *const ::std::ffi::c_void, dwcertencodingtype: u32, dwfindflags: u32, dwfindtype: CERT_FIND_FLAGS, pvfindpara: *const ::std::ffi::c_void, pprevcertcontext: *const CERT_CONTEXT) -> *mut CERT_CONTEXT;
19386         }
19387         ::std::mem::transmute(CertFindCertificateInStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(dwfindflags), ::std::mem::transmute(dwfindtype), ::std::mem::transmute(pvfindpara), ::std::mem::transmute(pprevcertcontext)))
19388     }
19389     #[cfg(not(windows))]
19390     unimplemented!("Unsupported target OS");
19391 }
19392 #[cfg(feature = "Win32_Foundation")]
19393 #[inline]
CertFindChainInStore(hcertstore: *const ::std::ffi::c_void, dwcertencodingtype: u32, dwfindflags: CERT_FIND_CHAIN_IN_STORE_FLAGS, dwfindtype: u32, pvfindpara: *const ::std::ffi::c_void, pprevchaincontext: *const CERT_CHAIN_CONTEXT) -> *mut CERT_CHAIN_CONTEXT19394 pub unsafe fn CertFindChainInStore(hcertstore: *const ::std::ffi::c_void, dwcertencodingtype: u32, dwfindflags: CERT_FIND_CHAIN_IN_STORE_FLAGS, dwfindtype: u32, pvfindpara: *const ::std::ffi::c_void, pprevchaincontext: *const CERT_CHAIN_CONTEXT) -> *mut CERT_CHAIN_CONTEXT {
19395     #[cfg(windows)]
19396     {
19397         #[link(name = "windows")]
19398         extern "system" {
19399             fn CertFindChainInStore(hcertstore: *const ::std::ffi::c_void, dwcertencodingtype: u32, dwfindflags: CERT_FIND_CHAIN_IN_STORE_FLAGS, dwfindtype: u32, pvfindpara: *const ::std::ffi::c_void, pprevchaincontext: *const CERT_CHAIN_CONTEXT) -> *mut CERT_CHAIN_CONTEXT;
19400         }
19401         ::std::mem::transmute(CertFindChainInStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(dwfindflags), ::std::mem::transmute(dwfindtype), ::std::mem::transmute(pvfindpara), ::std::mem::transmute(pprevchaincontext)))
19402     }
19403     #[cfg(not(windows))]
19404     unimplemented!("Unsupported target OS");
19405 }
19406 #[cfg(feature = "Win32_Foundation")]
19407 #[inline]
CertFindExtension<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszobjid: Param0, cextensions: u32, rgextensions: *const CERT_EXTENSION) -> *mut CERT_EXTENSION19408 pub unsafe fn CertFindExtension<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszobjid: Param0, cextensions: u32, rgextensions: *const CERT_EXTENSION) -> *mut CERT_EXTENSION {
19409     #[cfg(windows)]
19410     {
19411         #[link(name = "windows")]
19412         extern "system" {
19413             fn CertFindExtension(pszobjid: super::super::Foundation::PSTR, cextensions: u32, rgextensions: *const CERT_EXTENSION) -> *mut CERT_EXTENSION;
19414         }
19415         ::std::mem::transmute(CertFindExtension(pszobjid.into_param().abi(), ::std::mem::transmute(cextensions), ::std::mem::transmute(rgextensions)))
19416     }
19417     #[cfg(not(windows))]
19418     unimplemented!("Unsupported target OS");
19419 }
19420 #[cfg(feature = "Win32_Foundation")]
19421 #[inline]
CertFindRDNAttr<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszobjid: Param0, pname: *const CERT_NAME_INFO) -> *mut CERT_RDN_ATTR19422 pub unsafe fn CertFindRDNAttr<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszobjid: Param0, pname: *const CERT_NAME_INFO) -> *mut CERT_RDN_ATTR {
19423     #[cfg(windows)]
19424     {
19425         #[link(name = "windows")]
19426         extern "system" {
19427             fn CertFindRDNAttr(pszobjid: super::super::Foundation::PSTR, pname: *const CERT_NAME_INFO) -> *mut CERT_RDN_ATTR;
19428         }
19429         ::std::mem::transmute(CertFindRDNAttr(pszobjid.into_param().abi(), ::std::mem::transmute(pname)))
19430     }
19431     #[cfg(not(windows))]
19432     unimplemented!("Unsupported target OS");
19433 }
19434 #[cfg(feature = "Win32_Foundation")]
19435 #[inline]
CertFindSubjectInCTL(dwencodingtype: u32, dwsubjecttype: u32, pvsubject: *const ::std::ffi::c_void, pctlcontext: *const CTL_CONTEXT, dwflags: u32) -> *mut CTL_ENTRY19436 pub unsafe fn CertFindSubjectInCTL(dwencodingtype: u32, dwsubjecttype: u32, pvsubject: *const ::std::ffi::c_void, pctlcontext: *const CTL_CONTEXT, dwflags: u32) -> *mut CTL_ENTRY {
19437     #[cfg(windows)]
19438     {
19439         #[link(name = "windows")]
19440         extern "system" {
19441             fn CertFindSubjectInCTL(dwencodingtype: u32, dwsubjecttype: u32, pvsubject: *const ::std::ffi::c_void, pctlcontext: *const CTL_CONTEXT, dwflags: u32) -> *mut CTL_ENTRY;
19442         }
19443         ::std::mem::transmute(CertFindSubjectInCTL(::std::mem::transmute(dwencodingtype), ::std::mem::transmute(dwsubjecttype), ::std::mem::transmute(pvsubject), ::std::mem::transmute(pctlcontext), ::std::mem::transmute(dwflags)))
19444     }
19445     #[cfg(not(windows))]
19446     unimplemented!("Unsupported target OS");
19447 }
19448 #[cfg(feature = "Win32_Foundation")]
19449 #[inline]
CertFindSubjectInSortedCTL(psubjectidentifier: *const CRYPTOAPI_BLOB, pctlcontext: *const CTL_CONTEXT, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, pencodedattributes: *mut CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL19450 pub unsafe fn CertFindSubjectInSortedCTL(psubjectidentifier: *const CRYPTOAPI_BLOB, pctlcontext: *const CTL_CONTEXT, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, pencodedattributes: *mut CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL {
19451     #[cfg(windows)]
19452     {
19453         #[link(name = "windows")]
19454         extern "system" {
19455             fn CertFindSubjectInSortedCTL(psubjectidentifier: *const CRYPTOAPI_BLOB, pctlcontext: *const CTL_CONTEXT, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, pencodedattributes: *mut CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL;
19456         }
19457         ::std::mem::transmute(CertFindSubjectInSortedCTL(::std::mem::transmute(psubjectidentifier), ::std::mem::transmute(pctlcontext), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvreserved), ::std::mem::transmute(pencodedattributes)))
19458     }
19459     #[cfg(not(windows))]
19460     unimplemented!("Unsupported target OS");
19461 }
19462 #[cfg(feature = "Win32_Foundation")]
19463 #[inline]
CertFreeCRLContext(pcrlcontext: *const CRL_CONTEXT) -> super::super::Foundation::BOOL19464 pub unsafe fn CertFreeCRLContext(pcrlcontext: *const CRL_CONTEXT) -> super::super::Foundation::BOOL {
19465     #[cfg(windows)]
19466     {
19467         #[link(name = "windows")]
19468         extern "system" {
19469             fn CertFreeCRLContext(pcrlcontext: *const CRL_CONTEXT) -> super::super::Foundation::BOOL;
19470         }
19471         ::std::mem::transmute(CertFreeCRLContext(::std::mem::transmute(pcrlcontext)))
19472     }
19473     #[cfg(not(windows))]
19474     unimplemented!("Unsupported target OS");
19475 }
19476 #[cfg(feature = "Win32_Foundation")]
19477 #[inline]
CertFreeCTLContext(pctlcontext: *const CTL_CONTEXT) -> super::super::Foundation::BOOL19478 pub unsafe fn CertFreeCTLContext(pctlcontext: *const CTL_CONTEXT) -> super::super::Foundation::BOOL {
19479     #[cfg(windows)]
19480     {
19481         #[link(name = "windows")]
19482         extern "system" {
19483             fn CertFreeCTLContext(pctlcontext: *const CTL_CONTEXT) -> super::super::Foundation::BOOL;
19484         }
19485         ::std::mem::transmute(CertFreeCTLContext(::std::mem::transmute(pctlcontext)))
19486     }
19487     #[cfg(not(windows))]
19488     unimplemented!("Unsupported target OS");
19489 }
19490 #[cfg(feature = "Win32_Foundation")]
19491 #[inline]
CertFreeCertificateChain(pchaincontext: *const CERT_CHAIN_CONTEXT)19492 pub unsafe fn CertFreeCertificateChain(pchaincontext: *const CERT_CHAIN_CONTEXT) {
19493     #[cfg(windows)]
19494     {
19495         #[link(name = "windows")]
19496         extern "system" {
19497             fn CertFreeCertificateChain(pchaincontext: *const CERT_CHAIN_CONTEXT);
19498         }
19499         ::std::mem::transmute(CertFreeCertificateChain(::std::mem::transmute(pchaincontext)))
19500     }
19501     #[cfg(not(windows))]
19502     unimplemented!("Unsupported target OS");
19503 }
19504 #[inline]
CertFreeCertificateChainEngine<'a, Param0: ::windows::runtime::IntoParam<'a, HCERTCHAINENGINE>>(hchainengine: Param0)19505 pub unsafe fn CertFreeCertificateChainEngine<'a, Param0: ::windows::runtime::IntoParam<'a, HCERTCHAINENGINE>>(hchainengine: Param0) {
19506     #[cfg(windows)]
19507     {
19508         #[link(name = "windows")]
19509         extern "system" {
19510             fn CertFreeCertificateChainEngine(hchainengine: HCERTCHAINENGINE);
19511         }
19512         ::std::mem::transmute(CertFreeCertificateChainEngine(hchainengine.into_param().abi()))
19513     }
19514     #[cfg(not(windows))]
19515     unimplemented!("Unsupported target OS");
19516 }
19517 #[cfg(feature = "Win32_Foundation")]
19518 #[inline]
CertFreeCertificateChainList(prgpselection: *const *const CERT_CHAIN_CONTEXT)19519 pub unsafe fn CertFreeCertificateChainList(prgpselection: *const *const CERT_CHAIN_CONTEXT) {
19520     #[cfg(windows)]
19521     {
19522         #[link(name = "windows")]
19523         extern "system" {
19524             fn CertFreeCertificateChainList(prgpselection: *const *const CERT_CHAIN_CONTEXT);
19525         }
19526         ::std::mem::transmute(CertFreeCertificateChainList(::std::mem::transmute(prgpselection)))
19527     }
19528     #[cfg(not(windows))]
19529     unimplemented!("Unsupported target OS");
19530 }
19531 #[cfg(feature = "Win32_Foundation")]
19532 #[inline]
CertFreeCertificateContext(pcertcontext: *const CERT_CONTEXT) -> super::super::Foundation::BOOL19533 pub unsafe fn CertFreeCertificateContext(pcertcontext: *const CERT_CONTEXT) -> super::super::Foundation::BOOL {
19534     #[cfg(windows)]
19535     {
19536         #[link(name = "windows")]
19537         extern "system" {
19538             fn CertFreeCertificateContext(pcertcontext: *const CERT_CONTEXT) -> super::super::Foundation::BOOL;
19539         }
19540         ::std::mem::transmute(CertFreeCertificateContext(::std::mem::transmute(pcertcontext)))
19541     }
19542     #[cfg(not(windows))]
19543     unimplemented!("Unsupported target OS");
19544 }
19545 #[inline]
CertFreeServerOcspResponseContext(pserverocspresponsecontext: *const CERT_SERVER_OCSP_RESPONSE_CONTEXT)19546 pub unsafe fn CertFreeServerOcspResponseContext(pserverocspresponsecontext: *const CERT_SERVER_OCSP_RESPONSE_CONTEXT) {
19547     #[cfg(windows)]
19548     {
19549         #[link(name = "windows")]
19550         extern "system" {
19551             fn CertFreeServerOcspResponseContext(pserverocspresponsecontext: *const CERT_SERVER_OCSP_RESPONSE_CONTEXT);
19552         }
19553         ::std::mem::transmute(CertFreeServerOcspResponseContext(::std::mem::transmute(pserverocspresponsecontext)))
19554     }
19555     #[cfg(not(windows))]
19556     unimplemented!("Unsupported target OS");
19557 }
19558 #[cfg(feature = "Win32_Foundation")]
19559 #[inline]
CertGetCRLContextProperty(pcrlcontext: *const CRL_CONTEXT, dwpropid: u32, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL19560 pub unsafe fn CertGetCRLContextProperty(pcrlcontext: *const CRL_CONTEXT, dwpropid: u32, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL {
19561     #[cfg(windows)]
19562     {
19563         #[link(name = "windows")]
19564         extern "system" {
19565             fn CertGetCRLContextProperty(pcrlcontext: *const CRL_CONTEXT, dwpropid: u32, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL;
19566         }
19567         ::std::mem::transmute(CertGetCRLContextProperty(::std::mem::transmute(pcrlcontext), ::std::mem::transmute(dwpropid), ::std::mem::transmute(pvdata), ::std::mem::transmute(pcbdata)))
19568     }
19569     #[cfg(not(windows))]
19570     unimplemented!("Unsupported target OS");
19571 }
19572 #[cfg(feature = "Win32_Foundation")]
19573 #[inline]
CertGetCRLFromStore(hcertstore: *const ::std::ffi::c_void, pissuercontext: *const CERT_CONTEXT, pprevcrlcontext: *const CRL_CONTEXT, pdwflags: *mut u32) -> *mut CRL_CONTEXT19574 pub unsafe fn CertGetCRLFromStore(hcertstore: *const ::std::ffi::c_void, pissuercontext: *const CERT_CONTEXT, pprevcrlcontext: *const CRL_CONTEXT, pdwflags: *mut u32) -> *mut CRL_CONTEXT {
19575     #[cfg(windows)]
19576     {
19577         #[link(name = "windows")]
19578         extern "system" {
19579             fn CertGetCRLFromStore(hcertstore: *const ::std::ffi::c_void, pissuercontext: *const CERT_CONTEXT, pprevcrlcontext: *const CRL_CONTEXT, pdwflags: *mut u32) -> *mut CRL_CONTEXT;
19580         }
19581         ::std::mem::transmute(CertGetCRLFromStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(pissuercontext), ::std::mem::transmute(pprevcrlcontext), ::std::mem::transmute(pdwflags)))
19582     }
19583     #[cfg(not(windows))]
19584     unimplemented!("Unsupported target OS");
19585 }
19586 #[cfg(feature = "Win32_Foundation")]
19587 #[inline]
CertGetCTLContextProperty(pctlcontext: *const CTL_CONTEXT, dwpropid: u32, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL19588 pub unsafe fn CertGetCTLContextProperty(pctlcontext: *const CTL_CONTEXT, dwpropid: u32, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL {
19589     #[cfg(windows)]
19590     {
19591         #[link(name = "windows")]
19592         extern "system" {
19593             fn CertGetCTLContextProperty(pctlcontext: *const CTL_CONTEXT, dwpropid: u32, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL;
19594         }
19595         ::std::mem::transmute(CertGetCTLContextProperty(::std::mem::transmute(pctlcontext), ::std::mem::transmute(dwpropid), ::std::mem::transmute(pvdata), ::std::mem::transmute(pcbdata)))
19596     }
19597     #[cfg(not(windows))]
19598     unimplemented!("Unsupported target OS");
19599 }
19600 #[cfg(feature = "Win32_Foundation")]
19601 #[inline]
CertGetCertificateChain<'a, Param0: ::windows::runtime::IntoParam<'a, HCERTCHAINENGINE>>(hchainengine: Param0, pcertcontext: *const CERT_CONTEXT, ptime: *const super::super::Foundation::FILETIME, hadditionalstore: *const ::std::ffi::c_void, pchainpara: *const CERT_CHAIN_PARA, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, ppchaincontext: *mut *mut CERT_CHAIN_CONTEXT) -> super::super::Foundation::BOOL19602 pub unsafe fn CertGetCertificateChain<'a, Param0: ::windows::runtime::IntoParam<'a, HCERTCHAINENGINE>>(hchainengine: Param0, pcertcontext: *const CERT_CONTEXT, ptime: *const super::super::Foundation::FILETIME, hadditionalstore: *const ::std::ffi::c_void, pchainpara: *const CERT_CHAIN_PARA, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, ppchaincontext: *mut *mut CERT_CHAIN_CONTEXT) -> super::super::Foundation::BOOL {
19603     #[cfg(windows)]
19604     {
19605         #[link(name = "windows")]
19606         extern "system" {
19607             fn CertGetCertificateChain(hchainengine: HCERTCHAINENGINE, pcertcontext: *const CERT_CONTEXT, ptime: *const super::super::Foundation::FILETIME, hadditionalstore: *const ::std::ffi::c_void, pchainpara: *const CERT_CHAIN_PARA, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, ppchaincontext: *mut *mut CERT_CHAIN_CONTEXT) -> super::super::Foundation::BOOL;
19608         }
19609         ::std::mem::transmute(CertGetCertificateChain(
19610             hchainengine.into_param().abi(),
19611             ::std::mem::transmute(pcertcontext),
19612             ::std::mem::transmute(ptime),
19613             ::std::mem::transmute(hadditionalstore),
19614             ::std::mem::transmute(pchainpara),
19615             ::std::mem::transmute(dwflags),
19616             ::std::mem::transmute(pvreserved),
19617             ::std::mem::transmute(ppchaincontext),
19618         ))
19619     }
19620     #[cfg(not(windows))]
19621     unimplemented!("Unsupported target OS");
19622 }
19623 #[cfg(feature = "Win32_Foundation")]
19624 #[inline]
CertGetCertificateContextProperty(pcertcontext: *const CERT_CONTEXT, dwpropid: u32, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL19625 pub unsafe fn CertGetCertificateContextProperty(pcertcontext: *const CERT_CONTEXT, dwpropid: u32, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL {
19626     #[cfg(windows)]
19627     {
19628         #[link(name = "windows")]
19629         extern "system" {
19630             fn CertGetCertificateContextProperty(pcertcontext: *const CERT_CONTEXT, dwpropid: u32, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL;
19631         }
19632         ::std::mem::transmute(CertGetCertificateContextProperty(::std::mem::transmute(pcertcontext), ::std::mem::transmute(dwpropid), ::std::mem::transmute(pvdata), ::std::mem::transmute(pcbdata)))
19633     }
19634     #[cfg(not(windows))]
19635     unimplemented!("Unsupported target OS");
19636 }
19637 #[cfg(feature = "Win32_Foundation")]
19638 #[inline]
CertGetEnhancedKeyUsage(pcertcontext: *const CERT_CONTEXT, dwflags: u32, pusage: *mut CTL_USAGE, pcbusage: *mut u32) -> super::super::Foundation::BOOL19639 pub unsafe fn CertGetEnhancedKeyUsage(pcertcontext: *const CERT_CONTEXT, dwflags: u32, pusage: *mut CTL_USAGE, pcbusage: *mut u32) -> super::super::Foundation::BOOL {
19640     #[cfg(windows)]
19641     {
19642         #[link(name = "windows")]
19643         extern "system" {
19644             fn CertGetEnhancedKeyUsage(pcertcontext: *const CERT_CONTEXT, dwflags: u32, pusage: *mut CTL_USAGE, pcbusage: *mut u32) -> super::super::Foundation::BOOL;
19645         }
19646         ::std::mem::transmute(CertGetEnhancedKeyUsage(::std::mem::transmute(pcertcontext), ::std::mem::transmute(dwflags), ::std::mem::transmute(pusage), ::std::mem::transmute(pcbusage)))
19647     }
19648     #[cfg(not(windows))]
19649     unimplemented!("Unsupported target OS");
19650 }
19651 #[cfg(feature = "Win32_Foundation")]
19652 #[inline]
CertGetIntendedKeyUsage(dwcertencodingtype: u32, pcertinfo: *const CERT_INFO, pbkeyusage: *mut u8, cbkeyusage: u32) -> super::super::Foundation::BOOL19653 pub unsafe fn CertGetIntendedKeyUsage(dwcertencodingtype: u32, pcertinfo: *const CERT_INFO, pbkeyusage: *mut u8, cbkeyusage: u32) -> super::super::Foundation::BOOL {
19654     #[cfg(windows)]
19655     {
19656         #[link(name = "windows")]
19657         extern "system" {
19658             fn CertGetIntendedKeyUsage(dwcertencodingtype: u32, pcertinfo: *const CERT_INFO, pbkeyusage: *mut u8, cbkeyusage: u32) -> super::super::Foundation::BOOL;
19659         }
19660         ::std::mem::transmute(CertGetIntendedKeyUsage(::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(pcertinfo), ::std::mem::transmute(pbkeyusage), ::std::mem::transmute(cbkeyusage)))
19661     }
19662     #[cfg(not(windows))]
19663     unimplemented!("Unsupported target OS");
19664 }
19665 #[cfg(feature = "Win32_Foundation")]
19666 #[inline]
CertGetIssuerCertificateFromStore(hcertstore: *const ::std::ffi::c_void, psubjectcontext: *const CERT_CONTEXT, pprevissuercontext: *const CERT_CONTEXT, pdwflags: *mut u32) -> *mut CERT_CONTEXT19667 pub unsafe fn CertGetIssuerCertificateFromStore(hcertstore: *const ::std::ffi::c_void, psubjectcontext: *const CERT_CONTEXT, pprevissuercontext: *const CERT_CONTEXT, pdwflags: *mut u32) -> *mut CERT_CONTEXT {
19668     #[cfg(windows)]
19669     {
19670         #[link(name = "windows")]
19671         extern "system" {
19672             fn CertGetIssuerCertificateFromStore(hcertstore: *const ::std::ffi::c_void, psubjectcontext: *const CERT_CONTEXT, pprevissuercontext: *const CERT_CONTEXT, pdwflags: *mut u32) -> *mut CERT_CONTEXT;
19673         }
19674         ::std::mem::transmute(CertGetIssuerCertificateFromStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(psubjectcontext), ::std::mem::transmute(pprevissuercontext), ::std::mem::transmute(pdwflags)))
19675     }
19676     #[cfg(not(windows))]
19677     unimplemented!("Unsupported target OS");
19678 }
19679 #[cfg(feature = "Win32_Foundation")]
19680 #[inline]
CertGetNameStringA(pcertcontext: *const CERT_CONTEXT, dwtype: u32, dwflags: u32, pvtypepara: *const ::std::ffi::c_void, psznamestring: super::super::Foundation::PSTR, cchnamestring: u32) -> u3219681 pub unsafe fn CertGetNameStringA(pcertcontext: *const CERT_CONTEXT, dwtype: u32, dwflags: u32, pvtypepara: *const ::std::ffi::c_void, psznamestring: super::super::Foundation::PSTR, cchnamestring: u32) -> u32 {
19682     #[cfg(windows)]
19683     {
19684         #[link(name = "windows")]
19685         extern "system" {
19686             fn CertGetNameStringA(pcertcontext: *const CERT_CONTEXT, dwtype: u32, dwflags: u32, pvtypepara: *const ::std::ffi::c_void, psznamestring: super::super::Foundation::PSTR, cchnamestring: u32) -> u32;
19687         }
19688         ::std::mem::transmute(CertGetNameStringA(::std::mem::transmute(pcertcontext), ::std::mem::transmute(dwtype), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvtypepara), ::std::mem::transmute(psznamestring), ::std::mem::transmute(cchnamestring)))
19689     }
19690     #[cfg(not(windows))]
19691     unimplemented!("Unsupported target OS");
19692 }
19693 #[cfg(feature = "Win32_Foundation")]
19694 #[inline]
CertGetNameStringW(pcertcontext: *const CERT_CONTEXT, dwtype: u32, dwflags: u32, pvtypepara: *const ::std::ffi::c_void, psznamestring: super::super::Foundation::PWSTR, cchnamestring: u32) -> u3219695 pub unsafe fn CertGetNameStringW(pcertcontext: *const CERT_CONTEXT, dwtype: u32, dwflags: u32, pvtypepara: *const ::std::ffi::c_void, psznamestring: super::super::Foundation::PWSTR, cchnamestring: u32) -> u32 {
19696     #[cfg(windows)]
19697     {
19698         #[link(name = "windows")]
19699         extern "system" {
19700             fn CertGetNameStringW(pcertcontext: *const CERT_CONTEXT, dwtype: u32, dwflags: u32, pvtypepara: *const ::std::ffi::c_void, psznamestring: super::super::Foundation::PWSTR, cchnamestring: u32) -> u32;
19701         }
19702         ::std::mem::transmute(CertGetNameStringW(::std::mem::transmute(pcertcontext), ::std::mem::transmute(dwtype), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvtypepara), ::std::mem::transmute(psznamestring), ::std::mem::transmute(cchnamestring)))
19703     }
19704     #[cfg(not(windows))]
19705     unimplemented!("Unsupported target OS");
19706 }
19707 #[cfg(feature = "Win32_Foundation")]
19708 #[inline]
CertGetPublicKeyLength(dwcertencodingtype: u32, ppublickey: *const CERT_PUBLIC_KEY_INFO) -> u3219709 pub unsafe fn CertGetPublicKeyLength(dwcertencodingtype: u32, ppublickey: *const CERT_PUBLIC_KEY_INFO) -> u32 {
19710     #[cfg(windows)]
19711     {
19712         #[link(name = "windows")]
19713         extern "system" {
19714             fn CertGetPublicKeyLength(dwcertencodingtype: u32, ppublickey: *const CERT_PUBLIC_KEY_INFO) -> u32;
19715         }
19716         ::std::mem::transmute(CertGetPublicKeyLength(::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(ppublickey)))
19717     }
19718     #[cfg(not(windows))]
19719     unimplemented!("Unsupported target OS");
19720 }
19721 #[inline]
CertGetServerOcspResponseContext(hserverocspresponse: *const ::std::ffi::c_void, dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> *mut CERT_SERVER_OCSP_RESPONSE_CONTEXT19722 pub unsafe fn CertGetServerOcspResponseContext(hserverocspresponse: *const ::std::ffi::c_void, dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> *mut CERT_SERVER_OCSP_RESPONSE_CONTEXT {
19723     #[cfg(windows)]
19724     {
19725         #[link(name = "windows")]
19726         extern "system" {
19727             fn CertGetServerOcspResponseContext(hserverocspresponse: *const ::std::ffi::c_void, dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> *mut CERT_SERVER_OCSP_RESPONSE_CONTEXT;
19728         }
19729         ::std::mem::transmute(CertGetServerOcspResponseContext(::std::mem::transmute(hserverocspresponse), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvreserved)))
19730     }
19731     #[cfg(not(windows))]
19732     unimplemented!("Unsupported target OS");
19733 }
19734 #[cfg(feature = "Win32_Foundation")]
19735 #[inline]
CertGetStoreProperty(hcertstore: *const ::std::ffi::c_void, dwpropid: u32, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL19736 pub unsafe fn CertGetStoreProperty(hcertstore: *const ::std::ffi::c_void, dwpropid: u32, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL {
19737     #[cfg(windows)]
19738     {
19739         #[link(name = "windows")]
19740         extern "system" {
19741             fn CertGetStoreProperty(hcertstore: *const ::std::ffi::c_void, dwpropid: u32, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL;
19742         }
19743         ::std::mem::transmute(CertGetStoreProperty(::std::mem::transmute(hcertstore), ::std::mem::transmute(dwpropid), ::std::mem::transmute(pvdata), ::std::mem::transmute(pcbdata)))
19744     }
19745     #[cfg(not(windows))]
19746     unimplemented!("Unsupported target OS");
19747 }
19748 #[cfg(feature = "Win32_Foundation")]
19749 #[inline]
CertGetSubjectCertificateFromStore(hcertstore: *const ::std::ffi::c_void, dwcertencodingtype: u32, pcertid: *const CERT_INFO) -> *mut CERT_CONTEXT19750 pub unsafe fn CertGetSubjectCertificateFromStore(hcertstore: *const ::std::ffi::c_void, dwcertencodingtype: u32, pcertid: *const CERT_INFO) -> *mut CERT_CONTEXT {
19751     #[cfg(windows)]
19752     {
19753         #[link(name = "windows")]
19754         extern "system" {
19755             fn CertGetSubjectCertificateFromStore(hcertstore: *const ::std::ffi::c_void, dwcertencodingtype: u32, pcertid: *const CERT_INFO) -> *mut CERT_CONTEXT;
19756         }
19757         ::std::mem::transmute(CertGetSubjectCertificateFromStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(pcertid)))
19758     }
19759     #[cfg(not(windows))]
19760     unimplemented!("Unsupported target OS");
19761 }
19762 #[cfg(feature = "Win32_Foundation")]
19763 #[inline]
CertGetValidUsages(ccerts: u32, rghcerts: *const *const CERT_CONTEXT, cnumoids: *mut i32, rghoids: *mut super::super::Foundation::PSTR, pcboids: *mut u32) -> super::super::Foundation::BOOL19764 pub unsafe fn CertGetValidUsages(ccerts: u32, rghcerts: *const *const CERT_CONTEXT, cnumoids: *mut i32, rghoids: *mut super::super::Foundation::PSTR, pcboids: *mut u32) -> super::super::Foundation::BOOL {
19765     #[cfg(windows)]
19766     {
19767         #[link(name = "windows")]
19768         extern "system" {
19769             fn CertGetValidUsages(ccerts: u32, rghcerts: *const *const CERT_CONTEXT, cnumoids: *mut i32, rghoids: *mut super::super::Foundation::PSTR, pcboids: *mut u32) -> super::super::Foundation::BOOL;
19770         }
19771         ::std::mem::transmute(CertGetValidUsages(::std::mem::transmute(ccerts), ::std::mem::transmute(rghcerts), ::std::mem::transmute(cnumoids), ::std::mem::transmute(rghoids), ::std::mem::transmute(pcboids)))
19772     }
19773     #[cfg(not(windows))]
19774     unimplemented!("Unsupported target OS");
19775 }
19776 #[cfg(feature = "Win32_Foundation")]
19777 #[inline]
CertIsRDNAttrsInCertificateName(dwcertencodingtype: u32, dwflags: u32, pcertname: *const CRYPTOAPI_BLOB, prdn: *const CERT_RDN) -> super::super::Foundation::BOOL19778 pub unsafe fn CertIsRDNAttrsInCertificateName(dwcertencodingtype: u32, dwflags: u32, pcertname: *const CRYPTOAPI_BLOB, prdn: *const CERT_RDN) -> super::super::Foundation::BOOL {
19779     #[cfg(windows)]
19780     {
19781         #[link(name = "windows")]
19782         extern "system" {
19783             fn CertIsRDNAttrsInCertificateName(dwcertencodingtype: u32, dwflags: u32, pcertname: *const CRYPTOAPI_BLOB, prdn: *const CERT_RDN) -> super::super::Foundation::BOOL;
19784         }
19785         ::std::mem::transmute(CertIsRDNAttrsInCertificateName(::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(dwflags), ::std::mem::transmute(pcertname), ::std::mem::transmute(prdn)))
19786     }
19787     #[cfg(not(windows))]
19788     unimplemented!("Unsupported target OS");
19789 }
19790 #[cfg(feature = "Win32_Foundation")]
19791 #[inline]
CertIsStrongHashToSign<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pstrongsignpara: *const CERT_STRONG_SIGN_PARA, pwszcnghashalgid: Param1, psigningcert: *const CERT_CONTEXT) -> super::super::Foundation::BOOL19792 pub unsafe fn CertIsStrongHashToSign<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pstrongsignpara: *const CERT_STRONG_SIGN_PARA, pwszcnghashalgid: Param1, psigningcert: *const CERT_CONTEXT) -> super::super::Foundation::BOOL {
19793     #[cfg(windows)]
19794     {
19795         #[link(name = "windows")]
19796         extern "system" {
19797             fn CertIsStrongHashToSign(pstrongsignpara: *const CERT_STRONG_SIGN_PARA, pwszcnghashalgid: super::super::Foundation::PWSTR, psigningcert: *const CERT_CONTEXT) -> super::super::Foundation::BOOL;
19798         }
19799         ::std::mem::transmute(CertIsStrongHashToSign(::std::mem::transmute(pstrongsignpara), pwszcnghashalgid.into_param().abi(), ::std::mem::transmute(psigningcert)))
19800     }
19801     #[cfg(not(windows))]
19802     unimplemented!("Unsupported target OS");
19803 }
19804 #[cfg(feature = "Win32_Foundation")]
19805 #[inline]
CertIsValidCRLForCertificate(pcert: *const CERT_CONTEXT, pcrl: *const CRL_CONTEXT, dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL19806 pub unsafe fn CertIsValidCRLForCertificate(pcert: *const CERT_CONTEXT, pcrl: *const CRL_CONTEXT, dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
19807     #[cfg(windows)]
19808     {
19809         #[link(name = "windows")]
19810         extern "system" {
19811             fn CertIsValidCRLForCertificate(pcert: *const CERT_CONTEXT, pcrl: *const CRL_CONTEXT, dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
19812         }
19813         ::std::mem::transmute(CertIsValidCRLForCertificate(::std::mem::transmute(pcert), ::std::mem::transmute(pcrl), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvreserved)))
19814     }
19815     #[cfg(not(windows))]
19816     unimplemented!("Unsupported target OS");
19817 }
19818 #[cfg(feature = "Win32_Foundation")]
19819 #[inline]
CertIsWeakHash<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwhashusetype: u32, pwszcnghashalgid: Param1, dwchainflags: u32, psignerchaincontext: *const CERT_CHAIN_CONTEXT, ptimestamp: *const super::super::Foundation::FILETIME, pwszfilename: Param5) -> super::super::Foundation::BOOL19820 pub unsafe fn CertIsWeakHash<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwhashusetype: u32, pwszcnghashalgid: Param1, dwchainflags: u32, psignerchaincontext: *const CERT_CHAIN_CONTEXT, ptimestamp: *const super::super::Foundation::FILETIME, pwszfilename: Param5) -> super::super::Foundation::BOOL {
19821     #[cfg(windows)]
19822     {
19823         #[link(name = "windows")]
19824         extern "system" {
19825             fn CertIsWeakHash(dwhashusetype: u32, pwszcnghashalgid: super::super::Foundation::PWSTR, dwchainflags: u32, psignerchaincontext: *const CERT_CHAIN_CONTEXT, ptimestamp: *const super::super::Foundation::FILETIME, pwszfilename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
19826         }
19827         ::std::mem::transmute(CertIsWeakHash(::std::mem::transmute(dwhashusetype), pwszcnghashalgid.into_param().abi(), ::std::mem::transmute(dwchainflags), ::std::mem::transmute(psignerchaincontext), ::std::mem::transmute(ptimestamp), pwszfilename.into_param().abi()))
19828     }
19829     #[cfg(not(windows))]
19830     unimplemented!("Unsupported target OS");
19831 }
19832 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
19833 #[repr(transparent)]
19834 pub struct CertKeyType(pub u32);
19835 pub const KeyTypeOther: CertKeyType = CertKeyType(0u32);
19836 pub const KeyTypeVirtualSmartCard: CertKeyType = CertKeyType(1u32);
19837 pub const KeyTypePhysicalSmartCard: CertKeyType = CertKeyType(2u32);
19838 pub const KeyTypePassport: CertKeyType = CertKeyType(3u32);
19839 pub const KeyTypePassportRemote: CertKeyType = CertKeyType(4u32);
19840 pub const KeyTypePassportSmartCard: CertKeyType = CertKeyType(5u32);
19841 pub const KeyTypeHardware: CertKeyType = CertKeyType(6u32);
19842 pub const KeyTypeSoftware: CertKeyType = CertKeyType(7u32);
19843 pub const KeyTypeSelfSigned: CertKeyType = CertKeyType(8u32);
19844 impl ::std::convert::From<u32> for CertKeyType {
from(value: u32) -> Self19845     fn from(value: u32) -> Self {
19846         Self(value)
19847     }
19848 }
19849 unsafe impl ::windows::runtime::Abi for CertKeyType {
19850     type Abi = Self;
19851     type DefaultType = Self;
19852 }
19853 impl ::std::ops::BitOr for CertKeyType {
19854     type Output = Self;
bitor(self, rhs: Self) -> Self19855     fn bitor(self, rhs: Self) -> Self {
19856         Self(self.0 | rhs.0)
19857     }
19858 }
19859 impl ::std::ops::BitAnd for CertKeyType {
19860     type Output = Self;
bitand(self, rhs: Self) -> Self19861     fn bitand(self, rhs: Self) -> Self {
19862         Self(self.0 & rhs.0)
19863     }
19864 }
19865 impl ::std::ops::BitOrAssign for CertKeyType {
bitor_assign(&mut self, rhs: Self)19866     fn bitor_assign(&mut self, rhs: Self) {
19867         self.0.bitor_assign(rhs.0)
19868     }
19869 }
19870 impl ::std::ops::BitAndAssign for CertKeyType {
bitand_assign(&mut self, rhs: Self)19871     fn bitand_assign(&mut self, rhs: Self) {
19872         self.0.bitand_assign(rhs.0)
19873     }
19874 }
19875 impl ::std::ops::Not for CertKeyType {
19876     type Output = Self;
not(self) -> Self19877     fn not(self) -> Self {
19878         Self(self.0.not())
19879     }
19880 }
19881 #[cfg(feature = "Win32_Foundation")]
19882 #[inline]
CertNameToStrA(dwcertencodingtype: u32, pname: *const CRYPTOAPI_BLOB, dwstrtype: CERT_STRING_TYPE, psz: super::super::Foundation::PSTR, csz: u32) -> u3219883 pub unsafe fn CertNameToStrA(dwcertencodingtype: u32, pname: *const CRYPTOAPI_BLOB, dwstrtype: CERT_STRING_TYPE, psz: super::super::Foundation::PSTR, csz: u32) -> u32 {
19884     #[cfg(windows)]
19885     {
19886         #[link(name = "windows")]
19887         extern "system" {
19888             fn CertNameToStrA(dwcertencodingtype: u32, pname: *const CRYPTOAPI_BLOB, dwstrtype: CERT_STRING_TYPE, psz: super::super::Foundation::PSTR, csz: u32) -> u32;
19889         }
19890         ::std::mem::transmute(CertNameToStrA(::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(pname), ::std::mem::transmute(dwstrtype), ::std::mem::transmute(psz), ::std::mem::transmute(csz)))
19891     }
19892     #[cfg(not(windows))]
19893     unimplemented!("Unsupported target OS");
19894 }
19895 #[cfg(feature = "Win32_Foundation")]
19896 #[inline]
CertNameToStrW(dwcertencodingtype: u32, pname: *const CRYPTOAPI_BLOB, dwstrtype: CERT_STRING_TYPE, psz: super::super::Foundation::PWSTR, csz: u32) -> u3219897 pub unsafe fn CertNameToStrW(dwcertencodingtype: u32, pname: *const CRYPTOAPI_BLOB, dwstrtype: CERT_STRING_TYPE, psz: super::super::Foundation::PWSTR, csz: u32) -> u32 {
19898     #[cfg(windows)]
19899     {
19900         #[link(name = "windows")]
19901         extern "system" {
19902             fn CertNameToStrW(dwcertencodingtype: u32, pname: *const CRYPTOAPI_BLOB, dwstrtype: CERT_STRING_TYPE, psz: super::super::Foundation::PWSTR, csz: u32) -> u32;
19903         }
19904         ::std::mem::transmute(CertNameToStrW(::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(pname), ::std::mem::transmute(dwstrtype), ::std::mem::transmute(psz), ::std::mem::transmute(csz)))
19905     }
19906     #[cfg(not(windows))]
19907     unimplemented!("Unsupported target OS");
19908 }
19909 #[cfg(feature = "Win32_Foundation")]
19910 #[inline]
CertOIDToAlgId<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszobjid: Param0) -> u3219911 pub unsafe fn CertOIDToAlgId<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszobjid: Param0) -> u32 {
19912     #[cfg(windows)]
19913     {
19914         #[link(name = "windows")]
19915         extern "system" {
19916             fn CertOIDToAlgId(pszobjid: super::super::Foundation::PSTR) -> u32;
19917         }
19918         ::std::mem::transmute(CertOIDToAlgId(pszobjid.into_param().abi()))
19919     }
19920     #[cfg(not(windows))]
19921     unimplemented!("Unsupported target OS");
19922 }
19923 #[cfg(feature = "Win32_Foundation")]
19924 #[inline]
CertOpenServerOcspResponse(pchaincontext: *const CERT_CHAIN_CONTEXT, dwflags: u32, popenpara: *const CERT_SERVER_OCSP_RESPONSE_OPEN_PARA) -> *mut ::std::ffi::c_void19925 pub unsafe fn CertOpenServerOcspResponse(pchaincontext: *const CERT_CHAIN_CONTEXT, dwflags: u32, popenpara: *const CERT_SERVER_OCSP_RESPONSE_OPEN_PARA) -> *mut ::std::ffi::c_void {
19926     #[cfg(windows)]
19927     {
19928         #[link(name = "windows")]
19929         extern "system" {
19930             fn CertOpenServerOcspResponse(pchaincontext: *const CERT_CHAIN_CONTEXT, dwflags: u32, popenpara: *const ::std::mem::ManuallyDrop<CERT_SERVER_OCSP_RESPONSE_OPEN_PARA>) -> *mut ::std::ffi::c_void;
19931         }
19932         ::std::mem::transmute(CertOpenServerOcspResponse(::std::mem::transmute(pchaincontext), ::std::mem::transmute(dwflags), ::std::mem::transmute(popenpara)))
19933     }
19934     #[cfg(not(windows))]
19935     unimplemented!("Unsupported target OS");
19936 }
19937 #[cfg(feature = "Win32_Foundation")]
19938 #[inline]
CertOpenStore<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(lpszstoreprovider: Param0, dwencodingtype: CERT_QUERY_ENCODING_TYPE, hcryptprov: usize, dwflags: CERT_OPEN_STORE_FLAGS, pvpara: *const ::std::ffi::c_void) -> *mut ::std::ffi::c_void19939 pub unsafe fn CertOpenStore<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(lpszstoreprovider: Param0, dwencodingtype: CERT_QUERY_ENCODING_TYPE, hcryptprov: usize, dwflags: CERT_OPEN_STORE_FLAGS, pvpara: *const ::std::ffi::c_void) -> *mut ::std::ffi::c_void {
19940     #[cfg(windows)]
19941     {
19942         #[link(name = "windows")]
19943         extern "system" {
19944             fn CertOpenStore(lpszstoreprovider: super::super::Foundation::PSTR, dwencodingtype: CERT_QUERY_ENCODING_TYPE, hcryptprov: usize, dwflags: CERT_OPEN_STORE_FLAGS, pvpara: *const ::std::ffi::c_void) -> *mut ::std::ffi::c_void;
19945         }
19946         ::std::mem::transmute(CertOpenStore(lpszstoreprovider.into_param().abi(), ::std::mem::transmute(dwencodingtype), ::std::mem::transmute(hcryptprov), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvpara)))
19947     }
19948     #[cfg(not(windows))]
19949     unimplemented!("Unsupported target OS");
19950 }
19951 #[cfg(feature = "Win32_Foundation")]
19952 #[inline]
CertOpenSystemStoreA<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hprov: usize, szsubsystemprotocol: Param1) -> *mut ::std::ffi::c_void19953 pub unsafe fn CertOpenSystemStoreA<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hprov: usize, szsubsystemprotocol: Param1) -> *mut ::std::ffi::c_void {
19954     #[cfg(windows)]
19955     {
19956         #[link(name = "windows")]
19957         extern "system" {
19958             fn CertOpenSystemStoreA(hprov: usize, szsubsystemprotocol: super::super::Foundation::PSTR) -> *mut ::std::ffi::c_void;
19959         }
19960         ::std::mem::transmute(CertOpenSystemStoreA(::std::mem::transmute(hprov), szsubsystemprotocol.into_param().abi()))
19961     }
19962     #[cfg(not(windows))]
19963     unimplemented!("Unsupported target OS");
19964 }
19965 #[cfg(feature = "Win32_Foundation")]
19966 #[inline]
CertOpenSystemStoreW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hprov: usize, szsubsystemprotocol: Param1) -> *mut ::std::ffi::c_void19967 pub unsafe fn CertOpenSystemStoreW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hprov: usize, szsubsystemprotocol: Param1) -> *mut ::std::ffi::c_void {
19968     #[cfg(windows)]
19969     {
19970         #[link(name = "windows")]
19971         extern "system" {
19972             fn CertOpenSystemStoreW(hprov: usize, szsubsystemprotocol: super::super::Foundation::PWSTR) -> *mut ::std::ffi::c_void;
19973         }
19974         ::std::mem::transmute(CertOpenSystemStoreW(::std::mem::transmute(hprov), szsubsystemprotocol.into_param().abi()))
19975     }
19976     #[cfg(not(windows))]
19977     unimplemented!("Unsupported target OS");
19978 }
19979 #[cfg(feature = "Win32_Foundation")]
19980 #[inline]
CertRDNValueToStrA(dwvaluetype: u32, pvalue: *const CRYPTOAPI_BLOB, psz: super::super::Foundation::PSTR, csz: u32) -> u3219981 pub unsafe fn CertRDNValueToStrA(dwvaluetype: u32, pvalue: *const CRYPTOAPI_BLOB, psz: super::super::Foundation::PSTR, csz: u32) -> u32 {
19982     #[cfg(windows)]
19983     {
19984         #[link(name = "windows")]
19985         extern "system" {
19986             fn CertRDNValueToStrA(dwvaluetype: u32, pvalue: *const CRYPTOAPI_BLOB, psz: super::super::Foundation::PSTR, csz: u32) -> u32;
19987         }
19988         ::std::mem::transmute(CertRDNValueToStrA(::std::mem::transmute(dwvaluetype), ::std::mem::transmute(pvalue), ::std::mem::transmute(psz), ::std::mem::transmute(csz)))
19989     }
19990     #[cfg(not(windows))]
19991     unimplemented!("Unsupported target OS");
19992 }
19993 #[cfg(feature = "Win32_Foundation")]
19994 #[inline]
CertRDNValueToStrW(dwvaluetype: u32, pvalue: *const CRYPTOAPI_BLOB, psz: super::super::Foundation::PWSTR, csz: u32) -> u3219995 pub unsafe fn CertRDNValueToStrW(dwvaluetype: u32, pvalue: *const CRYPTOAPI_BLOB, psz: super::super::Foundation::PWSTR, csz: u32) -> u32 {
19996     #[cfg(windows)]
19997     {
19998         #[link(name = "windows")]
19999         extern "system" {
20000             fn CertRDNValueToStrW(dwvaluetype: u32, pvalue: *const CRYPTOAPI_BLOB, psz: super::super::Foundation::PWSTR, csz: u32) -> u32;
20001         }
20002         ::std::mem::transmute(CertRDNValueToStrW(::std::mem::transmute(dwvaluetype), ::std::mem::transmute(pvalue), ::std::mem::transmute(psz), ::std::mem::transmute(csz)))
20003     }
20004     #[cfg(not(windows))]
20005     unimplemented!("Unsupported target OS");
20006 }
20007 #[cfg(feature = "Win32_Foundation")]
20008 #[inline]
CertRegisterPhysicalStore<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pvsystemstore: *const ::std::ffi::c_void, dwflags: u32, pwszstorename: Param2, pstoreinfo: *const CERT_PHYSICAL_STORE_INFO, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL20009 pub unsafe fn CertRegisterPhysicalStore<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pvsystemstore: *const ::std::ffi::c_void, dwflags: u32, pwszstorename: Param2, pstoreinfo: *const CERT_PHYSICAL_STORE_INFO, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
20010     #[cfg(windows)]
20011     {
20012         #[link(name = "windows")]
20013         extern "system" {
20014             fn CertRegisterPhysicalStore(pvsystemstore: *const ::std::ffi::c_void, dwflags: u32, pwszstorename: super::super::Foundation::PWSTR, pstoreinfo: *const CERT_PHYSICAL_STORE_INFO, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
20015         }
20016         ::std::mem::transmute(CertRegisterPhysicalStore(::std::mem::transmute(pvsystemstore), ::std::mem::transmute(dwflags), pwszstorename.into_param().abi(), ::std::mem::transmute(pstoreinfo), ::std::mem::transmute(pvreserved)))
20017     }
20018     #[cfg(not(windows))]
20019     unimplemented!("Unsupported target OS");
20020 }
20021 #[cfg(feature = "Win32_Foundation")]
20022 #[inline]
CertRegisterSystemStore(pvsystemstore: *const ::std::ffi::c_void, dwflags: u32, pstoreinfo: *const CERT_SYSTEM_STORE_INFO, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL20023 pub unsafe fn CertRegisterSystemStore(pvsystemstore: *const ::std::ffi::c_void, dwflags: u32, pstoreinfo: *const CERT_SYSTEM_STORE_INFO, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
20024     #[cfg(windows)]
20025     {
20026         #[link(name = "windows")]
20027         extern "system" {
20028             fn CertRegisterSystemStore(pvsystemstore: *const ::std::ffi::c_void, dwflags: u32, pstoreinfo: *const CERT_SYSTEM_STORE_INFO, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
20029         }
20030         ::std::mem::transmute(CertRegisterSystemStore(::std::mem::transmute(pvsystemstore), ::std::mem::transmute(dwflags), ::std::mem::transmute(pstoreinfo), ::std::mem::transmute(pvreserved)))
20031     }
20032     #[cfg(not(windows))]
20033     unimplemented!("Unsupported target OS");
20034 }
20035 #[cfg(feature = "Win32_Foundation")]
20036 #[inline]
CertRemoveEnhancedKeyUsageIdentifier<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pcertcontext: *const CERT_CONTEXT, pszusageidentifier: Param1) -> super::super::Foundation::BOOL20037 pub unsafe fn CertRemoveEnhancedKeyUsageIdentifier<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pcertcontext: *const CERT_CONTEXT, pszusageidentifier: Param1) -> super::super::Foundation::BOOL {
20038     #[cfg(windows)]
20039     {
20040         #[link(name = "windows")]
20041         extern "system" {
20042             fn CertRemoveEnhancedKeyUsageIdentifier(pcertcontext: *const CERT_CONTEXT, pszusageidentifier: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
20043         }
20044         ::std::mem::transmute(CertRemoveEnhancedKeyUsageIdentifier(::std::mem::transmute(pcertcontext), pszusageidentifier.into_param().abi()))
20045     }
20046     #[cfg(not(windows))]
20047     unimplemented!("Unsupported target OS");
20048 }
20049 #[inline]
CertRemoveStoreFromCollection(hcollectionstore: *const ::std::ffi::c_void, hsiblingstore: *const ::std::ffi::c_void)20050 pub unsafe fn CertRemoveStoreFromCollection(hcollectionstore: *const ::std::ffi::c_void, hsiblingstore: *const ::std::ffi::c_void) {
20051     #[cfg(windows)]
20052     {
20053         #[link(name = "windows")]
20054         extern "system" {
20055             fn CertRemoveStoreFromCollection(hcollectionstore: *const ::std::ffi::c_void, hsiblingstore: *const ::std::ffi::c_void);
20056         }
20057         ::std::mem::transmute(CertRemoveStoreFromCollection(::std::mem::transmute(hcollectionstore), ::std::mem::transmute(hsiblingstore)))
20058     }
20059     #[cfg(not(windows))]
20060     unimplemented!("Unsupported target OS");
20061 }
20062 #[cfg(feature = "Win32_Foundation")]
20063 #[inline]
CertResyncCertificateChainEngine<'a, Param0: ::windows::runtime::IntoParam<'a, HCERTCHAINENGINE>>(hchainengine: Param0) -> super::super::Foundation::BOOL20064 pub unsafe fn CertResyncCertificateChainEngine<'a, Param0: ::windows::runtime::IntoParam<'a, HCERTCHAINENGINE>>(hchainengine: Param0) -> super::super::Foundation::BOOL {
20065     #[cfg(windows)]
20066     {
20067         #[link(name = "windows")]
20068         extern "system" {
20069             fn CertResyncCertificateChainEngine(hchainengine: HCERTCHAINENGINE) -> super::super::Foundation::BOOL;
20070         }
20071         ::std::mem::transmute(CertResyncCertificateChainEngine(hchainengine.into_param().abi()))
20072     }
20073     #[cfg(not(windows))]
20074     unimplemented!("Unsupported target OS");
20075 }
20076 #[cfg(feature = "Win32_Foundation")]
20077 #[inline]
CertRetrieveLogoOrBiometricInfo<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pcertcontext: *const CERT_CONTEXT, lpszlogoorbiometrictype: Param1, dwretrievalflags: u32, dwtimeout: u32, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, ppbdata: *mut *mut u8, pcbdata: *mut u32, ppwszmimetype: *mut super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL20078 pub unsafe fn CertRetrieveLogoOrBiometricInfo<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pcertcontext: *const CERT_CONTEXT, lpszlogoorbiometrictype: Param1, dwretrievalflags: u32, dwtimeout: u32, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, ppbdata: *mut *mut u8, pcbdata: *mut u32, ppwszmimetype: *mut super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL {
20079     #[cfg(windows)]
20080     {
20081         #[link(name = "windows")]
20082         extern "system" {
20083             fn CertRetrieveLogoOrBiometricInfo(pcertcontext: *const CERT_CONTEXT, lpszlogoorbiometrictype: super::super::Foundation::PSTR, dwretrievalflags: u32, dwtimeout: u32, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, ppbdata: *mut *mut u8, pcbdata: *mut u32, ppwszmimetype: *mut super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
20084         }
20085         ::std::mem::transmute(CertRetrieveLogoOrBiometricInfo(
20086             ::std::mem::transmute(pcertcontext),
20087             lpszlogoorbiometrictype.into_param().abi(),
20088             ::std::mem::transmute(dwretrievalflags),
20089             ::std::mem::transmute(dwtimeout),
20090             ::std::mem::transmute(dwflags),
20091             ::std::mem::transmute(pvreserved),
20092             ::std::mem::transmute(ppbdata),
20093             ::std::mem::transmute(pcbdata),
20094             ::std::mem::transmute(ppwszmimetype),
20095         ))
20096     }
20097     #[cfg(not(windows))]
20098     unimplemented!("Unsupported target OS");
20099 }
20100 #[cfg(feature = "Win32_Foundation")]
20101 #[inline]
CertSaveStore(hcertstore: *const ::std::ffi::c_void, dwencodingtype: CERT_QUERY_ENCODING_TYPE, dwsaveas: CERT_STORE_SAVE_AS, dwsaveto: CERT_STORE_SAVE_TO, pvsavetopara: *mut ::std::ffi::c_void, dwflags: u32) -> super::super::Foundation::BOOL20102 pub unsafe fn CertSaveStore(hcertstore: *const ::std::ffi::c_void, dwencodingtype: CERT_QUERY_ENCODING_TYPE, dwsaveas: CERT_STORE_SAVE_AS, dwsaveto: CERT_STORE_SAVE_TO, pvsavetopara: *mut ::std::ffi::c_void, dwflags: u32) -> super::super::Foundation::BOOL {
20103     #[cfg(windows)]
20104     {
20105         #[link(name = "windows")]
20106         extern "system" {
20107             fn CertSaveStore(hcertstore: *const ::std::ffi::c_void, dwencodingtype: CERT_QUERY_ENCODING_TYPE, dwsaveas: CERT_STORE_SAVE_AS, dwsaveto: CERT_STORE_SAVE_TO, pvsavetopara: *mut ::std::ffi::c_void, dwflags: u32) -> super::super::Foundation::BOOL;
20108         }
20109         ::std::mem::transmute(CertSaveStore(::std::mem::transmute(hcertstore), ::std::mem::transmute(dwencodingtype), ::std::mem::transmute(dwsaveas), ::std::mem::transmute(dwsaveto), ::std::mem::transmute(pvsavetopara), ::std::mem::transmute(dwflags)))
20110     }
20111     #[cfg(not(windows))]
20112     unimplemented!("Unsupported target OS");
20113 }
20114 #[cfg(feature = "Win32_Foundation")]
20115 #[inline]
CertSelectCertificateChains(pselectioncontext: *const ::windows::runtime::GUID, dwflags: u32, pchainparameters: *const CERT_SELECT_CHAIN_PARA, ccriteria: u32, rgpcriteria: *const CERT_SELECT_CRITERIA, hstore: *const ::std::ffi::c_void, pcselection: *mut u32, pprgpselection: *mut *mut *mut CERT_CHAIN_CONTEXT) -> super::super::Foundation::BOOL20116 pub unsafe fn CertSelectCertificateChains(pselectioncontext: *const ::windows::runtime::GUID, dwflags: u32, pchainparameters: *const CERT_SELECT_CHAIN_PARA, ccriteria: u32, rgpcriteria: *const CERT_SELECT_CRITERIA, hstore: *const ::std::ffi::c_void, pcselection: *mut u32, pprgpselection: *mut *mut *mut CERT_CHAIN_CONTEXT) -> super::super::Foundation::BOOL {
20117     #[cfg(windows)]
20118     {
20119         #[link(name = "windows")]
20120         extern "system" {
20121             fn CertSelectCertificateChains(pselectioncontext: *const ::windows::runtime::GUID, dwflags: u32, pchainparameters: *const CERT_SELECT_CHAIN_PARA, ccriteria: u32, rgpcriteria: *const CERT_SELECT_CRITERIA, hstore: *const ::std::ffi::c_void, pcselection: *mut u32, pprgpselection: *mut *mut *mut CERT_CHAIN_CONTEXT) -> super::super::Foundation::BOOL;
20122         }
20123         ::std::mem::transmute(CertSelectCertificateChains(
20124             ::std::mem::transmute(pselectioncontext),
20125             ::std::mem::transmute(dwflags),
20126             ::std::mem::transmute(pchainparameters),
20127             ::std::mem::transmute(ccriteria),
20128             ::std::mem::transmute(rgpcriteria),
20129             ::std::mem::transmute(hstore),
20130             ::std::mem::transmute(pcselection),
20131             ::std::mem::transmute(pprgpselection),
20132         ))
20133     }
20134     #[cfg(not(windows))]
20135     unimplemented!("Unsupported target OS");
20136 }
20137 #[cfg(feature = "Win32_Foundation")]
20138 #[inline]
CertSelectionGetSerializedBlob(pcsi: *const CERT_SELECTUI_INPUT, ppoutbuffer: *mut *mut ::std::ffi::c_void, puloutbuffersize: *mut u32) -> ::windows::runtime::Result<()>20139 pub unsafe fn CertSelectionGetSerializedBlob(pcsi: *const CERT_SELECTUI_INPUT, ppoutbuffer: *mut *mut ::std::ffi::c_void, puloutbuffersize: *mut u32) -> ::windows::runtime::Result<()> {
20140     #[cfg(windows)]
20141     {
20142         #[link(name = "windows")]
20143         extern "system" {
20144             fn CertSelectionGetSerializedBlob(pcsi: *const CERT_SELECTUI_INPUT, ppoutbuffer: *mut *mut ::std::ffi::c_void, puloutbuffersize: *mut u32) -> ::windows::runtime::HRESULT;
20145         }
20146         CertSelectionGetSerializedBlob(::std::mem::transmute(pcsi), ::std::mem::transmute(ppoutbuffer), ::std::mem::transmute(puloutbuffersize)).ok()
20147     }
20148     #[cfg(not(windows))]
20149     unimplemented!("Unsupported target OS");
20150 }
20151 #[cfg(feature = "Win32_Foundation")]
20152 #[inline]
CertSerializeCRLStoreElement(pcrlcontext: *const CRL_CONTEXT, dwflags: u32, pbelement: *mut u8, pcbelement: *mut u32) -> super::super::Foundation::BOOL20153 pub unsafe fn CertSerializeCRLStoreElement(pcrlcontext: *const CRL_CONTEXT, dwflags: u32, pbelement: *mut u8, pcbelement: *mut u32) -> super::super::Foundation::BOOL {
20154     #[cfg(windows)]
20155     {
20156         #[link(name = "windows")]
20157         extern "system" {
20158             fn CertSerializeCRLStoreElement(pcrlcontext: *const CRL_CONTEXT, dwflags: u32, pbelement: *mut u8, pcbelement: *mut u32) -> super::super::Foundation::BOOL;
20159         }
20160         ::std::mem::transmute(CertSerializeCRLStoreElement(::std::mem::transmute(pcrlcontext), ::std::mem::transmute(dwflags), ::std::mem::transmute(pbelement), ::std::mem::transmute(pcbelement)))
20161     }
20162     #[cfg(not(windows))]
20163     unimplemented!("Unsupported target OS");
20164 }
20165 #[cfg(feature = "Win32_Foundation")]
20166 #[inline]
CertSerializeCTLStoreElement(pctlcontext: *const CTL_CONTEXT, dwflags: u32, pbelement: *mut u8, pcbelement: *mut u32) -> super::super::Foundation::BOOL20167 pub unsafe fn CertSerializeCTLStoreElement(pctlcontext: *const CTL_CONTEXT, dwflags: u32, pbelement: *mut u8, pcbelement: *mut u32) -> super::super::Foundation::BOOL {
20168     #[cfg(windows)]
20169     {
20170         #[link(name = "windows")]
20171         extern "system" {
20172             fn CertSerializeCTLStoreElement(pctlcontext: *const CTL_CONTEXT, dwflags: u32, pbelement: *mut u8, pcbelement: *mut u32) -> super::super::Foundation::BOOL;
20173         }
20174         ::std::mem::transmute(CertSerializeCTLStoreElement(::std::mem::transmute(pctlcontext), ::std::mem::transmute(dwflags), ::std::mem::transmute(pbelement), ::std::mem::transmute(pcbelement)))
20175     }
20176     #[cfg(not(windows))]
20177     unimplemented!("Unsupported target OS");
20178 }
20179 #[cfg(feature = "Win32_Foundation")]
20180 #[inline]
CertSerializeCertificateStoreElement(pcertcontext: *const CERT_CONTEXT, dwflags: u32, pbelement: *mut u8, pcbelement: *mut u32) -> super::super::Foundation::BOOL20181 pub unsafe fn CertSerializeCertificateStoreElement(pcertcontext: *const CERT_CONTEXT, dwflags: u32, pbelement: *mut u8, pcbelement: *mut u32) -> super::super::Foundation::BOOL {
20182     #[cfg(windows)]
20183     {
20184         #[link(name = "windows")]
20185         extern "system" {
20186             fn CertSerializeCertificateStoreElement(pcertcontext: *const CERT_CONTEXT, dwflags: u32, pbelement: *mut u8, pcbelement: *mut u32) -> super::super::Foundation::BOOL;
20187         }
20188         ::std::mem::transmute(CertSerializeCertificateStoreElement(::std::mem::transmute(pcertcontext), ::std::mem::transmute(dwflags), ::std::mem::transmute(pbelement), ::std::mem::transmute(pcbelement)))
20189     }
20190     #[cfg(not(windows))]
20191     unimplemented!("Unsupported target OS");
20192 }
20193 #[cfg(feature = "Win32_Foundation")]
20194 #[inline]
CertSetCRLContextProperty(pcrlcontext: *const CRL_CONTEXT, dwpropid: u32, dwflags: u32, pvdata: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL20195 pub unsafe fn CertSetCRLContextProperty(pcrlcontext: *const CRL_CONTEXT, dwpropid: u32, dwflags: u32, pvdata: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL {
20196     #[cfg(windows)]
20197     {
20198         #[link(name = "windows")]
20199         extern "system" {
20200             fn CertSetCRLContextProperty(pcrlcontext: *const CRL_CONTEXT, dwpropid: u32, dwflags: u32, pvdata: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
20201         }
20202         ::std::mem::transmute(CertSetCRLContextProperty(::std::mem::transmute(pcrlcontext), ::std::mem::transmute(dwpropid), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvdata)))
20203     }
20204     #[cfg(not(windows))]
20205     unimplemented!("Unsupported target OS");
20206 }
20207 #[cfg(feature = "Win32_Foundation")]
20208 #[inline]
CertSetCTLContextProperty(pctlcontext: *const CTL_CONTEXT, dwpropid: u32, dwflags: u32, pvdata: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL20209 pub unsafe fn CertSetCTLContextProperty(pctlcontext: *const CTL_CONTEXT, dwpropid: u32, dwflags: u32, pvdata: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL {
20210     #[cfg(windows)]
20211     {
20212         #[link(name = "windows")]
20213         extern "system" {
20214             fn CertSetCTLContextProperty(pctlcontext: *const CTL_CONTEXT, dwpropid: u32, dwflags: u32, pvdata: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
20215         }
20216         ::std::mem::transmute(CertSetCTLContextProperty(::std::mem::transmute(pctlcontext), ::std::mem::transmute(dwpropid), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvdata)))
20217     }
20218     #[cfg(not(windows))]
20219     unimplemented!("Unsupported target OS");
20220 }
20221 #[cfg(feature = "Win32_Foundation")]
20222 #[inline]
CertSetCertificateContextPropertiesFromCTLEntry(pcertcontext: *const CERT_CONTEXT, pctlentry: *const CTL_ENTRY, dwflags: u32) -> super::super::Foundation::BOOL20223 pub unsafe fn CertSetCertificateContextPropertiesFromCTLEntry(pcertcontext: *const CERT_CONTEXT, pctlentry: *const CTL_ENTRY, dwflags: u32) -> super::super::Foundation::BOOL {
20224     #[cfg(windows)]
20225     {
20226         #[link(name = "windows")]
20227         extern "system" {
20228             fn CertSetCertificateContextPropertiesFromCTLEntry(pcertcontext: *const CERT_CONTEXT, pctlentry: *const CTL_ENTRY, dwflags: u32) -> super::super::Foundation::BOOL;
20229         }
20230         ::std::mem::transmute(CertSetCertificateContextPropertiesFromCTLEntry(::std::mem::transmute(pcertcontext), ::std::mem::transmute(pctlentry), ::std::mem::transmute(dwflags)))
20231     }
20232     #[cfg(not(windows))]
20233     unimplemented!("Unsupported target OS");
20234 }
20235 #[cfg(feature = "Win32_Foundation")]
20236 #[inline]
CertSetCertificateContextProperty(pcertcontext: *const CERT_CONTEXT, dwpropid: u32, dwflags: u32, pvdata: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL20237 pub unsafe fn CertSetCertificateContextProperty(pcertcontext: *const CERT_CONTEXT, dwpropid: u32, dwflags: u32, pvdata: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL {
20238     #[cfg(windows)]
20239     {
20240         #[link(name = "windows")]
20241         extern "system" {
20242             fn CertSetCertificateContextProperty(pcertcontext: *const CERT_CONTEXT, dwpropid: u32, dwflags: u32, pvdata: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
20243         }
20244         ::std::mem::transmute(CertSetCertificateContextProperty(::std::mem::transmute(pcertcontext), ::std::mem::transmute(dwpropid), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvdata)))
20245     }
20246     #[cfg(not(windows))]
20247     unimplemented!("Unsupported target OS");
20248 }
20249 #[cfg(feature = "Win32_Foundation")]
20250 #[inline]
CertSetEnhancedKeyUsage(pcertcontext: *const CERT_CONTEXT, pusage: *const CTL_USAGE) -> super::super::Foundation::BOOL20251 pub unsafe fn CertSetEnhancedKeyUsage(pcertcontext: *const CERT_CONTEXT, pusage: *const CTL_USAGE) -> super::super::Foundation::BOOL {
20252     #[cfg(windows)]
20253     {
20254         #[link(name = "windows")]
20255         extern "system" {
20256             fn CertSetEnhancedKeyUsage(pcertcontext: *const CERT_CONTEXT, pusage: *const CTL_USAGE) -> super::super::Foundation::BOOL;
20257         }
20258         ::std::mem::transmute(CertSetEnhancedKeyUsage(::std::mem::transmute(pcertcontext), ::std::mem::transmute(pusage)))
20259     }
20260     #[cfg(not(windows))]
20261     unimplemented!("Unsupported target OS");
20262 }
20263 #[cfg(feature = "Win32_Foundation")]
20264 #[inline]
CertSetStoreProperty(hcertstore: *const ::std::ffi::c_void, dwpropid: u32, dwflags: u32, pvdata: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL20265 pub unsafe fn CertSetStoreProperty(hcertstore: *const ::std::ffi::c_void, dwpropid: u32, dwflags: u32, pvdata: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL {
20266     #[cfg(windows)]
20267     {
20268         #[link(name = "windows")]
20269         extern "system" {
20270             fn CertSetStoreProperty(hcertstore: *const ::std::ffi::c_void, dwpropid: u32, dwflags: u32, pvdata: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
20271         }
20272         ::std::mem::transmute(CertSetStoreProperty(::std::mem::transmute(hcertstore), ::std::mem::transmute(dwpropid), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvdata)))
20273     }
20274     #[cfg(not(windows))]
20275     unimplemented!("Unsupported target OS");
20276 }
20277 #[cfg(feature = "Win32_Foundation")]
20278 #[inline]
CertStrToNameA<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwcertencodingtype: u32, pszx500: Param1, dwstrtype: CERT_STRING_TYPE, pvreserved: *mut ::std::ffi::c_void, pbencoded: *mut u8, pcbencoded: *mut u32, ppszerror: *mut super::super::Foundation::PSTR) -> super::super::Foundation::BOOL20279 pub unsafe fn CertStrToNameA<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwcertencodingtype: u32, pszx500: Param1, dwstrtype: CERT_STRING_TYPE, pvreserved: *mut ::std::ffi::c_void, pbencoded: *mut u8, pcbencoded: *mut u32, ppszerror: *mut super::super::Foundation::PSTR) -> super::super::Foundation::BOOL {
20280     #[cfg(windows)]
20281     {
20282         #[link(name = "windows")]
20283         extern "system" {
20284             fn CertStrToNameA(dwcertencodingtype: u32, pszx500: super::super::Foundation::PSTR, dwstrtype: CERT_STRING_TYPE, pvreserved: *mut ::std::ffi::c_void, pbencoded: *mut u8, pcbencoded: *mut u32, ppszerror: *mut super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
20285         }
20286         ::std::mem::transmute(CertStrToNameA(::std::mem::transmute(dwcertencodingtype), pszx500.into_param().abi(), ::std::mem::transmute(dwstrtype), ::std::mem::transmute(pvreserved), ::std::mem::transmute(pbencoded), ::std::mem::transmute(pcbencoded), ::std::mem::transmute(ppszerror)))
20287     }
20288     #[cfg(not(windows))]
20289     unimplemented!("Unsupported target OS");
20290 }
20291 #[cfg(feature = "Win32_Foundation")]
20292 #[inline]
CertStrToNameW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwcertencodingtype: u32, pszx500: Param1, dwstrtype: CERT_STRING_TYPE, pvreserved: *mut ::std::ffi::c_void, pbencoded: *mut u8, pcbencoded: *mut u32, ppszerror: *mut super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL20293 pub unsafe fn CertStrToNameW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwcertencodingtype: u32, pszx500: Param1, dwstrtype: CERT_STRING_TYPE, pvreserved: *mut ::std::ffi::c_void, pbencoded: *mut u8, pcbencoded: *mut u32, ppszerror: *mut super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL {
20294     #[cfg(windows)]
20295     {
20296         #[link(name = "windows")]
20297         extern "system" {
20298             fn CertStrToNameW(dwcertencodingtype: u32, pszx500: super::super::Foundation::PWSTR, dwstrtype: CERT_STRING_TYPE, pvreserved: *mut ::std::ffi::c_void, pbencoded: *mut u8, pcbencoded: *mut u32, ppszerror: *mut super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
20299         }
20300         ::std::mem::transmute(CertStrToNameW(::std::mem::transmute(dwcertencodingtype), pszx500.into_param().abi(), ::std::mem::transmute(dwstrtype), ::std::mem::transmute(pvreserved), ::std::mem::transmute(pbencoded), ::std::mem::transmute(pcbencoded), ::std::mem::transmute(ppszerror)))
20301     }
20302     #[cfg(not(windows))]
20303     unimplemented!("Unsupported target OS");
20304 }
20305 #[cfg(feature = "Win32_Foundation")]
20306 #[inline]
CertUnregisterPhysicalStore<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pvsystemstore: *const ::std::ffi::c_void, dwflags: u32, pwszstorename: Param2) -> super::super::Foundation::BOOL20307 pub unsafe fn CertUnregisterPhysicalStore<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pvsystemstore: *const ::std::ffi::c_void, dwflags: u32, pwszstorename: Param2) -> super::super::Foundation::BOOL {
20308     #[cfg(windows)]
20309     {
20310         #[link(name = "windows")]
20311         extern "system" {
20312             fn CertUnregisterPhysicalStore(pvsystemstore: *const ::std::ffi::c_void, dwflags: u32, pwszstorename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
20313         }
20314         ::std::mem::transmute(CertUnregisterPhysicalStore(::std::mem::transmute(pvsystemstore), ::std::mem::transmute(dwflags), pwszstorename.into_param().abi()))
20315     }
20316     #[cfg(not(windows))]
20317     unimplemented!("Unsupported target OS");
20318 }
20319 #[cfg(feature = "Win32_Foundation")]
20320 #[inline]
CertUnregisterSystemStore(pvsystemstore: *const ::std::ffi::c_void, dwflags: u32) -> super::super::Foundation::BOOL20321 pub unsafe fn CertUnregisterSystemStore(pvsystemstore: *const ::std::ffi::c_void, dwflags: u32) -> super::super::Foundation::BOOL {
20322     #[cfg(windows)]
20323     {
20324         #[link(name = "windows")]
20325         extern "system" {
20326             fn CertUnregisterSystemStore(pvsystemstore: *const ::std::ffi::c_void, dwflags: u32) -> super::super::Foundation::BOOL;
20327         }
20328         ::std::mem::transmute(CertUnregisterSystemStore(::std::mem::transmute(pvsystemstore), ::std::mem::transmute(dwflags)))
20329     }
20330     #[cfg(not(windows))]
20331     unimplemented!("Unsupported target OS");
20332 }
20333 #[cfg(feature = "Win32_Foundation")]
20334 #[inline]
CertVerifyCRLRevocation(dwcertencodingtype: u32, pcertid: *const CERT_INFO, ccrlinfo: u32, rgpcrlinfo: *const *const CRL_INFO) -> super::super::Foundation::BOOL20335 pub unsafe fn CertVerifyCRLRevocation(dwcertencodingtype: u32, pcertid: *const CERT_INFO, ccrlinfo: u32, rgpcrlinfo: *const *const CRL_INFO) -> super::super::Foundation::BOOL {
20336     #[cfg(windows)]
20337     {
20338         #[link(name = "windows")]
20339         extern "system" {
20340             fn CertVerifyCRLRevocation(dwcertencodingtype: u32, pcertid: *const CERT_INFO, ccrlinfo: u32, rgpcrlinfo: *const *const CRL_INFO) -> super::super::Foundation::BOOL;
20341         }
20342         ::std::mem::transmute(CertVerifyCRLRevocation(::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(pcertid), ::std::mem::transmute(ccrlinfo), ::std::mem::transmute(rgpcrlinfo)))
20343     }
20344     #[cfg(not(windows))]
20345     unimplemented!("Unsupported target OS");
20346 }
20347 #[cfg(feature = "Win32_Foundation")]
20348 #[inline]
CertVerifyCRLTimeValidity(ptimetoverify: *const super::super::Foundation::FILETIME, pcrlinfo: *const CRL_INFO) -> i3220349 pub unsafe fn CertVerifyCRLTimeValidity(ptimetoverify: *const super::super::Foundation::FILETIME, pcrlinfo: *const CRL_INFO) -> i32 {
20350     #[cfg(windows)]
20351     {
20352         #[link(name = "windows")]
20353         extern "system" {
20354             fn CertVerifyCRLTimeValidity(ptimetoverify: *const super::super::Foundation::FILETIME, pcrlinfo: *const CRL_INFO) -> i32;
20355         }
20356         ::std::mem::transmute(CertVerifyCRLTimeValidity(::std::mem::transmute(ptimetoverify), ::std::mem::transmute(pcrlinfo)))
20357     }
20358     #[cfg(not(windows))]
20359     unimplemented!("Unsupported target OS");
20360 }
20361 #[cfg(feature = "Win32_Foundation")]
20362 #[inline]
CertVerifyCTLUsage(dwencodingtype: u32, dwsubjecttype: u32, pvsubject: *const ::std::ffi::c_void, psubjectusage: *const CTL_USAGE, dwflags: u32, pverifyusagepara: *const CTL_VERIFY_USAGE_PARA, pverifyusagestatus: *mut CTL_VERIFY_USAGE_STATUS) -> super::super::Foundation::BOOL20363 pub unsafe fn CertVerifyCTLUsage(dwencodingtype: u32, dwsubjecttype: u32, pvsubject: *const ::std::ffi::c_void, psubjectusage: *const CTL_USAGE, dwflags: u32, pverifyusagepara: *const CTL_VERIFY_USAGE_PARA, pverifyusagestatus: *mut CTL_VERIFY_USAGE_STATUS) -> super::super::Foundation::BOOL {
20364     #[cfg(windows)]
20365     {
20366         #[link(name = "windows")]
20367         extern "system" {
20368             fn CertVerifyCTLUsage(dwencodingtype: u32, dwsubjecttype: u32, pvsubject: *const ::std::ffi::c_void, psubjectusage: *const CTL_USAGE, dwflags: u32, pverifyusagepara: *const CTL_VERIFY_USAGE_PARA, pverifyusagestatus: *mut CTL_VERIFY_USAGE_STATUS) -> super::super::Foundation::BOOL;
20369         }
20370         ::std::mem::transmute(CertVerifyCTLUsage(::std::mem::transmute(dwencodingtype), ::std::mem::transmute(dwsubjecttype), ::std::mem::transmute(pvsubject), ::std::mem::transmute(psubjectusage), ::std::mem::transmute(dwflags), ::std::mem::transmute(pverifyusagepara), ::std::mem::transmute(pverifyusagestatus)))
20371     }
20372     #[cfg(not(windows))]
20373     unimplemented!("Unsupported target OS");
20374 }
20375 #[cfg(feature = "Win32_Foundation")]
20376 #[inline]
CertVerifyCertificateChainPolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszpolicyoid: Param0, pchaincontext: *const CERT_CHAIN_CONTEXT, ppolicypara: *const CERT_CHAIN_POLICY_PARA, ppolicystatus: *mut CERT_CHAIN_POLICY_STATUS) -> super::super::Foundation::BOOL20377 pub unsafe fn CertVerifyCertificateChainPolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszpolicyoid: Param0, pchaincontext: *const CERT_CHAIN_CONTEXT, ppolicypara: *const CERT_CHAIN_POLICY_PARA, ppolicystatus: *mut CERT_CHAIN_POLICY_STATUS) -> super::super::Foundation::BOOL {
20378     #[cfg(windows)]
20379     {
20380         #[link(name = "windows")]
20381         extern "system" {
20382             fn CertVerifyCertificateChainPolicy(pszpolicyoid: super::super::Foundation::PSTR, pchaincontext: *const CERT_CHAIN_CONTEXT, ppolicypara: *const CERT_CHAIN_POLICY_PARA, ppolicystatus: *mut CERT_CHAIN_POLICY_STATUS) -> super::super::Foundation::BOOL;
20383         }
20384         ::std::mem::transmute(CertVerifyCertificateChainPolicy(pszpolicyoid.into_param().abi(), ::std::mem::transmute(pchaincontext), ::std::mem::transmute(ppolicypara), ::std::mem::transmute(ppolicystatus)))
20385     }
20386     #[cfg(not(windows))]
20387     unimplemented!("Unsupported target OS");
20388 }
20389 #[cfg(feature = "Win32_Foundation")]
20390 #[inline]
CertVerifyRevocation(dwencodingtype: u32, dwrevtype: u32, ccontext: u32, rgpvcontext: *const *const ::std::ffi::c_void, dwflags: u32, prevpara: *const CERT_REVOCATION_PARA, prevstatus: *mut CERT_REVOCATION_STATUS) -> super::super::Foundation::BOOL20391 pub unsafe fn CertVerifyRevocation(dwencodingtype: u32, dwrevtype: u32, ccontext: u32, rgpvcontext: *const *const ::std::ffi::c_void, dwflags: u32, prevpara: *const CERT_REVOCATION_PARA, prevstatus: *mut CERT_REVOCATION_STATUS) -> super::super::Foundation::BOOL {
20392     #[cfg(windows)]
20393     {
20394         #[link(name = "windows")]
20395         extern "system" {
20396             fn CertVerifyRevocation(dwencodingtype: u32, dwrevtype: u32, ccontext: u32, rgpvcontext: *const *const ::std::ffi::c_void, dwflags: u32, prevpara: *const CERT_REVOCATION_PARA, prevstatus: *mut CERT_REVOCATION_STATUS) -> super::super::Foundation::BOOL;
20397         }
20398         ::std::mem::transmute(CertVerifyRevocation(::std::mem::transmute(dwencodingtype), ::std::mem::transmute(dwrevtype), ::std::mem::transmute(ccontext), ::std::mem::transmute(rgpvcontext), ::std::mem::transmute(dwflags), ::std::mem::transmute(prevpara), ::std::mem::transmute(prevstatus)))
20399     }
20400     #[cfg(not(windows))]
20401     unimplemented!("Unsupported target OS");
20402 }
20403 #[cfg(feature = "Win32_Foundation")]
20404 #[inline]
CertVerifySubjectCertificateContext(psubject: *const CERT_CONTEXT, pissuer: *const CERT_CONTEXT, pdwflags: *mut u32) -> super::super::Foundation::BOOL20405 pub unsafe fn CertVerifySubjectCertificateContext(psubject: *const CERT_CONTEXT, pissuer: *const CERT_CONTEXT, pdwflags: *mut u32) -> super::super::Foundation::BOOL {
20406     #[cfg(windows)]
20407     {
20408         #[link(name = "windows")]
20409         extern "system" {
20410             fn CertVerifySubjectCertificateContext(psubject: *const CERT_CONTEXT, pissuer: *const CERT_CONTEXT, pdwflags: *mut u32) -> super::super::Foundation::BOOL;
20411         }
20412         ::std::mem::transmute(CertVerifySubjectCertificateContext(::std::mem::transmute(psubject), ::std::mem::transmute(pissuer), ::std::mem::transmute(pdwflags)))
20413     }
20414     #[cfg(not(windows))]
20415     unimplemented!("Unsupported target OS");
20416 }
20417 #[cfg(feature = "Win32_Foundation")]
20418 #[inline]
CertVerifyTimeValidity(ptimetoverify: *const super::super::Foundation::FILETIME, pcertinfo: *const CERT_INFO) -> i3220419 pub unsafe fn CertVerifyTimeValidity(ptimetoverify: *const super::super::Foundation::FILETIME, pcertinfo: *const CERT_INFO) -> i32 {
20420     #[cfg(windows)]
20421     {
20422         #[link(name = "windows")]
20423         extern "system" {
20424             fn CertVerifyTimeValidity(ptimetoverify: *const super::super::Foundation::FILETIME, pcertinfo: *const CERT_INFO) -> i32;
20425         }
20426         ::std::mem::transmute(CertVerifyTimeValidity(::std::mem::transmute(ptimetoverify), ::std::mem::transmute(pcertinfo)))
20427     }
20428     #[cfg(not(windows))]
20429     unimplemented!("Unsupported target OS");
20430 }
20431 #[cfg(feature = "Win32_Foundation")]
20432 #[inline]
CertVerifyValidityNesting(psubjectinfo: *const CERT_INFO, pissuerinfo: *const CERT_INFO) -> super::super::Foundation::BOOL20433 pub unsafe fn CertVerifyValidityNesting(psubjectinfo: *const CERT_INFO, pissuerinfo: *const CERT_INFO) -> super::super::Foundation::BOOL {
20434     #[cfg(windows)]
20435     {
20436         #[link(name = "windows")]
20437         extern "system" {
20438             fn CertVerifyValidityNesting(psubjectinfo: *const CERT_INFO, pissuerinfo: *const CERT_INFO) -> super::super::Foundation::BOOL;
20439         }
20440         ::std::mem::transmute(CertVerifyValidityNesting(::std::mem::transmute(psubjectinfo), ::std::mem::transmute(pissuerinfo)))
20441     }
20442     #[cfg(not(windows))]
20443     unimplemented!("Unsupported target OS");
20444 }
20445 #[inline]
CloseCryptoHandle(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE) -> ::windows::runtime::Result<()>20446 pub unsafe fn CloseCryptoHandle(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE) -> ::windows::runtime::Result<()> {
20447     #[cfg(windows)]
20448     {
20449         #[link(name = "windows")]
20450         extern "system" {
20451             fn CloseCryptoHandle(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE) -> ::windows::runtime::HRESULT;
20452         }
20453         CloseCryptoHandle(::std::mem::transmute(hcrypto)).ok()
20454     }
20455     #[cfg(not(windows))]
20456     unimplemented!("Unsupported target OS");
20457 }
20458 #[cfg(feature = "Win32_Foundation")]
20459 #[inline]
CryptAcquireCertificatePrivateKey(pcert: *const CERT_CONTEXT, dwflags: CRYPT_ACQUIRE_FLAGS, pvparameters: *const ::std::ffi::c_void, phcryptprovorncryptkey: *mut usize, pdwkeyspec: *mut CERT_KEY_SPEC, pfcallerfreeprovorncryptkey: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL20460 pub unsafe fn CryptAcquireCertificatePrivateKey(pcert: *const CERT_CONTEXT, dwflags: CRYPT_ACQUIRE_FLAGS, pvparameters: *const ::std::ffi::c_void, phcryptprovorncryptkey: *mut usize, pdwkeyspec: *mut CERT_KEY_SPEC, pfcallerfreeprovorncryptkey: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL {
20461     #[cfg(windows)]
20462     {
20463         #[link(name = "windows")]
20464         extern "system" {
20465             fn CryptAcquireCertificatePrivateKey(pcert: *const CERT_CONTEXT, dwflags: CRYPT_ACQUIRE_FLAGS, pvparameters: *const ::std::ffi::c_void, phcryptprovorncryptkey: *mut usize, pdwkeyspec: *mut CERT_KEY_SPEC, pfcallerfreeprovorncryptkey: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL;
20466         }
20467         ::std::mem::transmute(CryptAcquireCertificatePrivateKey(::std::mem::transmute(pcert), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvparameters), ::std::mem::transmute(phcryptprovorncryptkey), ::std::mem::transmute(pdwkeyspec), ::std::mem::transmute(pfcallerfreeprovorncryptkey)))
20468     }
20469     #[cfg(not(windows))]
20470     unimplemented!("Unsupported target OS");
20471 }
20472 #[cfg(feature = "Win32_Foundation")]
20473 #[inline]
CryptAcquireContextA<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(phprov: *mut usize, szcontainer: Param1, szprovider: Param2, dwprovtype: u32, dwflags: u32) -> super::super::Foundation::BOOL20474 pub unsafe fn CryptAcquireContextA<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(phprov: *mut usize, szcontainer: Param1, szprovider: Param2, dwprovtype: u32, dwflags: u32) -> super::super::Foundation::BOOL {
20475     #[cfg(windows)]
20476     {
20477         #[link(name = "windows")]
20478         extern "system" {
20479             fn CryptAcquireContextA(phprov: *mut usize, szcontainer: super::super::Foundation::PSTR, szprovider: super::super::Foundation::PSTR, dwprovtype: u32, dwflags: u32) -> super::super::Foundation::BOOL;
20480         }
20481         ::std::mem::transmute(CryptAcquireContextA(::std::mem::transmute(phprov), szcontainer.into_param().abi(), szprovider.into_param().abi(), ::std::mem::transmute(dwprovtype), ::std::mem::transmute(dwflags)))
20482     }
20483     #[cfg(not(windows))]
20484     unimplemented!("Unsupported target OS");
20485 }
20486 #[cfg(feature = "Win32_Foundation")]
20487 #[inline]
CryptAcquireContextW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(phprov: *mut usize, szcontainer: Param1, szprovider: Param2, dwprovtype: u32, dwflags: u32) -> super::super::Foundation::BOOL20488 pub unsafe fn CryptAcquireContextW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(phprov: *mut usize, szcontainer: Param1, szprovider: Param2, dwprovtype: u32, dwflags: u32) -> super::super::Foundation::BOOL {
20489     #[cfg(windows)]
20490     {
20491         #[link(name = "windows")]
20492         extern "system" {
20493             fn CryptAcquireContextW(phprov: *mut usize, szcontainer: super::super::Foundation::PWSTR, szprovider: super::super::Foundation::PWSTR, dwprovtype: u32, dwflags: u32) -> super::super::Foundation::BOOL;
20494         }
20495         ::std::mem::transmute(CryptAcquireContextW(::std::mem::transmute(phprov), szcontainer.into_param().abi(), szprovider.into_param().abi(), ::std::mem::transmute(dwprovtype), ::std::mem::transmute(dwflags)))
20496     }
20497     #[cfg(not(windows))]
20498     unimplemented!("Unsupported target OS");
20499 }
20500 #[cfg(feature = "Win32_Foundation")]
20501 #[inline]
CryptBinaryToStringA(pbbinary: *const u8, cbbinary: u32, dwflags: CRYPT_STRING, pszstring: super::super::Foundation::PSTR, pcchstring: *mut u32) -> super::super::Foundation::BOOL20502 pub unsafe fn CryptBinaryToStringA(pbbinary: *const u8, cbbinary: u32, dwflags: CRYPT_STRING, pszstring: super::super::Foundation::PSTR, pcchstring: *mut u32) -> super::super::Foundation::BOOL {
20503     #[cfg(windows)]
20504     {
20505         #[link(name = "windows")]
20506         extern "system" {
20507             fn CryptBinaryToStringA(pbbinary: *const u8, cbbinary: u32, dwflags: CRYPT_STRING, pszstring: super::super::Foundation::PSTR, pcchstring: *mut u32) -> super::super::Foundation::BOOL;
20508         }
20509         ::std::mem::transmute(CryptBinaryToStringA(::std::mem::transmute(pbbinary), ::std::mem::transmute(cbbinary), ::std::mem::transmute(dwflags), ::std::mem::transmute(pszstring), ::std::mem::transmute(pcchstring)))
20510     }
20511     #[cfg(not(windows))]
20512     unimplemented!("Unsupported target OS");
20513 }
20514 #[cfg(feature = "Win32_Foundation")]
20515 #[inline]
CryptBinaryToStringW(pbbinary: *const u8, cbbinary: u32, dwflags: CRYPT_STRING, pszstring: super::super::Foundation::PWSTR, pcchstring: *mut u32) -> super::super::Foundation::BOOL20516 pub unsafe fn CryptBinaryToStringW(pbbinary: *const u8, cbbinary: u32, dwflags: CRYPT_STRING, pszstring: super::super::Foundation::PWSTR, pcchstring: *mut u32) -> super::super::Foundation::BOOL {
20517     #[cfg(windows)]
20518     {
20519         #[link(name = "windows")]
20520         extern "system" {
20521             fn CryptBinaryToStringW(pbbinary: *const u8, cbbinary: u32, dwflags: CRYPT_STRING, pszstring: super::super::Foundation::PWSTR, pcchstring: *mut u32) -> super::super::Foundation::BOOL;
20522         }
20523         ::std::mem::transmute(CryptBinaryToStringW(::std::mem::transmute(pbbinary), ::std::mem::transmute(cbbinary), ::std::mem::transmute(dwflags), ::std::mem::transmute(pszstring), ::std::mem::transmute(pcchstring)))
20524     }
20525     #[cfg(not(windows))]
20526     unimplemented!("Unsupported target OS");
20527 }
20528 #[cfg(feature = "Win32_Foundation")]
20529 #[inline]
CryptCloseAsyncHandle<'a, Param0: ::windows::runtime::IntoParam<'a, HCRYPTASYNC>>(hasync: Param0) -> super::super::Foundation::BOOL20530 pub unsafe fn CryptCloseAsyncHandle<'a, Param0: ::windows::runtime::IntoParam<'a, HCRYPTASYNC>>(hasync: Param0) -> super::super::Foundation::BOOL {
20531     #[cfg(windows)]
20532     {
20533         #[link(name = "windows")]
20534         extern "system" {
20535             fn CryptCloseAsyncHandle(hasync: HCRYPTASYNC) -> super::super::Foundation::BOOL;
20536         }
20537         ::std::mem::transmute(CryptCloseAsyncHandle(hasync.into_param().abi()))
20538     }
20539     #[cfg(not(windows))]
20540     unimplemented!("Unsupported target OS");
20541 }
20542 #[cfg(feature = "Win32_Foundation")]
20543 #[inline]
CryptContextAddRef(hprov: usize, pdwreserved: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL20544 pub unsafe fn CryptContextAddRef(hprov: usize, pdwreserved: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL {
20545     #[cfg(windows)]
20546     {
20547         #[link(name = "windows")]
20548         extern "system" {
20549             fn CryptContextAddRef(hprov: usize, pdwreserved: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL;
20550         }
20551         ::std::mem::transmute(CryptContextAddRef(::std::mem::transmute(hprov), ::std::mem::transmute(pdwreserved), ::std::mem::transmute(dwflags)))
20552     }
20553     #[cfg(not(windows))]
20554     unimplemented!("Unsupported target OS");
20555 }
20556 #[cfg(feature = "Win32_Foundation")]
20557 #[inline]
CryptCreateAsyncHandle(dwflags: u32, phasync: *mut HCRYPTASYNC) -> super::super::Foundation::BOOL20558 pub unsafe fn CryptCreateAsyncHandle(dwflags: u32, phasync: *mut HCRYPTASYNC) -> super::super::Foundation::BOOL {
20559     #[cfg(windows)]
20560     {
20561         #[link(name = "windows")]
20562         extern "system" {
20563             fn CryptCreateAsyncHandle(dwflags: u32, phasync: *mut HCRYPTASYNC) -> super::super::Foundation::BOOL;
20564         }
20565         ::std::mem::transmute(CryptCreateAsyncHandle(::std::mem::transmute(dwflags), ::std::mem::transmute(phasync)))
20566     }
20567     #[cfg(not(windows))]
20568     unimplemented!("Unsupported target OS");
20569 }
20570 #[cfg(feature = "Win32_Foundation")]
20571 #[inline]
CryptCreateHash(hprov: usize, algid: u32, hkey: usize, dwflags: u32, phhash: *mut usize) -> super::super::Foundation::BOOL20572 pub unsafe fn CryptCreateHash(hprov: usize, algid: u32, hkey: usize, dwflags: u32, phhash: *mut usize) -> super::super::Foundation::BOOL {
20573     #[cfg(windows)]
20574     {
20575         #[link(name = "windows")]
20576         extern "system" {
20577             fn CryptCreateHash(hprov: usize, algid: u32, hkey: usize, dwflags: u32, phhash: *mut usize) -> super::super::Foundation::BOOL;
20578         }
20579         ::std::mem::transmute(CryptCreateHash(::std::mem::transmute(hprov), ::std::mem::transmute(algid), ::std::mem::transmute(hkey), ::std::mem::transmute(dwflags), ::std::mem::transmute(phhash)))
20580     }
20581     #[cfg(not(windows))]
20582     unimplemented!("Unsupported target OS");
20583 }
20584 #[cfg(feature = "Win32_Foundation")]
20585 #[inline]
CryptCreateKeyIdentifierFromCSP<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwcertencodingtype: u32, pszpubkeyoid: Param1, ppubkeystruc: *const PUBLICKEYSTRUC, cbpubkeystruc: u32, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, pbhash: *mut u8, pcbhash: *mut u32) -> super::super::Foundation::BOOL20586 pub unsafe fn CryptCreateKeyIdentifierFromCSP<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwcertencodingtype: u32, pszpubkeyoid: Param1, ppubkeystruc: *const PUBLICKEYSTRUC, cbpubkeystruc: u32, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, pbhash: *mut u8, pcbhash: *mut u32) -> super::super::Foundation::BOOL {
20587     #[cfg(windows)]
20588     {
20589         #[link(name = "windows")]
20590         extern "system" {
20591             fn CryptCreateKeyIdentifierFromCSP(dwcertencodingtype: u32, pszpubkeyoid: super::super::Foundation::PSTR, ppubkeystruc: *const PUBLICKEYSTRUC, cbpubkeystruc: u32, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, pbhash: *mut u8, pcbhash: *mut u32) -> super::super::Foundation::BOOL;
20592         }
20593         ::std::mem::transmute(CryptCreateKeyIdentifierFromCSP(
20594             ::std::mem::transmute(dwcertencodingtype),
20595             pszpubkeyoid.into_param().abi(),
20596             ::std::mem::transmute(ppubkeystruc),
20597             ::std::mem::transmute(cbpubkeystruc),
20598             ::std::mem::transmute(dwflags),
20599             ::std::mem::transmute(pvreserved),
20600             ::std::mem::transmute(pbhash),
20601             ::std::mem::transmute(pcbhash),
20602         ))
20603     }
20604     #[cfg(not(windows))]
20605     unimplemented!("Unsupported target OS");
20606 }
20607 #[cfg(feature = "Win32_Foundation")]
20608 #[inline]
CryptDecodeMessage(dwmsgtypeflags: u32, pdecryptpara: *const CRYPT_DECRYPT_MESSAGE_PARA, pverifypara: *const CRYPT_VERIFY_MESSAGE_PARA, dwsignerindex: u32, pbencodedblob: *const u8, cbencodedblob: u32, dwprevinnercontenttype: u32, pdwmsgtype: *mut u32, pdwinnercontenttype: *mut u32, pbdecoded: *mut u8, pcbdecoded: *mut u32, ppxchgcert: *mut *mut CERT_CONTEXT, ppsignercert: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL20609 pub unsafe fn CryptDecodeMessage(dwmsgtypeflags: u32, pdecryptpara: *const CRYPT_DECRYPT_MESSAGE_PARA, pverifypara: *const CRYPT_VERIFY_MESSAGE_PARA, dwsignerindex: u32, pbencodedblob: *const u8, cbencodedblob: u32, dwprevinnercontenttype: u32, pdwmsgtype: *mut u32, pdwinnercontenttype: *mut u32, pbdecoded: *mut u8, pcbdecoded: *mut u32, ppxchgcert: *mut *mut CERT_CONTEXT, ppsignercert: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL {
20610     #[cfg(windows)]
20611     {
20612         #[link(name = "windows")]
20613         extern "system" {
20614             fn CryptDecodeMessage(dwmsgtypeflags: u32, pdecryptpara: *const CRYPT_DECRYPT_MESSAGE_PARA, pverifypara: *const ::std::mem::ManuallyDrop<CRYPT_VERIFY_MESSAGE_PARA>, dwsignerindex: u32, pbencodedblob: *const u8, cbencodedblob: u32, dwprevinnercontenttype: u32, pdwmsgtype: *mut u32, pdwinnercontenttype: *mut u32, pbdecoded: *mut u8, pcbdecoded: *mut u32, ppxchgcert: *mut *mut CERT_CONTEXT, ppsignercert: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL;
20615         }
20616         ::std::mem::transmute(CryptDecodeMessage(
20617             ::std::mem::transmute(dwmsgtypeflags),
20618             ::std::mem::transmute(pdecryptpara),
20619             ::std::mem::transmute(pverifypara),
20620             ::std::mem::transmute(dwsignerindex),
20621             ::std::mem::transmute(pbencodedblob),
20622             ::std::mem::transmute(cbencodedblob),
20623             ::std::mem::transmute(dwprevinnercontenttype),
20624             ::std::mem::transmute(pdwmsgtype),
20625             ::std::mem::transmute(pdwinnercontenttype),
20626             ::std::mem::transmute(pbdecoded),
20627             ::std::mem::transmute(pcbdecoded),
20628             ::std::mem::transmute(ppxchgcert),
20629             ::std::mem::transmute(ppsignercert),
20630         ))
20631     }
20632     #[cfg(not(windows))]
20633     unimplemented!("Unsupported target OS");
20634 }
20635 #[cfg(feature = "Win32_Foundation")]
20636 #[inline]
CryptDecodeObject<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwcertencodingtype: u32, lpszstructtype: Param1, pbencoded: *const u8, cbencoded: u32, dwflags: u32, pvstructinfo: *mut ::std::ffi::c_void, pcbstructinfo: *mut u32) -> super::super::Foundation::BOOL20637 pub unsafe fn CryptDecodeObject<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwcertencodingtype: u32, lpszstructtype: Param1, pbencoded: *const u8, cbencoded: u32, dwflags: u32, pvstructinfo: *mut ::std::ffi::c_void, pcbstructinfo: *mut u32) -> super::super::Foundation::BOOL {
20638     #[cfg(windows)]
20639     {
20640         #[link(name = "windows")]
20641         extern "system" {
20642             fn CryptDecodeObject(dwcertencodingtype: u32, lpszstructtype: super::super::Foundation::PSTR, pbencoded: *const u8, cbencoded: u32, dwflags: u32, pvstructinfo: *mut ::std::ffi::c_void, pcbstructinfo: *mut u32) -> super::super::Foundation::BOOL;
20643         }
20644         ::std::mem::transmute(CryptDecodeObject(::std::mem::transmute(dwcertencodingtype), lpszstructtype.into_param().abi(), ::std::mem::transmute(pbencoded), ::std::mem::transmute(cbencoded), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvstructinfo), ::std::mem::transmute(pcbstructinfo)))
20645     }
20646     #[cfg(not(windows))]
20647     unimplemented!("Unsupported target OS");
20648 }
20649 #[cfg(feature = "Win32_Foundation")]
20650 #[inline]
CryptDecodeObjectEx<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwcertencodingtype: u32, lpszstructtype: Param1, pbencoded: *const u8, cbencoded: u32, dwflags: u32, pdecodepara: *const CRYPT_DECODE_PARA, pvstructinfo: *mut ::std::ffi::c_void, pcbstructinfo: *mut u32) -> super::super::Foundation::BOOL20651 pub unsafe fn CryptDecodeObjectEx<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwcertencodingtype: u32, lpszstructtype: Param1, pbencoded: *const u8, cbencoded: u32, dwflags: u32, pdecodepara: *const CRYPT_DECODE_PARA, pvstructinfo: *mut ::std::ffi::c_void, pcbstructinfo: *mut u32) -> super::super::Foundation::BOOL {
20652     #[cfg(windows)]
20653     {
20654         #[link(name = "windows")]
20655         extern "system" {
20656             fn CryptDecodeObjectEx(dwcertencodingtype: u32, lpszstructtype: super::super::Foundation::PSTR, pbencoded: *const u8, cbencoded: u32, dwflags: u32, pdecodepara: *const ::std::mem::ManuallyDrop<CRYPT_DECODE_PARA>, pvstructinfo: *mut ::std::ffi::c_void, pcbstructinfo: *mut u32) -> super::super::Foundation::BOOL;
20657         }
20658         ::std::mem::transmute(CryptDecodeObjectEx(
20659             ::std::mem::transmute(dwcertencodingtype),
20660             lpszstructtype.into_param().abi(),
20661             ::std::mem::transmute(pbencoded),
20662             ::std::mem::transmute(cbencoded),
20663             ::std::mem::transmute(dwflags),
20664             ::std::mem::transmute(pdecodepara),
20665             ::std::mem::transmute(pvstructinfo),
20666             ::std::mem::transmute(pcbstructinfo),
20667         ))
20668     }
20669     #[cfg(not(windows))]
20670     unimplemented!("Unsupported target OS");
20671 }
20672 #[cfg(feature = "Win32_Foundation")]
20673 #[inline]
CryptDecrypt<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hkey: usize, hhash: usize, r#final: Param2, dwflags: u32, pbdata: *mut u8, pdwdatalen: *mut u32) -> super::super::Foundation::BOOL20674 pub unsafe fn CryptDecrypt<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hkey: usize, hhash: usize, r#final: Param2, dwflags: u32, pbdata: *mut u8, pdwdatalen: *mut u32) -> super::super::Foundation::BOOL {
20675     #[cfg(windows)]
20676     {
20677         #[link(name = "windows")]
20678         extern "system" {
20679             fn CryptDecrypt(hkey: usize, hhash: usize, r#final: super::super::Foundation::BOOL, dwflags: u32, pbdata: *mut u8, pdwdatalen: *mut u32) -> super::super::Foundation::BOOL;
20680         }
20681         ::std::mem::transmute(CryptDecrypt(::std::mem::transmute(hkey), ::std::mem::transmute(hhash), r#final.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(pbdata), ::std::mem::transmute(pdwdatalen)))
20682     }
20683     #[cfg(not(windows))]
20684     unimplemented!("Unsupported target OS");
20685 }
20686 #[cfg(feature = "Win32_Foundation")]
20687 #[inline]
CryptDecryptAndVerifyMessageSignature(pdecryptpara: *const CRYPT_DECRYPT_MESSAGE_PARA, pverifypara: *const CRYPT_VERIFY_MESSAGE_PARA, dwsignerindex: u32, pbencryptedblob: *const u8, cbencryptedblob: u32, pbdecrypted: *mut u8, pcbdecrypted: *mut u32, ppxchgcert: *mut *mut CERT_CONTEXT, ppsignercert: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL20688 pub unsafe fn CryptDecryptAndVerifyMessageSignature(pdecryptpara: *const CRYPT_DECRYPT_MESSAGE_PARA, pverifypara: *const CRYPT_VERIFY_MESSAGE_PARA, dwsignerindex: u32, pbencryptedblob: *const u8, cbencryptedblob: u32, pbdecrypted: *mut u8, pcbdecrypted: *mut u32, ppxchgcert: *mut *mut CERT_CONTEXT, ppsignercert: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL {
20689     #[cfg(windows)]
20690     {
20691         #[link(name = "windows")]
20692         extern "system" {
20693             fn CryptDecryptAndVerifyMessageSignature(pdecryptpara: *const CRYPT_DECRYPT_MESSAGE_PARA, pverifypara: *const ::std::mem::ManuallyDrop<CRYPT_VERIFY_MESSAGE_PARA>, dwsignerindex: u32, pbencryptedblob: *const u8, cbencryptedblob: u32, pbdecrypted: *mut u8, pcbdecrypted: *mut u32, ppxchgcert: *mut *mut CERT_CONTEXT, ppsignercert: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL;
20694         }
20695         ::std::mem::transmute(CryptDecryptAndVerifyMessageSignature(
20696             ::std::mem::transmute(pdecryptpara),
20697             ::std::mem::transmute(pverifypara),
20698             ::std::mem::transmute(dwsignerindex),
20699             ::std::mem::transmute(pbencryptedblob),
20700             ::std::mem::transmute(cbencryptedblob),
20701             ::std::mem::transmute(pbdecrypted),
20702             ::std::mem::transmute(pcbdecrypted),
20703             ::std::mem::transmute(ppxchgcert),
20704             ::std::mem::transmute(ppsignercert),
20705         ))
20706     }
20707     #[cfg(not(windows))]
20708     unimplemented!("Unsupported target OS");
20709 }
20710 #[cfg(feature = "Win32_Foundation")]
20711 #[inline]
CryptDecryptMessage(pdecryptpara: *const CRYPT_DECRYPT_MESSAGE_PARA, pbencryptedblob: *const u8, cbencryptedblob: u32, pbdecrypted: *mut u8, pcbdecrypted: *mut u32, ppxchgcert: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL20712 pub unsafe fn CryptDecryptMessage(pdecryptpara: *const CRYPT_DECRYPT_MESSAGE_PARA, pbencryptedblob: *const u8, cbencryptedblob: u32, pbdecrypted: *mut u8, pcbdecrypted: *mut u32, ppxchgcert: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL {
20713     #[cfg(windows)]
20714     {
20715         #[link(name = "windows")]
20716         extern "system" {
20717             fn CryptDecryptMessage(pdecryptpara: *const CRYPT_DECRYPT_MESSAGE_PARA, pbencryptedblob: *const u8, cbencryptedblob: u32, pbdecrypted: *mut u8, pcbdecrypted: *mut u32, ppxchgcert: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL;
20718         }
20719         ::std::mem::transmute(CryptDecryptMessage(::std::mem::transmute(pdecryptpara), ::std::mem::transmute(pbencryptedblob), ::std::mem::transmute(cbencryptedblob), ::std::mem::transmute(pbdecrypted), ::std::mem::transmute(pcbdecrypted), ::std::mem::transmute(ppxchgcert)))
20720     }
20721     #[cfg(not(windows))]
20722     unimplemented!("Unsupported target OS");
20723 }
20724 #[cfg(feature = "Win32_Foundation")]
20725 #[inline]
CryptDeriveKey(hprov: usize, algid: u32, hbasedata: usize, dwflags: u32, phkey: *mut usize) -> super::super::Foundation::BOOL20726 pub unsafe fn CryptDeriveKey(hprov: usize, algid: u32, hbasedata: usize, dwflags: u32, phkey: *mut usize) -> super::super::Foundation::BOOL {
20727     #[cfg(windows)]
20728     {
20729         #[link(name = "windows")]
20730         extern "system" {
20731             fn CryptDeriveKey(hprov: usize, algid: u32, hbasedata: usize, dwflags: u32, phkey: *mut usize) -> super::super::Foundation::BOOL;
20732         }
20733         ::std::mem::transmute(CryptDeriveKey(::std::mem::transmute(hprov), ::std::mem::transmute(algid), ::std::mem::transmute(hbasedata), ::std::mem::transmute(dwflags), ::std::mem::transmute(phkey)))
20734     }
20735     #[cfg(not(windows))]
20736     unimplemented!("Unsupported target OS");
20737 }
20738 #[cfg(feature = "Win32_Foundation")]
20739 #[inline]
CryptDestroyHash(hhash: usize) -> super::super::Foundation::BOOL20740 pub unsafe fn CryptDestroyHash(hhash: usize) -> super::super::Foundation::BOOL {
20741     #[cfg(windows)]
20742     {
20743         #[link(name = "windows")]
20744         extern "system" {
20745             fn CryptDestroyHash(hhash: usize) -> super::super::Foundation::BOOL;
20746         }
20747         ::std::mem::transmute(CryptDestroyHash(::std::mem::transmute(hhash)))
20748     }
20749     #[cfg(not(windows))]
20750     unimplemented!("Unsupported target OS");
20751 }
20752 #[cfg(feature = "Win32_Foundation")]
20753 #[inline]
CryptDestroyKey(hkey: usize) -> super::super::Foundation::BOOL20754 pub unsafe fn CryptDestroyKey(hkey: usize) -> super::super::Foundation::BOOL {
20755     #[cfg(windows)]
20756     {
20757         #[link(name = "windows")]
20758         extern "system" {
20759             fn CryptDestroyKey(hkey: usize) -> super::super::Foundation::BOOL;
20760         }
20761         ::std::mem::transmute(CryptDestroyKey(::std::mem::transmute(hkey)))
20762     }
20763     #[cfg(not(windows))]
20764     unimplemented!("Unsupported target OS");
20765 }
20766 #[cfg(feature = "Win32_Foundation")]
20767 #[inline]
CryptDuplicateHash(hhash: usize, pdwreserved: *mut u32, dwflags: u32, phhash: *mut usize) -> super::super::Foundation::BOOL20768 pub unsafe fn CryptDuplicateHash(hhash: usize, pdwreserved: *mut u32, dwflags: u32, phhash: *mut usize) -> super::super::Foundation::BOOL {
20769     #[cfg(windows)]
20770     {
20771         #[link(name = "windows")]
20772         extern "system" {
20773             fn CryptDuplicateHash(hhash: usize, pdwreserved: *mut u32, dwflags: u32, phhash: *mut usize) -> super::super::Foundation::BOOL;
20774         }
20775         ::std::mem::transmute(CryptDuplicateHash(::std::mem::transmute(hhash), ::std::mem::transmute(pdwreserved), ::std::mem::transmute(dwflags), ::std::mem::transmute(phhash)))
20776     }
20777     #[cfg(not(windows))]
20778     unimplemented!("Unsupported target OS");
20779 }
20780 #[cfg(feature = "Win32_Foundation")]
20781 #[inline]
CryptDuplicateKey(hkey: usize, pdwreserved: *mut u32, dwflags: u32, phkey: *mut usize) -> super::super::Foundation::BOOL20782 pub unsafe fn CryptDuplicateKey(hkey: usize, pdwreserved: *mut u32, dwflags: u32, phkey: *mut usize) -> super::super::Foundation::BOOL {
20783     #[cfg(windows)]
20784     {
20785         #[link(name = "windows")]
20786         extern "system" {
20787             fn CryptDuplicateKey(hkey: usize, pdwreserved: *mut u32, dwflags: u32, phkey: *mut usize) -> super::super::Foundation::BOOL;
20788         }
20789         ::std::mem::transmute(CryptDuplicateKey(::std::mem::transmute(hkey), ::std::mem::transmute(pdwreserved), ::std::mem::transmute(dwflags), ::std::mem::transmute(phkey)))
20790     }
20791     #[cfg(not(windows))]
20792     unimplemented!("Unsupported target OS");
20793 }
20794 #[cfg(feature = "Win32_Foundation")]
20795 #[inline]
CryptEncodeObject<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwcertencodingtype: u32, lpszstructtype: Param1, pvstructinfo: *const ::std::ffi::c_void, pbencoded: *mut u8, pcbencoded: *mut u32) -> super::super::Foundation::BOOL20796 pub unsafe fn CryptEncodeObject<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwcertencodingtype: u32, lpszstructtype: Param1, pvstructinfo: *const ::std::ffi::c_void, pbencoded: *mut u8, pcbencoded: *mut u32) -> super::super::Foundation::BOOL {
20797     #[cfg(windows)]
20798     {
20799         #[link(name = "windows")]
20800         extern "system" {
20801             fn CryptEncodeObject(dwcertencodingtype: u32, lpszstructtype: super::super::Foundation::PSTR, pvstructinfo: *const ::std::ffi::c_void, pbencoded: *mut u8, pcbencoded: *mut u32) -> super::super::Foundation::BOOL;
20802         }
20803         ::std::mem::transmute(CryptEncodeObject(::std::mem::transmute(dwcertencodingtype), lpszstructtype.into_param().abi(), ::std::mem::transmute(pvstructinfo), ::std::mem::transmute(pbencoded), ::std::mem::transmute(pcbencoded)))
20804     }
20805     #[cfg(not(windows))]
20806     unimplemented!("Unsupported target OS");
20807 }
20808 #[cfg(feature = "Win32_Foundation")]
20809 #[inline]
CryptEncodeObjectEx<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwcertencodingtype: CERT_QUERY_ENCODING_TYPE, lpszstructtype: Param1, pvstructinfo: *const ::std::ffi::c_void, dwflags: CRYPT_ENCODE_OBJECT_FLAGS, pencodepara: *const CRYPT_ENCODE_PARA, pvencoded: *mut ::std::ffi::c_void, pcbencoded: *mut u32) -> super::super::Foundation::BOOL20810 pub unsafe fn CryptEncodeObjectEx<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwcertencodingtype: CERT_QUERY_ENCODING_TYPE, lpszstructtype: Param1, pvstructinfo: *const ::std::ffi::c_void, dwflags: CRYPT_ENCODE_OBJECT_FLAGS, pencodepara: *const CRYPT_ENCODE_PARA, pvencoded: *mut ::std::ffi::c_void, pcbencoded: *mut u32) -> super::super::Foundation::BOOL {
20811     #[cfg(windows)]
20812     {
20813         #[link(name = "windows")]
20814         extern "system" {
20815             fn CryptEncodeObjectEx(dwcertencodingtype: CERT_QUERY_ENCODING_TYPE, lpszstructtype: super::super::Foundation::PSTR, pvstructinfo: *const ::std::ffi::c_void, dwflags: CRYPT_ENCODE_OBJECT_FLAGS, pencodepara: *const ::std::mem::ManuallyDrop<CRYPT_ENCODE_PARA>, pvencoded: *mut ::std::ffi::c_void, pcbencoded: *mut u32) -> super::super::Foundation::BOOL;
20816         }
20817         ::std::mem::transmute(CryptEncodeObjectEx(::std::mem::transmute(dwcertencodingtype), lpszstructtype.into_param().abi(), ::std::mem::transmute(pvstructinfo), ::std::mem::transmute(dwflags), ::std::mem::transmute(pencodepara), ::std::mem::transmute(pvencoded), ::std::mem::transmute(pcbencoded)))
20818     }
20819     #[cfg(not(windows))]
20820     unimplemented!("Unsupported target OS");
20821 }
20822 #[cfg(feature = "Win32_Foundation")]
20823 #[inline]
CryptEncrypt<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hkey: usize, hhash: usize, r#final: Param2, dwflags: u32, pbdata: *mut u8, pdwdatalen: *mut u32, dwbuflen: u32) -> super::super::Foundation::BOOL20824 pub unsafe fn CryptEncrypt<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hkey: usize, hhash: usize, r#final: Param2, dwflags: u32, pbdata: *mut u8, pdwdatalen: *mut u32, dwbuflen: u32) -> super::super::Foundation::BOOL {
20825     #[cfg(windows)]
20826     {
20827         #[link(name = "windows")]
20828         extern "system" {
20829             fn CryptEncrypt(hkey: usize, hhash: usize, r#final: super::super::Foundation::BOOL, dwflags: u32, pbdata: *mut u8, pdwdatalen: *mut u32, dwbuflen: u32) -> super::super::Foundation::BOOL;
20830         }
20831         ::std::mem::transmute(CryptEncrypt(::std::mem::transmute(hkey), ::std::mem::transmute(hhash), r#final.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(pbdata), ::std::mem::transmute(pdwdatalen), ::std::mem::transmute(dwbuflen)))
20832     }
20833     #[cfg(not(windows))]
20834     unimplemented!("Unsupported target OS");
20835 }
20836 #[cfg(feature = "Win32_Foundation")]
20837 #[inline]
CryptEncryptMessage(pencryptpara: *const CRYPT_ENCRYPT_MESSAGE_PARA, crecipientcert: u32, rgprecipientcert: *const *const CERT_CONTEXT, pbtobeencrypted: *const u8, cbtobeencrypted: u32, pbencryptedblob: *mut u8, pcbencryptedblob: *mut u32) -> super::super::Foundation::BOOL20838 pub unsafe fn CryptEncryptMessage(pencryptpara: *const CRYPT_ENCRYPT_MESSAGE_PARA, crecipientcert: u32, rgprecipientcert: *const *const CERT_CONTEXT, pbtobeencrypted: *const u8, cbtobeencrypted: u32, pbencryptedblob: *mut u8, pcbencryptedblob: *mut u32) -> super::super::Foundation::BOOL {
20839     #[cfg(windows)]
20840     {
20841         #[link(name = "windows")]
20842         extern "system" {
20843             fn CryptEncryptMessage(pencryptpara: *const CRYPT_ENCRYPT_MESSAGE_PARA, crecipientcert: u32, rgprecipientcert: *const *const CERT_CONTEXT, pbtobeencrypted: *const u8, cbtobeencrypted: u32, pbencryptedblob: *mut u8, pcbencryptedblob: *mut u32) -> super::super::Foundation::BOOL;
20844         }
20845         ::std::mem::transmute(CryptEncryptMessage(::std::mem::transmute(pencryptpara), ::std::mem::transmute(crecipientcert), ::std::mem::transmute(rgprecipientcert), ::std::mem::transmute(pbtobeencrypted), ::std::mem::transmute(cbtobeencrypted), ::std::mem::transmute(pbencryptedblob), ::std::mem::transmute(pcbencryptedblob)))
20846     }
20847     #[cfg(not(windows))]
20848     unimplemented!("Unsupported target OS");
20849 }
20850 #[cfg(feature = "Win32_Foundation")]
20851 #[inline]
CryptEnumKeyIdentifierProperties<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pkeyidentifier: *const CRYPTOAPI_BLOB, dwpropid: u32, dwflags: u32, pwszcomputername: Param3, pvreserved: *mut ::std::ffi::c_void, pvarg: *mut ::std::ffi::c_void, pfnenum: ::std::option::Option<PFN_CRYPT_ENUM_KEYID_PROP>) -> super::super::Foundation::BOOL20852 pub unsafe fn CryptEnumKeyIdentifierProperties<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pkeyidentifier: *const CRYPTOAPI_BLOB, dwpropid: u32, dwflags: u32, pwszcomputername: Param3, pvreserved: *mut ::std::ffi::c_void, pvarg: *mut ::std::ffi::c_void, pfnenum: ::std::option::Option<PFN_CRYPT_ENUM_KEYID_PROP>) -> super::super::Foundation::BOOL {
20853     #[cfg(windows)]
20854     {
20855         #[link(name = "windows")]
20856         extern "system" {
20857             fn CryptEnumKeyIdentifierProperties(pkeyidentifier: *const CRYPTOAPI_BLOB, dwpropid: u32, dwflags: u32, pwszcomputername: super::super::Foundation::PWSTR, pvreserved: *mut ::std::ffi::c_void, pvarg: *mut ::std::ffi::c_void, pfnenum: ::windows::runtime::RawPtr) -> super::super::Foundation::BOOL;
20858         }
20859         ::std::mem::transmute(CryptEnumKeyIdentifierProperties(::std::mem::transmute(pkeyidentifier), ::std::mem::transmute(dwpropid), ::std::mem::transmute(dwflags), pwszcomputername.into_param().abi(), ::std::mem::transmute(pvreserved), ::std::mem::transmute(pvarg), ::std::mem::transmute(pfnenum)))
20860     }
20861     #[cfg(not(windows))]
20862     unimplemented!("Unsupported target OS");
20863 }
20864 #[cfg(feature = "Win32_Foundation")]
20865 #[inline]
CryptEnumOIDFunction<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwencodingtype: u32, pszfuncname: Param1, pszoid: Param2, dwflags: u32, pvarg: *mut ::std::ffi::c_void, pfnenumoidfunc: ::std::option::Option<PFN_CRYPT_ENUM_OID_FUNC>) -> super::super::Foundation::BOOL20866 pub unsafe fn CryptEnumOIDFunction<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwencodingtype: u32, pszfuncname: Param1, pszoid: Param2, dwflags: u32, pvarg: *mut ::std::ffi::c_void, pfnenumoidfunc: ::std::option::Option<PFN_CRYPT_ENUM_OID_FUNC>) -> super::super::Foundation::BOOL {
20867     #[cfg(windows)]
20868     {
20869         #[link(name = "windows")]
20870         extern "system" {
20871             fn CryptEnumOIDFunction(dwencodingtype: u32, pszfuncname: super::super::Foundation::PSTR, pszoid: super::super::Foundation::PSTR, dwflags: u32, pvarg: *mut ::std::ffi::c_void, pfnenumoidfunc: ::windows::runtime::RawPtr) -> super::super::Foundation::BOOL;
20872         }
20873         ::std::mem::transmute(CryptEnumOIDFunction(::std::mem::transmute(dwencodingtype), pszfuncname.into_param().abi(), pszoid.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvarg), ::std::mem::transmute(pfnenumoidfunc)))
20874     }
20875     #[cfg(not(windows))]
20876     unimplemented!("Unsupported target OS");
20877 }
20878 #[cfg(feature = "Win32_Foundation")]
20879 #[inline]
CryptEnumOIDInfo(dwgroupid: u32, dwflags: u32, pvarg: *mut ::std::ffi::c_void, pfnenumoidinfo: ::std::option::Option<PFN_CRYPT_ENUM_OID_INFO>) -> super::super::Foundation::BOOL20880 pub unsafe fn CryptEnumOIDInfo(dwgroupid: u32, dwflags: u32, pvarg: *mut ::std::ffi::c_void, pfnenumoidinfo: ::std::option::Option<PFN_CRYPT_ENUM_OID_INFO>) -> super::super::Foundation::BOOL {
20881     #[cfg(windows)]
20882     {
20883         #[link(name = "windows")]
20884         extern "system" {
20885             fn CryptEnumOIDInfo(dwgroupid: u32, dwflags: u32, pvarg: *mut ::std::ffi::c_void, pfnenumoidinfo: ::windows::runtime::RawPtr) -> super::super::Foundation::BOOL;
20886         }
20887         ::std::mem::transmute(CryptEnumOIDInfo(::std::mem::transmute(dwgroupid), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvarg), ::std::mem::transmute(pfnenumoidinfo)))
20888     }
20889     #[cfg(not(windows))]
20890     unimplemented!("Unsupported target OS");
20891 }
20892 #[cfg(feature = "Win32_Foundation")]
20893 #[inline]
CryptEnumProviderTypesA(dwindex: u32, pdwreserved: *mut u32, dwflags: u32, pdwprovtype: *mut u32, sztypename: super::super::Foundation::PSTR, pcbtypename: *mut u32) -> super::super::Foundation::BOOL20894 pub unsafe fn CryptEnumProviderTypesA(dwindex: u32, pdwreserved: *mut u32, dwflags: u32, pdwprovtype: *mut u32, sztypename: super::super::Foundation::PSTR, pcbtypename: *mut u32) -> super::super::Foundation::BOOL {
20895     #[cfg(windows)]
20896     {
20897         #[link(name = "windows")]
20898         extern "system" {
20899             fn CryptEnumProviderTypesA(dwindex: u32, pdwreserved: *mut u32, dwflags: u32, pdwprovtype: *mut u32, sztypename: super::super::Foundation::PSTR, pcbtypename: *mut u32) -> super::super::Foundation::BOOL;
20900         }
20901         ::std::mem::transmute(CryptEnumProviderTypesA(::std::mem::transmute(dwindex), ::std::mem::transmute(pdwreserved), ::std::mem::transmute(dwflags), ::std::mem::transmute(pdwprovtype), ::std::mem::transmute(sztypename), ::std::mem::transmute(pcbtypename)))
20902     }
20903     #[cfg(not(windows))]
20904     unimplemented!("Unsupported target OS");
20905 }
20906 #[cfg(feature = "Win32_Foundation")]
20907 #[inline]
CryptEnumProviderTypesW(dwindex: u32, pdwreserved: *mut u32, dwflags: u32, pdwprovtype: *mut u32, sztypename: super::super::Foundation::PWSTR, pcbtypename: *mut u32) -> super::super::Foundation::BOOL20908 pub unsafe fn CryptEnumProviderTypesW(dwindex: u32, pdwreserved: *mut u32, dwflags: u32, pdwprovtype: *mut u32, sztypename: super::super::Foundation::PWSTR, pcbtypename: *mut u32) -> super::super::Foundation::BOOL {
20909     #[cfg(windows)]
20910     {
20911         #[link(name = "windows")]
20912         extern "system" {
20913             fn CryptEnumProviderTypesW(dwindex: u32, pdwreserved: *mut u32, dwflags: u32, pdwprovtype: *mut u32, sztypename: super::super::Foundation::PWSTR, pcbtypename: *mut u32) -> super::super::Foundation::BOOL;
20914         }
20915         ::std::mem::transmute(CryptEnumProviderTypesW(::std::mem::transmute(dwindex), ::std::mem::transmute(pdwreserved), ::std::mem::transmute(dwflags), ::std::mem::transmute(pdwprovtype), ::std::mem::transmute(sztypename), ::std::mem::transmute(pcbtypename)))
20916     }
20917     #[cfg(not(windows))]
20918     unimplemented!("Unsupported target OS");
20919 }
20920 #[cfg(feature = "Win32_Foundation")]
20921 #[inline]
CryptEnumProvidersA(dwindex: u32, pdwreserved: *mut u32, dwflags: u32, pdwprovtype: *mut u32, szprovname: super::super::Foundation::PSTR, pcbprovname: *mut u32) -> super::super::Foundation::BOOL20922 pub unsafe fn CryptEnumProvidersA(dwindex: u32, pdwreserved: *mut u32, dwflags: u32, pdwprovtype: *mut u32, szprovname: super::super::Foundation::PSTR, pcbprovname: *mut u32) -> super::super::Foundation::BOOL {
20923     #[cfg(windows)]
20924     {
20925         #[link(name = "windows")]
20926         extern "system" {
20927             fn CryptEnumProvidersA(dwindex: u32, pdwreserved: *mut u32, dwflags: u32, pdwprovtype: *mut u32, szprovname: super::super::Foundation::PSTR, pcbprovname: *mut u32) -> super::super::Foundation::BOOL;
20928         }
20929         ::std::mem::transmute(CryptEnumProvidersA(::std::mem::transmute(dwindex), ::std::mem::transmute(pdwreserved), ::std::mem::transmute(dwflags), ::std::mem::transmute(pdwprovtype), ::std::mem::transmute(szprovname), ::std::mem::transmute(pcbprovname)))
20930     }
20931     #[cfg(not(windows))]
20932     unimplemented!("Unsupported target OS");
20933 }
20934 #[cfg(feature = "Win32_Foundation")]
20935 #[inline]
CryptEnumProvidersW(dwindex: u32, pdwreserved: *mut u32, dwflags: u32, pdwprovtype: *mut u32, szprovname: super::super::Foundation::PWSTR, pcbprovname: *mut u32) -> super::super::Foundation::BOOL20936 pub unsafe fn CryptEnumProvidersW(dwindex: u32, pdwreserved: *mut u32, dwflags: u32, pdwprovtype: *mut u32, szprovname: super::super::Foundation::PWSTR, pcbprovname: *mut u32) -> super::super::Foundation::BOOL {
20937     #[cfg(windows)]
20938     {
20939         #[link(name = "windows")]
20940         extern "system" {
20941             fn CryptEnumProvidersW(dwindex: u32, pdwreserved: *mut u32, dwflags: u32, pdwprovtype: *mut u32, szprovname: super::super::Foundation::PWSTR, pcbprovname: *mut u32) -> super::super::Foundation::BOOL;
20942         }
20943         ::std::mem::transmute(CryptEnumProvidersW(::std::mem::transmute(dwindex), ::std::mem::transmute(pdwreserved), ::std::mem::transmute(dwflags), ::std::mem::transmute(pdwprovtype), ::std::mem::transmute(szprovname), ::std::mem::transmute(pcbprovname)))
20944     }
20945     #[cfg(not(windows))]
20946     unimplemented!("Unsupported target OS");
20947 }
20948 #[cfg(feature = "Win32_Foundation")]
20949 #[inline]
CryptExportKey(hkey: usize, hexpkey: usize, dwblobtype: u32, dwflags: CRYPT_KEY_FLAGS, pbdata: *mut u8, pdwdatalen: *mut u32) -> super::super::Foundation::BOOL20950 pub unsafe fn CryptExportKey(hkey: usize, hexpkey: usize, dwblobtype: u32, dwflags: CRYPT_KEY_FLAGS, pbdata: *mut u8, pdwdatalen: *mut u32) -> super::super::Foundation::BOOL {
20951     #[cfg(windows)]
20952     {
20953         #[link(name = "windows")]
20954         extern "system" {
20955             fn CryptExportKey(hkey: usize, hexpkey: usize, dwblobtype: u32, dwflags: CRYPT_KEY_FLAGS, pbdata: *mut u8, pdwdatalen: *mut u32) -> super::super::Foundation::BOOL;
20956         }
20957         ::std::mem::transmute(CryptExportKey(::std::mem::transmute(hkey), ::std::mem::transmute(hexpkey), ::std::mem::transmute(dwblobtype), ::std::mem::transmute(dwflags), ::std::mem::transmute(pbdata), ::std::mem::transmute(pdwdatalen)))
20958     }
20959     #[cfg(not(windows))]
20960     unimplemented!("Unsupported target OS");
20961 }
20962 #[cfg(feature = "Win32_Foundation")]
20963 #[inline]
CryptExportPKCS8<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hcryptprov: usize, dwkeyspec: u32, pszprivatekeyobjid: Param2, dwflags: u32, pvauxinfo: *const ::std::ffi::c_void, pbprivatekeyblob: *mut u8, pcbprivatekeyblob: *mut u32) -> super::super::Foundation::BOOL20964 pub unsafe fn CryptExportPKCS8<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hcryptprov: usize, dwkeyspec: u32, pszprivatekeyobjid: Param2, dwflags: u32, pvauxinfo: *const ::std::ffi::c_void, pbprivatekeyblob: *mut u8, pcbprivatekeyblob: *mut u32) -> super::super::Foundation::BOOL {
20965     #[cfg(windows)]
20966     {
20967         #[link(name = "windows")]
20968         extern "system" {
20969             fn CryptExportPKCS8(hcryptprov: usize, dwkeyspec: u32, pszprivatekeyobjid: super::super::Foundation::PSTR, dwflags: u32, pvauxinfo: *const ::std::ffi::c_void, pbprivatekeyblob: *mut u8, pcbprivatekeyblob: *mut u32) -> super::super::Foundation::BOOL;
20970         }
20971         ::std::mem::transmute(CryptExportPKCS8(::std::mem::transmute(hcryptprov), ::std::mem::transmute(dwkeyspec), pszprivatekeyobjid.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvauxinfo), ::std::mem::transmute(pbprivatekeyblob), ::std::mem::transmute(pcbprivatekeyblob)))
20972     }
20973     #[cfg(not(windows))]
20974     unimplemented!("Unsupported target OS");
20975 }
20976 #[cfg(feature = "Win32_Foundation")]
20977 #[inline]
CryptExportPublicKeyInfo(hcryptprovorncryptkey: usize, dwkeyspec: u32, dwcertencodingtype: u32, pinfo: *mut CERT_PUBLIC_KEY_INFO, pcbinfo: *mut u32) -> super::super::Foundation::BOOL20978 pub unsafe fn CryptExportPublicKeyInfo(hcryptprovorncryptkey: usize, dwkeyspec: u32, dwcertencodingtype: u32, pinfo: *mut CERT_PUBLIC_KEY_INFO, pcbinfo: *mut u32) -> super::super::Foundation::BOOL {
20979     #[cfg(windows)]
20980     {
20981         #[link(name = "windows")]
20982         extern "system" {
20983             fn CryptExportPublicKeyInfo(hcryptprovorncryptkey: usize, dwkeyspec: u32, dwcertencodingtype: u32, pinfo: *mut CERT_PUBLIC_KEY_INFO, pcbinfo: *mut u32) -> super::super::Foundation::BOOL;
20984         }
20985         ::std::mem::transmute(CryptExportPublicKeyInfo(::std::mem::transmute(hcryptprovorncryptkey), ::std::mem::transmute(dwkeyspec), ::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(pinfo), ::std::mem::transmute(pcbinfo)))
20986     }
20987     #[cfg(not(windows))]
20988     unimplemented!("Unsupported target OS");
20989 }
20990 #[cfg(feature = "Win32_Foundation")]
20991 #[inline]
CryptExportPublicKeyInfoEx<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hcryptprovorncryptkey: usize, dwkeyspec: u32, dwcertencodingtype: u32, pszpublickeyobjid: Param3, dwflags: u32, pvauxinfo: *const ::std::ffi::c_void, pinfo: *mut CERT_PUBLIC_KEY_INFO, pcbinfo: *mut u32) -> super::super::Foundation::BOOL20992 pub unsafe fn CryptExportPublicKeyInfoEx<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hcryptprovorncryptkey: usize, dwkeyspec: u32, dwcertencodingtype: u32, pszpublickeyobjid: Param3, dwflags: u32, pvauxinfo: *const ::std::ffi::c_void, pinfo: *mut CERT_PUBLIC_KEY_INFO, pcbinfo: *mut u32) -> super::super::Foundation::BOOL {
20993     #[cfg(windows)]
20994     {
20995         #[link(name = "windows")]
20996         extern "system" {
20997             fn CryptExportPublicKeyInfoEx(hcryptprovorncryptkey: usize, dwkeyspec: u32, dwcertencodingtype: u32, pszpublickeyobjid: super::super::Foundation::PSTR, dwflags: u32, pvauxinfo: *const ::std::ffi::c_void, pinfo: *mut CERT_PUBLIC_KEY_INFO, pcbinfo: *mut u32) -> super::super::Foundation::BOOL;
20998         }
20999         ::std::mem::transmute(CryptExportPublicKeyInfoEx(
21000             ::std::mem::transmute(hcryptprovorncryptkey),
21001             ::std::mem::transmute(dwkeyspec),
21002             ::std::mem::transmute(dwcertencodingtype),
21003             pszpublickeyobjid.into_param().abi(),
21004             ::std::mem::transmute(dwflags),
21005             ::std::mem::transmute(pvauxinfo),
21006             ::std::mem::transmute(pinfo),
21007             ::std::mem::transmute(pcbinfo),
21008         ))
21009     }
21010     #[cfg(not(windows))]
21011     unimplemented!("Unsupported target OS");
21012 }
21013 #[cfg(feature = "Win32_Foundation")]
21014 #[inline]
CryptExportPublicKeyInfoFromBCryptKeyHandle<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hbcryptkey: Param0, dwcertencodingtype: u32, pszpublickeyobjid: Param2, dwflags: u32, pvauxinfo: *const ::std::ffi::c_void, pinfo: *mut CERT_PUBLIC_KEY_INFO, pcbinfo: *mut u32) -> super::super::Foundation::BOOL21015 pub unsafe fn CryptExportPublicKeyInfoFromBCryptKeyHandle<'a, Param0: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hbcryptkey: Param0, dwcertencodingtype: u32, pszpublickeyobjid: Param2, dwflags: u32, pvauxinfo: *const ::std::ffi::c_void, pinfo: *mut CERT_PUBLIC_KEY_INFO, pcbinfo: *mut u32) -> super::super::Foundation::BOOL {
21016     #[cfg(windows)]
21017     {
21018         #[link(name = "windows")]
21019         extern "system" {
21020             fn CryptExportPublicKeyInfoFromBCryptKeyHandle(hbcryptkey: BCRYPT_KEY_HANDLE, dwcertencodingtype: u32, pszpublickeyobjid: super::super::Foundation::PSTR, dwflags: u32, pvauxinfo: *const ::std::ffi::c_void, pinfo: *mut CERT_PUBLIC_KEY_INFO, pcbinfo: *mut u32) -> super::super::Foundation::BOOL;
21021         }
21022         ::std::mem::transmute(CryptExportPublicKeyInfoFromBCryptKeyHandle(hbcryptkey.into_param().abi(), ::std::mem::transmute(dwcertencodingtype), pszpublickeyobjid.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvauxinfo), ::std::mem::transmute(pinfo), ::std::mem::transmute(pcbinfo)))
21023     }
21024     #[cfg(not(windows))]
21025     unimplemented!("Unsupported target OS");
21026 }
21027 #[cfg(feature = "Win32_Foundation")]
21028 #[inline]
CryptFindCertificateKeyProvInfo(pcert: *const CERT_CONTEXT, dwflags: CRYPT_FIND_FLAGS, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL21029 pub unsafe fn CryptFindCertificateKeyProvInfo(pcert: *const CERT_CONTEXT, dwflags: CRYPT_FIND_FLAGS, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
21030     #[cfg(windows)]
21031     {
21032         #[link(name = "windows")]
21033         extern "system" {
21034             fn CryptFindCertificateKeyProvInfo(pcert: *const CERT_CONTEXT, dwflags: CRYPT_FIND_FLAGS, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
21035         }
21036         ::std::mem::transmute(CryptFindCertificateKeyProvInfo(::std::mem::transmute(pcert), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvreserved)))
21037     }
21038     #[cfg(not(windows))]
21039     unimplemented!("Unsupported target OS");
21040 }
21041 #[cfg(feature = "Win32_Foundation")]
21042 #[inline]
CryptFindLocalizedName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pwszcryptname: Param0) -> super::super::Foundation::PWSTR21043 pub unsafe fn CryptFindLocalizedName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pwszcryptname: Param0) -> super::super::Foundation::PWSTR {
21044     #[cfg(windows)]
21045     {
21046         #[link(name = "windows")]
21047         extern "system" {
21048             fn CryptFindLocalizedName(pwszcryptname: super::super::Foundation::PWSTR) -> super::super::Foundation::PWSTR;
21049         }
21050         ::std::mem::transmute(CryptFindLocalizedName(pwszcryptname.into_param().abi()))
21051     }
21052     #[cfg(not(windows))]
21053     unimplemented!("Unsupported target OS");
21054 }
21055 #[cfg(feature = "Win32_Foundation")]
21056 #[inline]
CryptFindOIDInfo(dwkeytype: u32, pvkey: *const ::std::ffi::c_void, dwgroupid: u32) -> *mut CRYPT_OID_INFO21057 pub unsafe fn CryptFindOIDInfo(dwkeytype: u32, pvkey: *const ::std::ffi::c_void, dwgroupid: u32) -> *mut CRYPT_OID_INFO {
21058     #[cfg(windows)]
21059     {
21060         #[link(name = "windows")]
21061         extern "system" {
21062             fn CryptFindOIDInfo(dwkeytype: u32, pvkey: *const ::std::ffi::c_void, dwgroupid: u32) -> *mut CRYPT_OID_INFO;
21063         }
21064         ::std::mem::transmute(CryptFindOIDInfo(::std::mem::transmute(dwkeytype), ::std::mem::transmute(pvkey), ::std::mem::transmute(dwgroupid)))
21065     }
21066     #[cfg(not(windows))]
21067     unimplemented!("Unsupported target OS");
21068 }
21069 #[cfg(feature = "Win32_Foundation")]
21070 #[inline]
CryptFormatObject<'a, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwcertencodingtype: u32, dwformattype: u32, dwformatstrtype: u32, pformatstruct: *const ::std::ffi::c_void, lpszstructtype: Param4, pbencoded: *const u8, cbencoded: u32, pbformat: *mut ::std::ffi::c_void, pcbformat: *mut u32) -> super::super::Foundation::BOOL21071 pub unsafe fn CryptFormatObject<'a, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwcertencodingtype: u32, dwformattype: u32, dwformatstrtype: u32, pformatstruct: *const ::std::ffi::c_void, lpszstructtype: Param4, pbencoded: *const u8, cbencoded: u32, pbformat: *mut ::std::ffi::c_void, pcbformat: *mut u32) -> super::super::Foundation::BOOL {
21072     #[cfg(windows)]
21073     {
21074         #[link(name = "windows")]
21075         extern "system" {
21076             fn CryptFormatObject(dwcertencodingtype: u32, dwformattype: u32, dwformatstrtype: u32, pformatstruct: *const ::std::ffi::c_void, lpszstructtype: super::super::Foundation::PSTR, pbencoded: *const u8, cbencoded: u32, pbformat: *mut ::std::ffi::c_void, pcbformat: *mut u32) -> super::super::Foundation::BOOL;
21077         }
21078         ::std::mem::transmute(CryptFormatObject(
21079             ::std::mem::transmute(dwcertencodingtype),
21080             ::std::mem::transmute(dwformattype),
21081             ::std::mem::transmute(dwformatstrtype),
21082             ::std::mem::transmute(pformatstruct),
21083             lpszstructtype.into_param().abi(),
21084             ::std::mem::transmute(pbencoded),
21085             ::std::mem::transmute(cbencoded),
21086             ::std::mem::transmute(pbformat),
21087             ::std::mem::transmute(pcbformat),
21088         ))
21089     }
21090     #[cfg(not(windows))]
21091     unimplemented!("Unsupported target OS");
21092 }
21093 #[cfg(feature = "Win32_Foundation")]
21094 #[inline]
CryptFreeOIDFunctionAddress(hfuncaddr: *const ::std::ffi::c_void, dwflags: u32) -> super::super::Foundation::BOOL21095 pub unsafe fn CryptFreeOIDFunctionAddress(hfuncaddr: *const ::std::ffi::c_void, dwflags: u32) -> super::super::Foundation::BOOL {
21096     #[cfg(windows)]
21097     {
21098         #[link(name = "windows")]
21099         extern "system" {
21100             fn CryptFreeOIDFunctionAddress(hfuncaddr: *const ::std::ffi::c_void, dwflags: u32) -> super::super::Foundation::BOOL;
21101         }
21102         ::std::mem::transmute(CryptFreeOIDFunctionAddress(::std::mem::transmute(hfuncaddr), ::std::mem::transmute(dwflags)))
21103     }
21104     #[cfg(not(windows))]
21105     unimplemented!("Unsupported target OS");
21106 }
21107 #[cfg(feature = "Win32_Foundation")]
21108 #[inline]
CryptGenKey(hprov: usize, algid: u32, dwflags: CRYPT_KEY_FLAGS, phkey: *mut usize) -> super::super::Foundation::BOOL21109 pub unsafe fn CryptGenKey(hprov: usize, algid: u32, dwflags: CRYPT_KEY_FLAGS, phkey: *mut usize) -> super::super::Foundation::BOOL {
21110     #[cfg(windows)]
21111     {
21112         #[link(name = "windows")]
21113         extern "system" {
21114             fn CryptGenKey(hprov: usize, algid: u32, dwflags: CRYPT_KEY_FLAGS, phkey: *mut usize) -> super::super::Foundation::BOOL;
21115         }
21116         ::std::mem::transmute(CryptGenKey(::std::mem::transmute(hprov), ::std::mem::transmute(algid), ::std::mem::transmute(dwflags), ::std::mem::transmute(phkey)))
21117     }
21118     #[cfg(not(windows))]
21119     unimplemented!("Unsupported target OS");
21120 }
21121 #[cfg(feature = "Win32_Foundation")]
21122 #[inline]
CryptGenRandom(hprov: usize, dwlen: u32, pbbuffer: *mut u8) -> super::super::Foundation::BOOL21123 pub unsafe fn CryptGenRandom(hprov: usize, dwlen: u32, pbbuffer: *mut u8) -> super::super::Foundation::BOOL {
21124     #[cfg(windows)]
21125     {
21126         #[link(name = "windows")]
21127         extern "system" {
21128             fn CryptGenRandom(hprov: usize, dwlen: u32, pbbuffer: *mut u8) -> super::super::Foundation::BOOL;
21129         }
21130         ::std::mem::transmute(CryptGenRandom(::std::mem::transmute(hprov), ::std::mem::transmute(dwlen), ::std::mem::transmute(pbbuffer)))
21131     }
21132     #[cfg(not(windows))]
21133     unimplemented!("Unsupported target OS");
21134 }
21135 #[cfg(feature = "Win32_Foundation")]
21136 #[inline]
CryptGetAsyncParam<'a, Param0: ::windows::runtime::IntoParam<'a, HCRYPTASYNC>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hasync: Param0, pszparamoid: Param1, ppvparam: *mut *mut ::std::ffi::c_void, ppfnfree: *mut ::std::option::Option<PFN_CRYPT_ASYNC_PARAM_FREE_FUNC>) -> super::super::Foundation::BOOL21137 pub unsafe fn CryptGetAsyncParam<'a, Param0: ::windows::runtime::IntoParam<'a, HCRYPTASYNC>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hasync: Param0, pszparamoid: Param1, ppvparam: *mut *mut ::std::ffi::c_void, ppfnfree: *mut ::std::option::Option<PFN_CRYPT_ASYNC_PARAM_FREE_FUNC>) -> super::super::Foundation::BOOL {
21138     #[cfg(windows)]
21139     {
21140         #[link(name = "windows")]
21141         extern "system" {
21142             fn CryptGetAsyncParam(hasync: HCRYPTASYNC, pszparamoid: super::super::Foundation::PSTR, ppvparam: *mut *mut ::std::ffi::c_void, ppfnfree: *mut ::windows::runtime::RawPtr) -> super::super::Foundation::BOOL;
21143         }
21144         ::std::mem::transmute(CryptGetAsyncParam(hasync.into_param().abi(), pszparamoid.into_param().abi(), ::std::mem::transmute(ppvparam), ::std::mem::transmute(ppfnfree)))
21145     }
21146     #[cfg(not(windows))]
21147     unimplemented!("Unsupported target OS");
21148 }
21149 #[cfg(feature = "Win32_Foundation")]
21150 #[inline]
CryptGetDefaultOIDDllList(hfuncset: *const ::std::ffi::c_void, dwencodingtype: u32, pwszdlllist: super::super::Foundation::PWSTR, pcchdlllist: *mut u32) -> super::super::Foundation::BOOL21151 pub unsafe fn CryptGetDefaultOIDDllList(hfuncset: *const ::std::ffi::c_void, dwencodingtype: u32, pwszdlllist: super::super::Foundation::PWSTR, pcchdlllist: *mut u32) -> super::super::Foundation::BOOL {
21152     #[cfg(windows)]
21153     {
21154         #[link(name = "windows")]
21155         extern "system" {
21156             fn CryptGetDefaultOIDDllList(hfuncset: *const ::std::ffi::c_void, dwencodingtype: u32, pwszdlllist: super::super::Foundation::PWSTR, pcchdlllist: *mut u32) -> super::super::Foundation::BOOL;
21157         }
21158         ::std::mem::transmute(CryptGetDefaultOIDDllList(::std::mem::transmute(hfuncset), ::std::mem::transmute(dwencodingtype), ::std::mem::transmute(pwszdlllist), ::std::mem::transmute(pcchdlllist)))
21159     }
21160     #[cfg(not(windows))]
21161     unimplemented!("Unsupported target OS");
21162 }
21163 #[cfg(feature = "Win32_Foundation")]
21164 #[inline]
CryptGetDefaultOIDFunctionAddress<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hfuncset: *const ::std::ffi::c_void, dwencodingtype: u32, pwszdll: Param2, dwflags: u32, ppvfuncaddr: *mut *mut ::std::ffi::c_void, phfuncaddr: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL21165 pub unsafe fn CryptGetDefaultOIDFunctionAddress<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hfuncset: *const ::std::ffi::c_void, dwencodingtype: u32, pwszdll: Param2, dwflags: u32, ppvfuncaddr: *mut *mut ::std::ffi::c_void, phfuncaddr: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
21166     #[cfg(windows)]
21167     {
21168         #[link(name = "windows")]
21169         extern "system" {
21170             fn CryptGetDefaultOIDFunctionAddress(hfuncset: *const ::std::ffi::c_void, dwencodingtype: u32, pwszdll: super::super::Foundation::PWSTR, dwflags: u32, ppvfuncaddr: *mut *mut ::std::ffi::c_void, phfuncaddr: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
21171         }
21172         ::std::mem::transmute(CryptGetDefaultOIDFunctionAddress(::std::mem::transmute(hfuncset), ::std::mem::transmute(dwencodingtype), pwszdll.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(ppvfuncaddr), ::std::mem::transmute(phfuncaddr)))
21173     }
21174     #[cfg(not(windows))]
21175     unimplemented!("Unsupported target OS");
21176 }
21177 #[cfg(feature = "Win32_Foundation")]
21178 #[inline]
CryptGetDefaultProviderA(dwprovtype: u32, pdwreserved: *mut u32, dwflags: u32, pszprovname: super::super::Foundation::PSTR, pcbprovname: *mut u32) -> super::super::Foundation::BOOL21179 pub unsafe fn CryptGetDefaultProviderA(dwprovtype: u32, pdwreserved: *mut u32, dwflags: u32, pszprovname: super::super::Foundation::PSTR, pcbprovname: *mut u32) -> super::super::Foundation::BOOL {
21180     #[cfg(windows)]
21181     {
21182         #[link(name = "windows")]
21183         extern "system" {
21184             fn CryptGetDefaultProviderA(dwprovtype: u32, pdwreserved: *mut u32, dwflags: u32, pszprovname: super::super::Foundation::PSTR, pcbprovname: *mut u32) -> super::super::Foundation::BOOL;
21185         }
21186         ::std::mem::transmute(CryptGetDefaultProviderA(::std::mem::transmute(dwprovtype), ::std::mem::transmute(pdwreserved), ::std::mem::transmute(dwflags), ::std::mem::transmute(pszprovname), ::std::mem::transmute(pcbprovname)))
21187     }
21188     #[cfg(not(windows))]
21189     unimplemented!("Unsupported target OS");
21190 }
21191 #[cfg(feature = "Win32_Foundation")]
21192 #[inline]
CryptGetDefaultProviderW(dwprovtype: u32, pdwreserved: *mut u32, dwflags: u32, pszprovname: super::super::Foundation::PWSTR, pcbprovname: *mut u32) -> super::super::Foundation::BOOL21193 pub unsafe fn CryptGetDefaultProviderW(dwprovtype: u32, pdwreserved: *mut u32, dwflags: u32, pszprovname: super::super::Foundation::PWSTR, pcbprovname: *mut u32) -> super::super::Foundation::BOOL {
21194     #[cfg(windows)]
21195     {
21196         #[link(name = "windows")]
21197         extern "system" {
21198             fn CryptGetDefaultProviderW(dwprovtype: u32, pdwreserved: *mut u32, dwflags: u32, pszprovname: super::super::Foundation::PWSTR, pcbprovname: *mut u32) -> super::super::Foundation::BOOL;
21199         }
21200         ::std::mem::transmute(CryptGetDefaultProviderW(::std::mem::transmute(dwprovtype), ::std::mem::transmute(pdwreserved), ::std::mem::transmute(dwflags), ::std::mem::transmute(pszprovname), ::std::mem::transmute(pcbprovname)))
21201     }
21202     #[cfg(not(windows))]
21203     unimplemented!("Unsupported target OS");
21204 }
21205 #[cfg(feature = "Win32_Foundation")]
21206 #[inline]
CryptGetHashParam(hhash: usize, dwparam: u32, pbdata: *mut u8, pdwdatalen: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL21207 pub unsafe fn CryptGetHashParam(hhash: usize, dwparam: u32, pbdata: *mut u8, pdwdatalen: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL {
21208     #[cfg(windows)]
21209     {
21210         #[link(name = "windows")]
21211         extern "system" {
21212             fn CryptGetHashParam(hhash: usize, dwparam: u32, pbdata: *mut u8, pdwdatalen: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL;
21213         }
21214         ::std::mem::transmute(CryptGetHashParam(::std::mem::transmute(hhash), ::std::mem::transmute(dwparam), ::std::mem::transmute(pbdata), ::std::mem::transmute(pdwdatalen), ::std::mem::transmute(dwflags)))
21215     }
21216     #[cfg(not(windows))]
21217     unimplemented!("Unsupported target OS");
21218 }
21219 #[cfg(feature = "Win32_Foundation")]
21220 #[inline]
CryptGetKeyIdentifierProperty<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pkeyidentifier: *const CRYPTOAPI_BLOB, dwpropid: u32, dwflags: u32, pwszcomputername: Param3, pvreserved: *mut ::std::ffi::c_void, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL21221 pub unsafe fn CryptGetKeyIdentifierProperty<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pkeyidentifier: *const CRYPTOAPI_BLOB, dwpropid: u32, dwflags: u32, pwszcomputername: Param3, pvreserved: *mut ::std::ffi::c_void, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL {
21222     #[cfg(windows)]
21223     {
21224         #[link(name = "windows")]
21225         extern "system" {
21226             fn CryptGetKeyIdentifierProperty(pkeyidentifier: *const CRYPTOAPI_BLOB, dwpropid: u32, dwflags: u32, pwszcomputername: super::super::Foundation::PWSTR, pvreserved: *mut ::std::ffi::c_void, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL;
21227         }
21228         ::std::mem::transmute(CryptGetKeyIdentifierProperty(::std::mem::transmute(pkeyidentifier), ::std::mem::transmute(dwpropid), ::std::mem::transmute(dwflags), pwszcomputername.into_param().abi(), ::std::mem::transmute(pvreserved), ::std::mem::transmute(pvdata), ::std::mem::transmute(pcbdata)))
21229     }
21230     #[cfg(not(windows))]
21231     unimplemented!("Unsupported target OS");
21232 }
21233 #[cfg(feature = "Win32_Foundation")]
21234 #[inline]
CryptGetKeyParam(hkey: usize, dwparam: CRYPT_KEY_PARAM_ID, pbdata: *mut u8, pdwdatalen: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL21235 pub unsafe fn CryptGetKeyParam(hkey: usize, dwparam: CRYPT_KEY_PARAM_ID, pbdata: *mut u8, pdwdatalen: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL {
21236     #[cfg(windows)]
21237     {
21238         #[link(name = "windows")]
21239         extern "system" {
21240             fn CryptGetKeyParam(hkey: usize, dwparam: CRYPT_KEY_PARAM_ID, pbdata: *mut u8, pdwdatalen: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL;
21241         }
21242         ::std::mem::transmute(CryptGetKeyParam(::std::mem::transmute(hkey), ::std::mem::transmute(dwparam), ::std::mem::transmute(pbdata), ::std::mem::transmute(pdwdatalen), ::std::mem::transmute(dwflags)))
21243     }
21244     #[cfg(not(windows))]
21245     unimplemented!("Unsupported target OS");
21246 }
21247 #[inline]
CryptGetMessageCertificates(dwmsgandcertencodingtype: u32, hcryptprov: usize, dwflags: u32, pbsignedblob: *const u8, cbsignedblob: u32) -> *mut ::std::ffi::c_void21248 pub unsafe fn CryptGetMessageCertificates(dwmsgandcertencodingtype: u32, hcryptprov: usize, dwflags: u32, pbsignedblob: *const u8, cbsignedblob: u32) -> *mut ::std::ffi::c_void {
21249     #[cfg(windows)]
21250     {
21251         #[link(name = "windows")]
21252         extern "system" {
21253             fn CryptGetMessageCertificates(dwmsgandcertencodingtype: u32, hcryptprov: usize, dwflags: u32, pbsignedblob: *const u8, cbsignedblob: u32) -> *mut ::std::ffi::c_void;
21254         }
21255         ::std::mem::transmute(CryptGetMessageCertificates(::std::mem::transmute(dwmsgandcertencodingtype), ::std::mem::transmute(hcryptprov), ::std::mem::transmute(dwflags), ::std::mem::transmute(pbsignedblob), ::std::mem::transmute(cbsignedblob)))
21256     }
21257     #[cfg(not(windows))]
21258     unimplemented!("Unsupported target OS");
21259 }
21260 #[inline]
CryptGetMessageSignerCount(dwmsgencodingtype: u32, pbsignedblob: *const u8, cbsignedblob: u32) -> i3221261 pub unsafe fn CryptGetMessageSignerCount(dwmsgencodingtype: u32, pbsignedblob: *const u8, cbsignedblob: u32) -> i32 {
21262     #[cfg(windows)]
21263     {
21264         #[link(name = "windows")]
21265         extern "system" {
21266             fn CryptGetMessageSignerCount(dwmsgencodingtype: u32, pbsignedblob: *const u8, cbsignedblob: u32) -> i32;
21267         }
21268         ::std::mem::transmute(CryptGetMessageSignerCount(::std::mem::transmute(dwmsgencodingtype), ::std::mem::transmute(pbsignedblob), ::std::mem::transmute(cbsignedblob)))
21269     }
21270     #[cfg(not(windows))]
21271     unimplemented!("Unsupported target OS");
21272 }
21273 #[cfg(feature = "Win32_Foundation")]
21274 #[inline]
CryptGetOIDFunctionAddress<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hfuncset: *const ::std::ffi::c_void, dwencodingtype: u32, pszoid: Param2, dwflags: u32, ppvfuncaddr: *mut *mut ::std::ffi::c_void, phfuncaddr: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL21275 pub unsafe fn CryptGetOIDFunctionAddress<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hfuncset: *const ::std::ffi::c_void, dwencodingtype: u32, pszoid: Param2, dwflags: u32, ppvfuncaddr: *mut *mut ::std::ffi::c_void, phfuncaddr: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
21276     #[cfg(windows)]
21277     {
21278         #[link(name = "windows")]
21279         extern "system" {
21280             fn CryptGetOIDFunctionAddress(hfuncset: *const ::std::ffi::c_void, dwencodingtype: u32, pszoid: super::super::Foundation::PSTR, dwflags: u32, ppvfuncaddr: *mut *mut ::std::ffi::c_void, phfuncaddr: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
21281         }
21282         ::std::mem::transmute(CryptGetOIDFunctionAddress(::std::mem::transmute(hfuncset), ::std::mem::transmute(dwencodingtype), pszoid.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(ppvfuncaddr), ::std::mem::transmute(phfuncaddr)))
21283     }
21284     #[cfg(not(windows))]
21285     unimplemented!("Unsupported target OS");
21286 }
21287 #[cfg(feature = "Win32_Foundation")]
21288 #[inline]
CryptGetOIDFunctionValue<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwencodingtype: u32, pszfuncname: Param1, pszoid: Param2, pwszvaluename: Param3, pdwvaluetype: *mut u32, pbvaluedata: *mut u8, pcbvaluedata: *mut u32) -> super::super::Foundation::BOOL21289 pub unsafe fn CryptGetOIDFunctionValue<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwencodingtype: u32, pszfuncname: Param1, pszoid: Param2, pwszvaluename: Param3, pdwvaluetype: *mut u32, pbvaluedata: *mut u8, pcbvaluedata: *mut u32) -> super::super::Foundation::BOOL {
21290     #[cfg(windows)]
21291     {
21292         #[link(name = "windows")]
21293         extern "system" {
21294             fn CryptGetOIDFunctionValue(dwencodingtype: u32, pszfuncname: super::super::Foundation::PSTR, pszoid: super::super::Foundation::PSTR, pwszvaluename: super::super::Foundation::PWSTR, pdwvaluetype: *mut u32, pbvaluedata: *mut u8, pcbvaluedata: *mut u32) -> super::super::Foundation::BOOL;
21295         }
21296         ::std::mem::transmute(CryptGetOIDFunctionValue(::std::mem::transmute(dwencodingtype), pszfuncname.into_param().abi(), pszoid.into_param().abi(), pwszvaluename.into_param().abi(), ::std::mem::transmute(pdwvaluetype), ::std::mem::transmute(pbvaluedata), ::std::mem::transmute(pcbvaluedata)))
21297     }
21298     #[cfg(not(windows))]
21299     unimplemented!("Unsupported target OS");
21300 }
21301 #[cfg(feature = "Win32_Foundation")]
21302 #[inline]
CryptGetObjectUrl<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszurloid: Param0, pvpara: *const ::std::ffi::c_void, dwflags: CRYPT_GET_URL_FLAGS, purlarray: *mut CRYPT_URL_ARRAY, pcburlarray: *mut u32, purlinfo: *mut CRYPT_URL_INFO, pcburlinfo: *mut u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL21303 pub unsafe fn CryptGetObjectUrl<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszurloid: Param0, pvpara: *const ::std::ffi::c_void, dwflags: CRYPT_GET_URL_FLAGS, purlarray: *mut CRYPT_URL_ARRAY, pcburlarray: *mut u32, purlinfo: *mut CRYPT_URL_INFO, pcburlinfo: *mut u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
21304     #[cfg(windows)]
21305     {
21306         #[link(name = "windows")]
21307         extern "system" {
21308             fn CryptGetObjectUrl(pszurloid: super::super::Foundation::PSTR, pvpara: *const ::std::ffi::c_void, dwflags: CRYPT_GET_URL_FLAGS, purlarray: *mut CRYPT_URL_ARRAY, pcburlarray: *mut u32, purlinfo: *mut CRYPT_URL_INFO, pcburlinfo: *mut u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
21309         }
21310         ::std::mem::transmute(CryptGetObjectUrl(pszurloid.into_param().abi(), ::std::mem::transmute(pvpara), ::std::mem::transmute(dwflags), ::std::mem::transmute(purlarray), ::std::mem::transmute(pcburlarray), ::std::mem::transmute(purlinfo), ::std::mem::transmute(pcburlinfo), ::std::mem::transmute(pvreserved)))
21311     }
21312     #[cfg(not(windows))]
21313     unimplemented!("Unsupported target OS");
21314 }
21315 #[cfg(feature = "Win32_Foundation")]
21316 #[inline]
CryptGetProvParam(hprov: usize, dwparam: u32, pbdata: *mut u8, pdwdatalen: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL21317 pub unsafe fn CryptGetProvParam(hprov: usize, dwparam: u32, pbdata: *mut u8, pdwdatalen: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL {
21318     #[cfg(windows)]
21319     {
21320         #[link(name = "windows")]
21321         extern "system" {
21322             fn CryptGetProvParam(hprov: usize, dwparam: u32, pbdata: *mut u8, pdwdatalen: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL;
21323         }
21324         ::std::mem::transmute(CryptGetProvParam(::std::mem::transmute(hprov), ::std::mem::transmute(dwparam), ::std::mem::transmute(pbdata), ::std::mem::transmute(pdwdatalen), ::std::mem::transmute(dwflags)))
21325     }
21326     #[cfg(not(windows))]
21327     unimplemented!("Unsupported target OS");
21328 }
21329 #[cfg(feature = "Win32_Foundation")]
21330 #[inline]
CryptGetUserKey(hprov: usize, dwkeyspec: u32, phuserkey: *mut usize) -> super::super::Foundation::BOOL21331 pub unsafe fn CryptGetUserKey(hprov: usize, dwkeyspec: u32, phuserkey: *mut usize) -> super::super::Foundation::BOOL {
21332     #[cfg(windows)]
21333     {
21334         #[link(name = "windows")]
21335         extern "system" {
21336             fn CryptGetUserKey(hprov: usize, dwkeyspec: u32, phuserkey: *mut usize) -> super::super::Foundation::BOOL;
21337         }
21338         ::std::mem::transmute(CryptGetUserKey(::std::mem::transmute(hprov), ::std::mem::transmute(dwkeyspec), ::std::mem::transmute(phuserkey)))
21339     }
21340     #[cfg(not(windows))]
21341     unimplemented!("Unsupported target OS");
21342 }
21343 #[cfg(feature = "Win32_Foundation")]
21344 #[inline]
CryptHashCertificate(hcryptprov: usize, algid: u32, dwflags: u32, pbencoded: *const u8, cbencoded: u32, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL21345 pub unsafe fn CryptHashCertificate(hcryptprov: usize, algid: u32, dwflags: u32, pbencoded: *const u8, cbencoded: u32, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL {
21346     #[cfg(windows)]
21347     {
21348         #[link(name = "windows")]
21349         extern "system" {
21350             fn CryptHashCertificate(hcryptprov: usize, algid: u32, dwflags: u32, pbencoded: *const u8, cbencoded: u32, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL;
21351         }
21352         ::std::mem::transmute(CryptHashCertificate(::std::mem::transmute(hcryptprov), ::std::mem::transmute(algid), ::std::mem::transmute(dwflags), ::std::mem::transmute(pbencoded), ::std::mem::transmute(cbencoded), ::std::mem::transmute(pbcomputedhash), ::std::mem::transmute(pcbcomputedhash)))
21353     }
21354     #[cfg(not(windows))]
21355     unimplemented!("Unsupported target OS");
21356 }
21357 #[cfg(feature = "Win32_Foundation")]
21358 #[inline]
CryptHashCertificate2<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pwszcnghashalgid: Param0, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, pbencoded: *const u8, cbencoded: u32, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL21359 pub unsafe fn CryptHashCertificate2<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pwszcnghashalgid: Param0, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, pbencoded: *const u8, cbencoded: u32, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL {
21360     #[cfg(windows)]
21361     {
21362         #[link(name = "windows")]
21363         extern "system" {
21364             fn CryptHashCertificate2(pwszcnghashalgid: super::super::Foundation::PWSTR, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, pbencoded: *const u8, cbencoded: u32, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL;
21365         }
21366         ::std::mem::transmute(CryptHashCertificate2(pwszcnghashalgid.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvreserved), ::std::mem::transmute(pbencoded), ::std::mem::transmute(cbencoded), ::std::mem::transmute(pbcomputedhash), ::std::mem::transmute(pcbcomputedhash)))
21367     }
21368     #[cfg(not(windows))]
21369     unimplemented!("Unsupported target OS");
21370 }
21371 #[cfg(feature = "Win32_Foundation")]
21372 #[inline]
CryptHashData(hhash: usize, pbdata: *const u8, dwdatalen: u32, dwflags: u32) -> super::super::Foundation::BOOL21373 pub unsafe fn CryptHashData(hhash: usize, pbdata: *const u8, dwdatalen: u32, dwflags: u32) -> super::super::Foundation::BOOL {
21374     #[cfg(windows)]
21375     {
21376         #[link(name = "windows")]
21377         extern "system" {
21378             fn CryptHashData(hhash: usize, pbdata: *const u8, dwdatalen: u32, dwflags: u32) -> super::super::Foundation::BOOL;
21379         }
21380         ::std::mem::transmute(CryptHashData(::std::mem::transmute(hhash), ::std::mem::transmute(pbdata), ::std::mem::transmute(dwdatalen), ::std::mem::transmute(dwflags)))
21381     }
21382     #[cfg(not(windows))]
21383     unimplemented!("Unsupported target OS");
21384 }
21385 #[cfg(feature = "Win32_Foundation")]
21386 #[inline]
CryptHashMessage<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(phashpara: *const CRYPT_HASH_MESSAGE_PARA, fdetachedhash: Param1, ctobehashed: u32, rgpbtobehashed: *const *const u8, rgcbtobehashed: *const u32, pbhashedblob: *mut u8, pcbhashedblob: *mut u32, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL21387 pub unsafe fn CryptHashMessage<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(phashpara: *const CRYPT_HASH_MESSAGE_PARA, fdetachedhash: Param1, ctobehashed: u32, rgpbtobehashed: *const *const u8, rgcbtobehashed: *const u32, pbhashedblob: *mut u8, pcbhashedblob: *mut u32, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL {
21388     #[cfg(windows)]
21389     {
21390         #[link(name = "windows")]
21391         extern "system" {
21392             fn CryptHashMessage(phashpara: *const CRYPT_HASH_MESSAGE_PARA, fdetachedhash: super::super::Foundation::BOOL, ctobehashed: u32, rgpbtobehashed: *const *const u8, rgcbtobehashed: *const u32, pbhashedblob: *mut u8, pcbhashedblob: *mut u32, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL;
21393         }
21394         ::std::mem::transmute(CryptHashMessage(
21395             ::std::mem::transmute(phashpara),
21396             fdetachedhash.into_param().abi(),
21397             ::std::mem::transmute(ctobehashed),
21398             ::std::mem::transmute(rgpbtobehashed),
21399             ::std::mem::transmute(rgcbtobehashed),
21400             ::std::mem::transmute(pbhashedblob),
21401             ::std::mem::transmute(pcbhashedblob),
21402             ::std::mem::transmute(pbcomputedhash),
21403             ::std::mem::transmute(pcbcomputedhash),
21404         ))
21405     }
21406     #[cfg(not(windows))]
21407     unimplemented!("Unsupported target OS");
21408 }
21409 #[cfg(feature = "Win32_Foundation")]
21410 #[inline]
CryptHashPublicKeyInfo(hcryptprov: usize, algid: u32, dwflags: u32, dwcertencodingtype: u32, pinfo: *const CERT_PUBLIC_KEY_INFO, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL21411 pub unsafe fn CryptHashPublicKeyInfo(hcryptprov: usize, algid: u32, dwflags: u32, dwcertencodingtype: u32, pinfo: *const CERT_PUBLIC_KEY_INFO, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL {
21412     #[cfg(windows)]
21413     {
21414         #[link(name = "windows")]
21415         extern "system" {
21416             fn CryptHashPublicKeyInfo(hcryptprov: usize, algid: u32, dwflags: u32, dwcertencodingtype: u32, pinfo: *const CERT_PUBLIC_KEY_INFO, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL;
21417         }
21418         ::std::mem::transmute(CryptHashPublicKeyInfo(::std::mem::transmute(hcryptprov), ::std::mem::transmute(algid), ::std::mem::transmute(dwflags), ::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(pinfo), ::std::mem::transmute(pbcomputedhash), ::std::mem::transmute(pcbcomputedhash)))
21419     }
21420     #[cfg(not(windows))]
21421     unimplemented!("Unsupported target OS");
21422 }
21423 #[cfg(feature = "Win32_Foundation")]
21424 #[inline]
CryptHashSessionKey(hhash: usize, hkey: usize, dwflags: u32) -> super::super::Foundation::BOOL21425 pub unsafe fn CryptHashSessionKey(hhash: usize, hkey: usize, dwflags: u32) -> super::super::Foundation::BOOL {
21426     #[cfg(windows)]
21427     {
21428         #[link(name = "windows")]
21429         extern "system" {
21430             fn CryptHashSessionKey(hhash: usize, hkey: usize, dwflags: u32) -> super::super::Foundation::BOOL;
21431         }
21432         ::std::mem::transmute(CryptHashSessionKey(::std::mem::transmute(hhash), ::std::mem::transmute(hkey), ::std::mem::transmute(dwflags)))
21433     }
21434     #[cfg(not(windows))]
21435     unimplemented!("Unsupported target OS");
21436 }
21437 #[cfg(feature = "Win32_Foundation")]
21438 #[inline]
CryptHashToBeSigned(hcryptprov: usize, dwcertencodingtype: u32, pbencoded: *const u8, cbencoded: u32, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL21439 pub unsafe fn CryptHashToBeSigned(hcryptprov: usize, dwcertencodingtype: u32, pbencoded: *const u8, cbencoded: u32, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL {
21440     #[cfg(windows)]
21441     {
21442         #[link(name = "windows")]
21443         extern "system" {
21444             fn CryptHashToBeSigned(hcryptprov: usize, dwcertencodingtype: u32, pbencoded: *const u8, cbencoded: u32, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL;
21445         }
21446         ::std::mem::transmute(CryptHashToBeSigned(::std::mem::transmute(hcryptprov), ::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(pbencoded), ::std::mem::transmute(cbencoded), ::std::mem::transmute(pbcomputedhash), ::std::mem::transmute(pcbcomputedhash)))
21447     }
21448     #[cfg(not(windows))]
21449     unimplemented!("Unsupported target OS");
21450 }
21451 #[cfg(feature = "Win32_Foundation")]
21452 #[inline]
CryptImportKey(hprov: usize, pbdata: *const u8, dwdatalen: u32, hpubkey: usize, dwflags: CRYPT_KEY_FLAGS, phkey: *mut usize) -> super::super::Foundation::BOOL21453 pub unsafe fn CryptImportKey(hprov: usize, pbdata: *const u8, dwdatalen: u32, hpubkey: usize, dwflags: CRYPT_KEY_FLAGS, phkey: *mut usize) -> super::super::Foundation::BOOL {
21454     #[cfg(windows)]
21455     {
21456         #[link(name = "windows")]
21457         extern "system" {
21458             fn CryptImportKey(hprov: usize, pbdata: *const u8, dwdatalen: u32, hpubkey: usize, dwflags: CRYPT_KEY_FLAGS, phkey: *mut usize) -> super::super::Foundation::BOOL;
21459         }
21460         ::std::mem::transmute(CryptImportKey(::std::mem::transmute(hprov), ::std::mem::transmute(pbdata), ::std::mem::transmute(dwdatalen), ::std::mem::transmute(hpubkey), ::std::mem::transmute(dwflags), ::std::mem::transmute(phkey)))
21461     }
21462     #[cfg(not(windows))]
21463     unimplemented!("Unsupported target OS");
21464 }
21465 #[cfg(feature = "Win32_Foundation")]
21466 #[inline]
CryptImportPKCS8<'a, Param0: ::windows::runtime::IntoParam<'a, CRYPT_PKCS8_IMPORT_PARAMS>>(sprivatekeyandparams: Param0, dwflags: CRYPT_KEY_FLAGS, phcryptprov: *mut usize, pvauxinfo: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL21467 pub unsafe fn CryptImportPKCS8<'a, Param0: ::windows::runtime::IntoParam<'a, CRYPT_PKCS8_IMPORT_PARAMS>>(sprivatekeyandparams: Param0, dwflags: CRYPT_KEY_FLAGS, phcryptprov: *mut usize, pvauxinfo: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL {
21468     #[cfg(windows)]
21469     {
21470         #[link(name = "windows")]
21471         extern "system" {
21472             fn CryptImportPKCS8(sprivatekeyandparams: ::std::mem::ManuallyDrop<CRYPT_PKCS8_IMPORT_PARAMS>, dwflags: CRYPT_KEY_FLAGS, phcryptprov: *mut usize, pvauxinfo: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
21473         }
21474         ::std::mem::transmute(CryptImportPKCS8(sprivatekeyandparams.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(phcryptprov), ::std::mem::transmute(pvauxinfo)))
21475     }
21476     #[cfg(not(windows))]
21477     unimplemented!("Unsupported target OS");
21478 }
21479 #[cfg(feature = "Win32_Foundation")]
21480 #[inline]
CryptImportPublicKeyInfo(hcryptprov: usize, dwcertencodingtype: u32, pinfo: *const CERT_PUBLIC_KEY_INFO, phkey: *mut usize) -> super::super::Foundation::BOOL21481 pub unsafe fn CryptImportPublicKeyInfo(hcryptprov: usize, dwcertencodingtype: u32, pinfo: *const CERT_PUBLIC_KEY_INFO, phkey: *mut usize) -> super::super::Foundation::BOOL {
21482     #[cfg(windows)]
21483     {
21484         #[link(name = "windows")]
21485         extern "system" {
21486             fn CryptImportPublicKeyInfo(hcryptprov: usize, dwcertencodingtype: u32, pinfo: *const CERT_PUBLIC_KEY_INFO, phkey: *mut usize) -> super::super::Foundation::BOOL;
21487         }
21488         ::std::mem::transmute(CryptImportPublicKeyInfo(::std::mem::transmute(hcryptprov), ::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(pinfo), ::std::mem::transmute(phkey)))
21489     }
21490     #[cfg(not(windows))]
21491     unimplemented!("Unsupported target OS");
21492 }
21493 #[cfg(feature = "Win32_Foundation")]
21494 #[inline]
CryptImportPublicKeyInfoEx(hcryptprov: usize, dwcertencodingtype: u32, pinfo: *const CERT_PUBLIC_KEY_INFO, aikeyalg: u32, dwflags: u32, pvauxinfo: *const ::std::ffi::c_void, phkey: *mut usize) -> super::super::Foundation::BOOL21495 pub unsafe fn CryptImportPublicKeyInfoEx(hcryptprov: usize, dwcertencodingtype: u32, pinfo: *const CERT_PUBLIC_KEY_INFO, aikeyalg: u32, dwflags: u32, pvauxinfo: *const ::std::ffi::c_void, phkey: *mut usize) -> super::super::Foundation::BOOL {
21496     #[cfg(windows)]
21497     {
21498         #[link(name = "windows")]
21499         extern "system" {
21500             fn CryptImportPublicKeyInfoEx(hcryptprov: usize, dwcertencodingtype: u32, pinfo: *const CERT_PUBLIC_KEY_INFO, aikeyalg: u32, dwflags: u32, pvauxinfo: *const ::std::ffi::c_void, phkey: *mut usize) -> super::super::Foundation::BOOL;
21501         }
21502         ::std::mem::transmute(CryptImportPublicKeyInfoEx(::std::mem::transmute(hcryptprov), ::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(pinfo), ::std::mem::transmute(aikeyalg), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvauxinfo), ::std::mem::transmute(phkey)))
21503     }
21504     #[cfg(not(windows))]
21505     unimplemented!("Unsupported target OS");
21506 }
21507 #[cfg(feature = "Win32_Foundation")]
21508 #[inline]
CryptImportPublicKeyInfoEx2(dwcertencodingtype: u32, pinfo: *const CERT_PUBLIC_KEY_INFO, dwflags: CRYPT_IMPORT_PUBLIC_KEY_FLAGS, pvauxinfo: *const ::std::ffi::c_void, phkey: *mut BCRYPT_KEY_HANDLE) -> super::super::Foundation::BOOL21509 pub unsafe fn CryptImportPublicKeyInfoEx2(dwcertencodingtype: u32, pinfo: *const CERT_PUBLIC_KEY_INFO, dwflags: CRYPT_IMPORT_PUBLIC_KEY_FLAGS, pvauxinfo: *const ::std::ffi::c_void, phkey: *mut BCRYPT_KEY_HANDLE) -> super::super::Foundation::BOOL {
21510     #[cfg(windows)]
21511     {
21512         #[link(name = "windows")]
21513         extern "system" {
21514             fn CryptImportPublicKeyInfoEx2(dwcertencodingtype: u32, pinfo: *const CERT_PUBLIC_KEY_INFO, dwflags: CRYPT_IMPORT_PUBLIC_KEY_FLAGS, pvauxinfo: *const ::std::ffi::c_void, phkey: *mut BCRYPT_KEY_HANDLE) -> super::super::Foundation::BOOL;
21515         }
21516         ::std::mem::transmute(CryptImportPublicKeyInfoEx2(::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(pinfo), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvauxinfo), ::std::mem::transmute(phkey)))
21517     }
21518     #[cfg(not(windows))]
21519     unimplemented!("Unsupported target OS");
21520 }
21521 #[cfg(feature = "Win32_Foundation")]
21522 #[inline]
CryptInitOIDFunctionSet<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszfuncname: Param0, dwflags: u32) -> *mut ::std::ffi::c_void21523 pub unsafe fn CryptInitOIDFunctionSet<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszfuncname: Param0, dwflags: u32) -> *mut ::std::ffi::c_void {
21524     #[cfg(windows)]
21525     {
21526         #[link(name = "windows")]
21527         extern "system" {
21528             fn CryptInitOIDFunctionSet(pszfuncname: super::super::Foundation::PSTR, dwflags: u32) -> *mut ::std::ffi::c_void;
21529         }
21530         ::std::mem::transmute(CryptInitOIDFunctionSet(pszfuncname.into_param().abi(), ::std::mem::transmute(dwflags)))
21531     }
21532     #[cfg(not(windows))]
21533     unimplemented!("Unsupported target OS");
21534 }
21535 #[cfg(feature = "Win32_Foundation")]
21536 #[inline]
CryptInstallCancelRetrieval(pfncancel: ::std::option::Option<PFN_CRYPT_CANCEL_RETRIEVAL>, pvarg: *const ::std::ffi::c_void, dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL21537 pub unsafe fn CryptInstallCancelRetrieval(pfncancel: ::std::option::Option<PFN_CRYPT_CANCEL_RETRIEVAL>, pvarg: *const ::std::ffi::c_void, dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
21538     #[cfg(windows)]
21539     {
21540         #[link(name = "windows")]
21541         extern "system" {
21542             fn CryptInstallCancelRetrieval(pfncancel: ::windows::runtime::RawPtr, pvarg: *const ::std::ffi::c_void, dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
21543         }
21544         ::std::mem::transmute(CryptInstallCancelRetrieval(::std::mem::transmute(pfncancel), ::std::mem::transmute(pvarg), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvreserved)))
21545     }
21546     #[cfg(not(windows))]
21547     unimplemented!("Unsupported target OS");
21548 }
21549 #[cfg(feature = "Win32_Foundation")]
21550 #[inline]
CryptInstallDefaultContext(hcryptprov: usize, dwdefaulttype: CRYPT_DEFAULT_CONTEXT_TYPE, pvdefaultpara: *const ::std::ffi::c_void, dwflags: CRYPT_DEFAULT_CONTEXT_FLAGS, pvreserved: *mut ::std::ffi::c_void, phdefaultcontext: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL21551 pub unsafe fn CryptInstallDefaultContext(hcryptprov: usize, dwdefaulttype: CRYPT_DEFAULT_CONTEXT_TYPE, pvdefaultpara: *const ::std::ffi::c_void, dwflags: CRYPT_DEFAULT_CONTEXT_FLAGS, pvreserved: *mut ::std::ffi::c_void, phdefaultcontext: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
21552     #[cfg(windows)]
21553     {
21554         #[link(name = "windows")]
21555         extern "system" {
21556             fn CryptInstallDefaultContext(hcryptprov: usize, dwdefaulttype: CRYPT_DEFAULT_CONTEXT_TYPE, pvdefaultpara: *const ::std::ffi::c_void, dwflags: CRYPT_DEFAULT_CONTEXT_FLAGS, pvreserved: *mut ::std::ffi::c_void, phdefaultcontext: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
21557         }
21558         ::std::mem::transmute(CryptInstallDefaultContext(::std::mem::transmute(hcryptprov), ::std::mem::transmute(dwdefaulttype), ::std::mem::transmute(pvdefaultpara), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvreserved), ::std::mem::transmute(phdefaultcontext)))
21559     }
21560     #[cfg(not(windows))]
21561     unimplemented!("Unsupported target OS");
21562 }
21563 #[cfg(feature = "Win32_Foundation")]
21564 #[inline]
CryptInstallOIDFunctionAddress<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HINSTANCE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hmodule: Param0, dwencodingtype: u32, pszfuncname: Param2, cfuncentry: u32, rgfuncentry: *const CRYPT_OID_FUNC_ENTRY, dwflags: u32) -> super::super::Foundation::BOOL21565 pub unsafe fn CryptInstallOIDFunctionAddress<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HINSTANCE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hmodule: Param0, dwencodingtype: u32, pszfuncname: Param2, cfuncentry: u32, rgfuncentry: *const CRYPT_OID_FUNC_ENTRY, dwflags: u32) -> super::super::Foundation::BOOL {
21566     #[cfg(windows)]
21567     {
21568         #[link(name = "windows")]
21569         extern "system" {
21570             fn CryptInstallOIDFunctionAddress(hmodule: super::super::Foundation::HINSTANCE, dwencodingtype: u32, pszfuncname: super::super::Foundation::PSTR, cfuncentry: u32, rgfuncentry: *const CRYPT_OID_FUNC_ENTRY, dwflags: u32) -> super::super::Foundation::BOOL;
21571         }
21572         ::std::mem::transmute(CryptInstallOIDFunctionAddress(hmodule.into_param().abi(), ::std::mem::transmute(dwencodingtype), pszfuncname.into_param().abi(), ::std::mem::transmute(cfuncentry), ::std::mem::transmute(rgfuncentry), ::std::mem::transmute(dwflags)))
21573     }
21574     #[cfg(not(windows))]
21575     unimplemented!("Unsupported target OS");
21576 }
21577 #[inline]
CryptMemAlloc(cbsize: u32) -> *mut ::std::ffi::c_void21578 pub unsafe fn CryptMemAlloc(cbsize: u32) -> *mut ::std::ffi::c_void {
21579     #[cfg(windows)]
21580     {
21581         #[link(name = "windows")]
21582         extern "system" {
21583             fn CryptMemAlloc(cbsize: u32) -> *mut ::std::ffi::c_void;
21584         }
21585         ::std::mem::transmute(CryptMemAlloc(::std::mem::transmute(cbsize)))
21586     }
21587     #[cfg(not(windows))]
21588     unimplemented!("Unsupported target OS");
21589 }
21590 #[inline]
CryptMemFree(pv: *const ::std::ffi::c_void)21591 pub unsafe fn CryptMemFree(pv: *const ::std::ffi::c_void) {
21592     #[cfg(windows)]
21593     {
21594         #[link(name = "windows")]
21595         extern "system" {
21596             fn CryptMemFree(pv: *const ::std::ffi::c_void);
21597         }
21598         ::std::mem::transmute(CryptMemFree(::std::mem::transmute(pv)))
21599     }
21600     #[cfg(not(windows))]
21601     unimplemented!("Unsupported target OS");
21602 }
21603 #[inline]
CryptMemRealloc(pv: *const ::std::ffi::c_void, cbsize: u32) -> *mut ::std::ffi::c_void21604 pub unsafe fn CryptMemRealloc(pv: *const ::std::ffi::c_void, cbsize: u32) -> *mut ::std::ffi::c_void {
21605     #[cfg(windows)]
21606     {
21607         #[link(name = "windows")]
21608         extern "system" {
21609             fn CryptMemRealloc(pv: *const ::std::ffi::c_void, cbsize: u32) -> *mut ::std::ffi::c_void;
21610         }
21611         ::std::mem::transmute(CryptMemRealloc(::std::mem::transmute(pv), ::std::mem::transmute(cbsize)))
21612     }
21613     #[cfg(not(windows))]
21614     unimplemented!("Unsupported target OS");
21615 }
21616 #[cfg(feature = "Win32_Foundation")]
21617 #[inline]
CryptMsgCalculateEncodedLength<'a, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwmsgencodingtype: u32, dwflags: u32, dwmsgtype: u32, pvmsgencodeinfo: *const ::std::ffi::c_void, pszinnercontentobjid: Param4, cbdata: u32) -> u3221618 pub unsafe fn CryptMsgCalculateEncodedLength<'a, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwmsgencodingtype: u32, dwflags: u32, dwmsgtype: u32, pvmsgencodeinfo: *const ::std::ffi::c_void, pszinnercontentobjid: Param4, cbdata: u32) -> u32 {
21619     #[cfg(windows)]
21620     {
21621         #[link(name = "windows")]
21622         extern "system" {
21623             fn CryptMsgCalculateEncodedLength(dwmsgencodingtype: u32, dwflags: u32, dwmsgtype: u32, pvmsgencodeinfo: *const ::std::ffi::c_void, pszinnercontentobjid: super::super::Foundation::PSTR, cbdata: u32) -> u32;
21624         }
21625         ::std::mem::transmute(CryptMsgCalculateEncodedLength(::std::mem::transmute(dwmsgencodingtype), ::std::mem::transmute(dwflags), ::std::mem::transmute(dwmsgtype), ::std::mem::transmute(pvmsgencodeinfo), pszinnercontentobjid.into_param().abi(), ::std::mem::transmute(cbdata)))
21626     }
21627     #[cfg(not(windows))]
21628     unimplemented!("Unsupported target OS");
21629 }
21630 #[cfg(feature = "Win32_Foundation")]
21631 #[inline]
CryptMsgClose(hcryptmsg: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL21632 pub unsafe fn CryptMsgClose(hcryptmsg: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL {
21633     #[cfg(windows)]
21634     {
21635         #[link(name = "windows")]
21636         extern "system" {
21637             fn CryptMsgClose(hcryptmsg: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
21638         }
21639         ::std::mem::transmute(CryptMsgClose(::std::mem::transmute(hcryptmsg)))
21640     }
21641     #[cfg(not(windows))]
21642     unimplemented!("Unsupported target OS");
21643 }
21644 #[cfg(feature = "Win32_Foundation")]
21645 #[inline]
CryptMsgControl(hcryptmsg: *const ::std::ffi::c_void, dwflags: u32, dwctrltype: u32, pvctrlpara: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL21646 pub unsafe fn CryptMsgControl(hcryptmsg: *const ::std::ffi::c_void, dwflags: u32, dwctrltype: u32, pvctrlpara: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL {
21647     #[cfg(windows)]
21648     {
21649         #[link(name = "windows")]
21650         extern "system" {
21651             fn CryptMsgControl(hcryptmsg: *const ::std::ffi::c_void, dwflags: u32, dwctrltype: u32, pvctrlpara: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
21652         }
21653         ::std::mem::transmute(CryptMsgControl(::std::mem::transmute(hcryptmsg), ::std::mem::transmute(dwflags), ::std::mem::transmute(dwctrltype), ::std::mem::transmute(pvctrlpara)))
21654     }
21655     #[cfg(not(windows))]
21656     unimplemented!("Unsupported target OS");
21657 }
21658 #[cfg(feature = "Win32_Foundation")]
21659 #[inline]
CryptMsgCountersign(hcryptmsg: *const ::std::ffi::c_void, dwindex: u32, ccountersigners: u32, rgcountersigners: *const CMSG_SIGNER_ENCODE_INFO) -> super::super::Foundation::BOOL21660 pub unsafe fn CryptMsgCountersign(hcryptmsg: *const ::std::ffi::c_void, dwindex: u32, ccountersigners: u32, rgcountersigners: *const CMSG_SIGNER_ENCODE_INFO) -> super::super::Foundation::BOOL {
21661     #[cfg(windows)]
21662     {
21663         #[link(name = "windows")]
21664         extern "system" {
21665             fn CryptMsgCountersign(hcryptmsg: *const ::std::ffi::c_void, dwindex: u32, ccountersigners: u32, rgcountersigners: *const CMSG_SIGNER_ENCODE_INFO) -> super::super::Foundation::BOOL;
21666         }
21667         ::std::mem::transmute(CryptMsgCountersign(::std::mem::transmute(hcryptmsg), ::std::mem::transmute(dwindex), ::std::mem::transmute(ccountersigners), ::std::mem::transmute(rgcountersigners)))
21668     }
21669     #[cfg(not(windows))]
21670     unimplemented!("Unsupported target OS");
21671 }
21672 #[cfg(feature = "Win32_Foundation")]
21673 #[inline]
CryptMsgCountersignEncoded(dwencodingtype: u32, pbsignerinfo: *const u8, cbsignerinfo: u32, ccountersigners: u32, rgcountersigners: *const CMSG_SIGNER_ENCODE_INFO, pbcountersignature: *mut u8, pcbcountersignature: *mut u32) -> super::super::Foundation::BOOL21674 pub unsafe fn CryptMsgCountersignEncoded(dwencodingtype: u32, pbsignerinfo: *const u8, cbsignerinfo: u32, ccountersigners: u32, rgcountersigners: *const CMSG_SIGNER_ENCODE_INFO, pbcountersignature: *mut u8, pcbcountersignature: *mut u32) -> super::super::Foundation::BOOL {
21675     #[cfg(windows)]
21676     {
21677         #[link(name = "windows")]
21678         extern "system" {
21679             fn CryptMsgCountersignEncoded(dwencodingtype: u32, pbsignerinfo: *const u8, cbsignerinfo: u32, ccountersigners: u32, rgcountersigners: *const CMSG_SIGNER_ENCODE_INFO, pbcountersignature: *mut u8, pcbcountersignature: *mut u32) -> super::super::Foundation::BOOL;
21680         }
21681         ::std::mem::transmute(CryptMsgCountersignEncoded(
21682             ::std::mem::transmute(dwencodingtype),
21683             ::std::mem::transmute(pbsignerinfo),
21684             ::std::mem::transmute(cbsignerinfo),
21685             ::std::mem::transmute(ccountersigners),
21686             ::std::mem::transmute(rgcountersigners),
21687             ::std::mem::transmute(pbcountersignature),
21688             ::std::mem::transmute(pcbcountersignature),
21689         ))
21690     }
21691     #[cfg(not(windows))]
21692     unimplemented!("Unsupported target OS");
21693 }
21694 #[inline]
CryptMsgDuplicate(hcryptmsg: *const ::std::ffi::c_void) -> *mut ::std::ffi::c_void21695 pub unsafe fn CryptMsgDuplicate(hcryptmsg: *const ::std::ffi::c_void) -> *mut ::std::ffi::c_void {
21696     #[cfg(windows)]
21697     {
21698         #[link(name = "windows")]
21699         extern "system" {
21700             fn CryptMsgDuplicate(hcryptmsg: *const ::std::ffi::c_void) -> *mut ::std::ffi::c_void;
21701         }
21702         ::std::mem::transmute(CryptMsgDuplicate(::std::mem::transmute(hcryptmsg)))
21703     }
21704     #[cfg(not(windows))]
21705     unimplemented!("Unsupported target OS");
21706 }
21707 #[cfg(feature = "Win32_Foundation")]
21708 #[inline]
CryptMsgEncodeAndSignCTL(dwmsgencodingtype: u32, pctlinfo: *const CTL_INFO, psigninfo: *const CMSG_SIGNED_ENCODE_INFO, dwflags: u32, pbencoded: *mut u8, pcbencoded: *mut u32) -> super::super::Foundation::BOOL21709 pub unsafe fn CryptMsgEncodeAndSignCTL(dwmsgencodingtype: u32, pctlinfo: *const CTL_INFO, psigninfo: *const CMSG_SIGNED_ENCODE_INFO, dwflags: u32, pbencoded: *mut u8, pcbencoded: *mut u32) -> super::super::Foundation::BOOL {
21710     #[cfg(windows)]
21711     {
21712         #[link(name = "windows")]
21713         extern "system" {
21714             fn CryptMsgEncodeAndSignCTL(dwmsgencodingtype: u32, pctlinfo: *const CTL_INFO, psigninfo: *const CMSG_SIGNED_ENCODE_INFO, dwflags: u32, pbencoded: *mut u8, pcbencoded: *mut u32) -> super::super::Foundation::BOOL;
21715         }
21716         ::std::mem::transmute(CryptMsgEncodeAndSignCTL(::std::mem::transmute(dwmsgencodingtype), ::std::mem::transmute(pctlinfo), ::std::mem::transmute(psigninfo), ::std::mem::transmute(dwflags), ::std::mem::transmute(pbencoded), ::std::mem::transmute(pcbencoded)))
21717     }
21718     #[cfg(not(windows))]
21719     unimplemented!("Unsupported target OS");
21720 }
21721 #[cfg(feature = "Win32_Foundation")]
21722 #[inline]
CryptMsgGetAndVerifySigner(hcryptmsg: *const ::std::ffi::c_void, csignerstore: u32, rghsignerstore: *const *const ::std::ffi::c_void, dwflags: u32, ppsigner: *mut *mut CERT_CONTEXT, pdwsignerindex: *mut u32) -> super::super::Foundation::BOOL21723 pub unsafe fn CryptMsgGetAndVerifySigner(hcryptmsg: *const ::std::ffi::c_void, csignerstore: u32, rghsignerstore: *const *const ::std::ffi::c_void, dwflags: u32, ppsigner: *mut *mut CERT_CONTEXT, pdwsignerindex: *mut u32) -> super::super::Foundation::BOOL {
21724     #[cfg(windows)]
21725     {
21726         #[link(name = "windows")]
21727         extern "system" {
21728             fn CryptMsgGetAndVerifySigner(hcryptmsg: *const ::std::ffi::c_void, csignerstore: u32, rghsignerstore: *const *const ::std::ffi::c_void, dwflags: u32, ppsigner: *mut *mut CERT_CONTEXT, pdwsignerindex: *mut u32) -> super::super::Foundation::BOOL;
21729         }
21730         ::std::mem::transmute(CryptMsgGetAndVerifySigner(::std::mem::transmute(hcryptmsg), ::std::mem::transmute(csignerstore), ::std::mem::transmute(rghsignerstore), ::std::mem::transmute(dwflags), ::std::mem::transmute(ppsigner), ::std::mem::transmute(pdwsignerindex)))
21731     }
21732     #[cfg(not(windows))]
21733     unimplemented!("Unsupported target OS");
21734 }
21735 #[cfg(feature = "Win32_Foundation")]
21736 #[inline]
CryptMsgGetParam(hcryptmsg: *const ::std::ffi::c_void, dwparamtype: u32, dwindex: u32, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL21737 pub unsafe fn CryptMsgGetParam(hcryptmsg: *const ::std::ffi::c_void, dwparamtype: u32, dwindex: u32, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL {
21738     #[cfg(windows)]
21739     {
21740         #[link(name = "windows")]
21741         extern "system" {
21742             fn CryptMsgGetParam(hcryptmsg: *const ::std::ffi::c_void, dwparamtype: u32, dwindex: u32, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL;
21743         }
21744         ::std::mem::transmute(CryptMsgGetParam(::std::mem::transmute(hcryptmsg), ::std::mem::transmute(dwparamtype), ::std::mem::transmute(dwindex), ::std::mem::transmute(pvdata), ::std::mem::transmute(pcbdata)))
21745     }
21746     #[cfg(not(windows))]
21747     unimplemented!("Unsupported target OS");
21748 }
21749 #[cfg(feature = "Win32_Foundation")]
21750 #[inline]
CryptMsgOpenToDecode(dwmsgencodingtype: u32, dwflags: u32, dwmsgtype: u32, hcryptprov: usize, precipientinfo: *mut CERT_INFO, pstreaminfo: *const CMSG_STREAM_INFO) -> *mut ::std::ffi::c_void21751 pub unsafe fn CryptMsgOpenToDecode(dwmsgencodingtype: u32, dwflags: u32, dwmsgtype: u32, hcryptprov: usize, precipientinfo: *mut CERT_INFO, pstreaminfo: *const CMSG_STREAM_INFO) -> *mut ::std::ffi::c_void {
21752     #[cfg(windows)]
21753     {
21754         #[link(name = "windows")]
21755         extern "system" {
21756             fn CryptMsgOpenToDecode(dwmsgencodingtype: u32, dwflags: u32, dwmsgtype: u32, hcryptprov: usize, precipientinfo: *mut CERT_INFO, pstreaminfo: *const ::std::mem::ManuallyDrop<CMSG_STREAM_INFO>) -> *mut ::std::ffi::c_void;
21757         }
21758         ::std::mem::transmute(CryptMsgOpenToDecode(::std::mem::transmute(dwmsgencodingtype), ::std::mem::transmute(dwflags), ::std::mem::transmute(dwmsgtype), ::std::mem::transmute(hcryptprov), ::std::mem::transmute(precipientinfo), ::std::mem::transmute(pstreaminfo)))
21759     }
21760     #[cfg(not(windows))]
21761     unimplemented!("Unsupported target OS");
21762 }
21763 #[cfg(feature = "Win32_Foundation")]
21764 #[inline]
CryptMsgOpenToEncode<'a, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwmsgencodingtype: u32, dwflags: u32, dwmsgtype: CRYPT_MSG_TYPE, pvmsgencodeinfo: *const ::std::ffi::c_void, pszinnercontentobjid: Param4, pstreaminfo: *const CMSG_STREAM_INFO) -> *mut ::std::ffi::c_void21765 pub unsafe fn CryptMsgOpenToEncode<'a, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwmsgencodingtype: u32, dwflags: u32, dwmsgtype: CRYPT_MSG_TYPE, pvmsgencodeinfo: *const ::std::ffi::c_void, pszinnercontentobjid: Param4, pstreaminfo: *const CMSG_STREAM_INFO) -> *mut ::std::ffi::c_void {
21766     #[cfg(windows)]
21767     {
21768         #[link(name = "windows")]
21769         extern "system" {
21770             fn CryptMsgOpenToEncode(dwmsgencodingtype: u32, dwflags: u32, dwmsgtype: CRYPT_MSG_TYPE, pvmsgencodeinfo: *const ::std::ffi::c_void, pszinnercontentobjid: super::super::Foundation::PSTR, pstreaminfo: *const ::std::mem::ManuallyDrop<CMSG_STREAM_INFO>) -> *mut ::std::ffi::c_void;
21771         }
21772         ::std::mem::transmute(CryptMsgOpenToEncode(::std::mem::transmute(dwmsgencodingtype), ::std::mem::transmute(dwflags), ::std::mem::transmute(dwmsgtype), ::std::mem::transmute(pvmsgencodeinfo), pszinnercontentobjid.into_param().abi(), ::std::mem::transmute(pstreaminfo)))
21773     }
21774     #[cfg(not(windows))]
21775     unimplemented!("Unsupported target OS");
21776 }
21777 #[cfg(feature = "Win32_Foundation")]
21778 #[inline]
CryptMsgSignCTL(dwmsgencodingtype: u32, pbctlcontent: *const u8, cbctlcontent: u32, psigninfo: *const CMSG_SIGNED_ENCODE_INFO, dwflags: u32, pbencoded: *mut u8, pcbencoded: *mut u32) -> super::super::Foundation::BOOL21779 pub unsafe fn CryptMsgSignCTL(dwmsgencodingtype: u32, pbctlcontent: *const u8, cbctlcontent: u32, psigninfo: *const CMSG_SIGNED_ENCODE_INFO, dwflags: u32, pbencoded: *mut u8, pcbencoded: *mut u32) -> super::super::Foundation::BOOL {
21780     #[cfg(windows)]
21781     {
21782         #[link(name = "windows")]
21783         extern "system" {
21784             fn CryptMsgSignCTL(dwmsgencodingtype: u32, pbctlcontent: *const u8, cbctlcontent: u32, psigninfo: *const CMSG_SIGNED_ENCODE_INFO, dwflags: u32, pbencoded: *mut u8, pcbencoded: *mut u32) -> super::super::Foundation::BOOL;
21785         }
21786         ::std::mem::transmute(CryptMsgSignCTL(::std::mem::transmute(dwmsgencodingtype), ::std::mem::transmute(pbctlcontent), ::std::mem::transmute(cbctlcontent), ::std::mem::transmute(psigninfo), ::std::mem::transmute(dwflags), ::std::mem::transmute(pbencoded), ::std::mem::transmute(pcbencoded)))
21787     }
21788     #[cfg(not(windows))]
21789     unimplemented!("Unsupported target OS");
21790 }
21791 #[cfg(feature = "Win32_Foundation")]
21792 #[inline]
CryptMsgUpdate<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hcryptmsg: *const ::std::ffi::c_void, pbdata: *const u8, cbdata: u32, ffinal: Param3) -> super::super::Foundation::BOOL21793 pub unsafe fn CryptMsgUpdate<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hcryptmsg: *const ::std::ffi::c_void, pbdata: *const u8, cbdata: u32, ffinal: Param3) -> super::super::Foundation::BOOL {
21794     #[cfg(windows)]
21795     {
21796         #[link(name = "windows")]
21797         extern "system" {
21798             fn CryptMsgUpdate(hcryptmsg: *const ::std::ffi::c_void, pbdata: *const u8, cbdata: u32, ffinal: super::super::Foundation::BOOL) -> super::super::Foundation::BOOL;
21799         }
21800         ::std::mem::transmute(CryptMsgUpdate(::std::mem::transmute(hcryptmsg), ::std::mem::transmute(pbdata), ::std::mem::transmute(cbdata), ffinal.into_param().abi()))
21801     }
21802     #[cfg(not(windows))]
21803     unimplemented!("Unsupported target OS");
21804 }
21805 #[cfg(feature = "Win32_Foundation")]
21806 #[inline]
CryptMsgVerifyCountersignatureEncoded(hcryptprov: usize, dwencodingtype: u32, pbsignerinfo: *const u8, cbsignerinfo: u32, pbsignerinfocountersignature: *const u8, cbsignerinfocountersignature: u32, pcicountersigner: *const CERT_INFO) -> super::super::Foundation::BOOL21807 pub unsafe fn CryptMsgVerifyCountersignatureEncoded(hcryptprov: usize, dwencodingtype: u32, pbsignerinfo: *const u8, cbsignerinfo: u32, pbsignerinfocountersignature: *const u8, cbsignerinfocountersignature: u32, pcicountersigner: *const CERT_INFO) -> super::super::Foundation::BOOL {
21808     #[cfg(windows)]
21809     {
21810         #[link(name = "windows")]
21811         extern "system" {
21812             fn CryptMsgVerifyCountersignatureEncoded(hcryptprov: usize, dwencodingtype: u32, pbsignerinfo: *const u8, cbsignerinfo: u32, pbsignerinfocountersignature: *const u8, cbsignerinfocountersignature: u32, pcicountersigner: *const CERT_INFO) -> super::super::Foundation::BOOL;
21813         }
21814         ::std::mem::transmute(CryptMsgVerifyCountersignatureEncoded(
21815             ::std::mem::transmute(hcryptprov),
21816             ::std::mem::transmute(dwencodingtype),
21817             ::std::mem::transmute(pbsignerinfo),
21818             ::std::mem::transmute(cbsignerinfo),
21819             ::std::mem::transmute(pbsignerinfocountersignature),
21820             ::std::mem::transmute(cbsignerinfocountersignature),
21821             ::std::mem::transmute(pcicountersigner),
21822         ))
21823     }
21824     #[cfg(not(windows))]
21825     unimplemented!("Unsupported target OS");
21826 }
21827 #[cfg(feature = "Win32_Foundation")]
21828 #[inline]
CryptMsgVerifyCountersignatureEncodedEx(hcryptprov: usize, dwencodingtype: u32, pbsignerinfo: *const u8, cbsignerinfo: u32, pbsignerinfocountersignature: *const u8, cbsignerinfocountersignature: u32, dwsignertype: u32, pvsigner: *const ::std::ffi::c_void, dwflags: u32, pvextra: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL21829 pub unsafe fn CryptMsgVerifyCountersignatureEncodedEx(hcryptprov: usize, dwencodingtype: u32, pbsignerinfo: *const u8, cbsignerinfo: u32, pbsignerinfocountersignature: *const u8, cbsignerinfocountersignature: u32, dwsignertype: u32, pvsigner: *const ::std::ffi::c_void, dwflags: u32, pvextra: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
21830     #[cfg(windows)]
21831     {
21832         #[link(name = "windows")]
21833         extern "system" {
21834             fn CryptMsgVerifyCountersignatureEncodedEx(hcryptprov: usize, dwencodingtype: u32, pbsignerinfo: *const u8, cbsignerinfo: u32, pbsignerinfocountersignature: *const u8, cbsignerinfocountersignature: u32, dwsignertype: u32, pvsigner: *const ::std::ffi::c_void, dwflags: u32, pvextra: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
21835         }
21836         ::std::mem::transmute(CryptMsgVerifyCountersignatureEncodedEx(
21837             ::std::mem::transmute(hcryptprov),
21838             ::std::mem::transmute(dwencodingtype),
21839             ::std::mem::transmute(pbsignerinfo),
21840             ::std::mem::transmute(cbsignerinfo),
21841             ::std::mem::transmute(pbsignerinfocountersignature),
21842             ::std::mem::transmute(cbsignerinfocountersignature),
21843             ::std::mem::transmute(dwsignertype),
21844             ::std::mem::transmute(pvsigner),
21845             ::std::mem::transmute(dwflags),
21846             ::std::mem::transmute(pvextra),
21847         ))
21848     }
21849     #[cfg(not(windows))]
21850     unimplemented!("Unsupported target OS");
21851 }
21852 #[cfg(feature = "Win32_Foundation")]
21853 #[inline]
CryptProtectData<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pdatain: *const CRYPTOAPI_BLOB, szdatadescr: Param1, poptionalentropy: *const CRYPTOAPI_BLOB, pvreserved: *mut ::std::ffi::c_void, ppromptstruct: *const CRYPTPROTECT_PROMPTSTRUCT, dwflags: u32, pdataout: *mut CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL21854 pub unsafe fn CryptProtectData<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pdatain: *const CRYPTOAPI_BLOB, szdatadescr: Param1, poptionalentropy: *const CRYPTOAPI_BLOB, pvreserved: *mut ::std::ffi::c_void, ppromptstruct: *const CRYPTPROTECT_PROMPTSTRUCT, dwflags: u32, pdataout: *mut CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL {
21855     #[cfg(windows)]
21856     {
21857         #[link(name = "windows")]
21858         extern "system" {
21859             fn CryptProtectData(pdatain: *const CRYPTOAPI_BLOB, szdatadescr: super::super::Foundation::PWSTR, poptionalentropy: *const CRYPTOAPI_BLOB, pvreserved: *mut ::std::ffi::c_void, ppromptstruct: *const CRYPTPROTECT_PROMPTSTRUCT, dwflags: u32, pdataout: *mut CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL;
21860         }
21861         ::std::mem::transmute(CryptProtectData(::std::mem::transmute(pdatain), szdatadescr.into_param().abi(), ::std::mem::transmute(poptionalentropy), ::std::mem::transmute(pvreserved), ::std::mem::transmute(ppromptstruct), ::std::mem::transmute(dwflags), ::std::mem::transmute(pdataout)))
21862     }
21863     #[cfg(not(windows))]
21864     unimplemented!("Unsupported target OS");
21865 }
21866 #[cfg(feature = "Win32_Foundation")]
21867 #[inline]
CryptProtectMemory(pdatain: *mut ::std::ffi::c_void, cbdatain: u32, dwflags: u32) -> super::super::Foundation::BOOL21868 pub unsafe fn CryptProtectMemory(pdatain: *mut ::std::ffi::c_void, cbdatain: u32, dwflags: u32) -> super::super::Foundation::BOOL {
21869     #[cfg(windows)]
21870     {
21871         #[link(name = "windows")]
21872         extern "system" {
21873             fn CryptProtectMemory(pdatain: *mut ::std::ffi::c_void, cbdatain: u32, dwflags: u32) -> super::super::Foundation::BOOL;
21874         }
21875         ::std::mem::transmute(CryptProtectMemory(::std::mem::transmute(pdatain), ::std::mem::transmute(cbdatain), ::std::mem::transmute(dwflags)))
21876     }
21877     #[cfg(not(windows))]
21878     unimplemented!("Unsupported target OS");
21879 }
21880 #[cfg(feature = "Win32_Foundation")]
21881 #[inline]
CryptQueryObject( dwobjecttype: CERT_QUERY_OBJECT_TYPE, pvobject: *const ::std::ffi::c_void, dwexpectedcontenttypeflags: CERT_QUERY_CONTENT_TYPE_FLAGS, dwexpectedformattypeflags: CERT_QUERY_FORMAT_TYPE_FLAGS, dwflags: u32, pdwmsgandcertencodingtype: *mut CERT_QUERY_ENCODING_TYPE, pdwcontenttype: *mut CERT_QUERY_CONTENT_TYPE, pdwformattype: *mut CERT_QUERY_FORMAT_TYPE, phcertstore: *mut *mut ::std::ffi::c_void, phmsg: *mut *mut ::std::ffi::c_void, ppvcontext: *mut *mut ::std::ffi::c_void, ) -> super::super::Foundation::BOOL21882 pub unsafe fn CryptQueryObject(
21883     dwobjecttype: CERT_QUERY_OBJECT_TYPE,
21884     pvobject: *const ::std::ffi::c_void,
21885     dwexpectedcontenttypeflags: CERT_QUERY_CONTENT_TYPE_FLAGS,
21886     dwexpectedformattypeflags: CERT_QUERY_FORMAT_TYPE_FLAGS,
21887     dwflags: u32,
21888     pdwmsgandcertencodingtype: *mut CERT_QUERY_ENCODING_TYPE,
21889     pdwcontenttype: *mut CERT_QUERY_CONTENT_TYPE,
21890     pdwformattype: *mut CERT_QUERY_FORMAT_TYPE,
21891     phcertstore: *mut *mut ::std::ffi::c_void,
21892     phmsg: *mut *mut ::std::ffi::c_void,
21893     ppvcontext: *mut *mut ::std::ffi::c_void,
21894 ) -> super::super::Foundation::BOOL {
21895     #[cfg(windows)]
21896     {
21897         #[link(name = "windows")]
21898         extern "system" {
21899             fn CryptQueryObject(
21900                 dwobjecttype: CERT_QUERY_OBJECT_TYPE,
21901                 pvobject: *const ::std::ffi::c_void,
21902                 dwexpectedcontenttypeflags: CERT_QUERY_CONTENT_TYPE_FLAGS,
21903                 dwexpectedformattypeflags: CERT_QUERY_FORMAT_TYPE_FLAGS,
21904                 dwflags: u32,
21905                 pdwmsgandcertencodingtype: *mut CERT_QUERY_ENCODING_TYPE,
21906                 pdwcontenttype: *mut CERT_QUERY_CONTENT_TYPE,
21907                 pdwformattype: *mut CERT_QUERY_FORMAT_TYPE,
21908                 phcertstore: *mut *mut ::std::ffi::c_void,
21909                 phmsg: *mut *mut ::std::ffi::c_void,
21910                 ppvcontext: *mut *mut ::std::ffi::c_void,
21911             ) -> super::super::Foundation::BOOL;
21912         }
21913         ::std::mem::transmute(CryptQueryObject(
21914             ::std::mem::transmute(dwobjecttype),
21915             ::std::mem::transmute(pvobject),
21916             ::std::mem::transmute(dwexpectedcontenttypeflags),
21917             ::std::mem::transmute(dwexpectedformattypeflags),
21918             ::std::mem::transmute(dwflags),
21919             ::std::mem::transmute(pdwmsgandcertencodingtype),
21920             ::std::mem::transmute(pdwcontenttype),
21921             ::std::mem::transmute(pdwformattype),
21922             ::std::mem::transmute(phcertstore),
21923             ::std::mem::transmute(phmsg),
21924             ::std::mem::transmute(ppvcontext),
21925         ))
21926     }
21927     #[cfg(not(windows))]
21928     unimplemented!("Unsupported target OS");
21929 }
21930 #[cfg(feature = "Win32_Foundation")]
21931 #[inline]
CryptRegisterDefaultOIDFunction<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwencodingtype: u32, pszfuncname: Param1, dwindex: u32, pwszdll: Param3) -> super::super::Foundation::BOOL21932 pub unsafe fn CryptRegisterDefaultOIDFunction<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwencodingtype: u32, pszfuncname: Param1, dwindex: u32, pwszdll: Param3) -> super::super::Foundation::BOOL {
21933     #[cfg(windows)]
21934     {
21935         #[link(name = "windows")]
21936         extern "system" {
21937             fn CryptRegisterDefaultOIDFunction(dwencodingtype: u32, pszfuncname: super::super::Foundation::PSTR, dwindex: u32, pwszdll: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
21938         }
21939         ::std::mem::transmute(CryptRegisterDefaultOIDFunction(::std::mem::transmute(dwencodingtype), pszfuncname.into_param().abi(), ::std::mem::transmute(dwindex), pwszdll.into_param().abi()))
21940     }
21941     #[cfg(not(windows))]
21942     unimplemented!("Unsupported target OS");
21943 }
21944 #[cfg(feature = "Win32_Foundation")]
21945 #[inline]
CryptRegisterOIDFunction<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwencodingtype: u32, pszfuncname: Param1, pszoid: Param2, pwszdll: Param3, pszoverridefuncname: Param4) -> super::super::Foundation::BOOL21946 pub unsafe fn CryptRegisterOIDFunction<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwencodingtype: u32, pszfuncname: Param1, pszoid: Param2, pwszdll: Param3, pszoverridefuncname: Param4) -> super::super::Foundation::BOOL {
21947     #[cfg(windows)]
21948     {
21949         #[link(name = "windows")]
21950         extern "system" {
21951             fn CryptRegisterOIDFunction(dwencodingtype: u32, pszfuncname: super::super::Foundation::PSTR, pszoid: super::super::Foundation::PSTR, pwszdll: super::super::Foundation::PWSTR, pszoverridefuncname: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
21952         }
21953         ::std::mem::transmute(CryptRegisterOIDFunction(::std::mem::transmute(dwencodingtype), pszfuncname.into_param().abi(), pszoid.into_param().abi(), pwszdll.into_param().abi(), pszoverridefuncname.into_param().abi()))
21954     }
21955     #[cfg(not(windows))]
21956     unimplemented!("Unsupported target OS");
21957 }
21958 #[cfg(feature = "Win32_Foundation")]
21959 #[inline]
CryptRegisterOIDInfo(pinfo: *const CRYPT_OID_INFO, dwflags: u32) -> super::super::Foundation::BOOL21960 pub unsafe fn CryptRegisterOIDInfo(pinfo: *const CRYPT_OID_INFO, dwflags: u32) -> super::super::Foundation::BOOL {
21961     #[cfg(windows)]
21962     {
21963         #[link(name = "windows")]
21964         extern "system" {
21965             fn CryptRegisterOIDInfo(pinfo: *const CRYPT_OID_INFO, dwflags: u32) -> super::super::Foundation::BOOL;
21966         }
21967         ::std::mem::transmute(CryptRegisterOIDInfo(::std::mem::transmute(pinfo), ::std::mem::transmute(dwflags)))
21968     }
21969     #[cfg(not(windows))]
21970     unimplemented!("Unsupported target OS");
21971 }
21972 #[cfg(feature = "Win32_Foundation")]
21973 #[inline]
CryptReleaseContext(hprov: usize, dwflags: u32) -> super::super::Foundation::BOOL21974 pub unsafe fn CryptReleaseContext(hprov: usize, dwflags: u32) -> super::super::Foundation::BOOL {
21975     #[cfg(windows)]
21976     {
21977         #[link(name = "windows")]
21978         extern "system" {
21979             fn CryptReleaseContext(hprov: usize, dwflags: u32) -> super::super::Foundation::BOOL;
21980         }
21981         ::std::mem::transmute(CryptReleaseContext(::std::mem::transmute(hprov), ::std::mem::transmute(dwflags)))
21982     }
21983     #[cfg(not(windows))]
21984     unimplemented!("Unsupported target OS");
21985 }
21986 #[cfg(feature = "Win32_Foundation")]
21987 #[inline]
CryptRetrieveObjectByUrlA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param5: ::windows::runtime::IntoParam<'a, HCRYPTASYNC>>( pszurl: Param0, pszobjectoid: Param1, dwretrievalflags: u32, dwtimeout: u32, ppvobject: *mut *mut ::std::ffi::c_void, hasyncretrieve: Param5, pcredentials: *const CRYPT_CREDENTIALS, pvverify: *const ::std::ffi::c_void, pauxinfo: *mut CRYPT_RETRIEVE_AUX_INFO, ) -> super::super::Foundation::BOOL21988 pub unsafe fn CryptRetrieveObjectByUrlA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param5: ::windows::runtime::IntoParam<'a, HCRYPTASYNC>>(
21989     pszurl: Param0,
21990     pszobjectoid: Param1,
21991     dwretrievalflags: u32,
21992     dwtimeout: u32,
21993     ppvobject: *mut *mut ::std::ffi::c_void,
21994     hasyncretrieve: Param5,
21995     pcredentials: *const CRYPT_CREDENTIALS,
21996     pvverify: *const ::std::ffi::c_void,
21997     pauxinfo: *mut CRYPT_RETRIEVE_AUX_INFO,
21998 ) -> super::super::Foundation::BOOL {
21999     #[cfg(windows)]
22000     {
22001         #[link(name = "windows")]
22002         extern "system" {
22003             fn CryptRetrieveObjectByUrlA(pszurl: super::super::Foundation::PSTR, pszobjectoid: super::super::Foundation::PSTR, dwretrievalflags: u32, dwtimeout: u32, ppvobject: *mut *mut ::std::ffi::c_void, hasyncretrieve: HCRYPTASYNC, pcredentials: *const CRYPT_CREDENTIALS, pvverify: *const ::std::ffi::c_void, pauxinfo: *mut CRYPT_RETRIEVE_AUX_INFO) -> super::super::Foundation::BOOL;
22004         }
22005         ::std::mem::transmute(CryptRetrieveObjectByUrlA(
22006             pszurl.into_param().abi(),
22007             pszobjectoid.into_param().abi(),
22008             ::std::mem::transmute(dwretrievalflags),
22009             ::std::mem::transmute(dwtimeout),
22010             ::std::mem::transmute(ppvobject),
22011             hasyncretrieve.into_param().abi(),
22012             ::std::mem::transmute(pcredentials),
22013             ::std::mem::transmute(pvverify),
22014             ::std::mem::transmute(pauxinfo),
22015         ))
22016     }
22017     #[cfg(not(windows))]
22018     unimplemented!("Unsupported target OS");
22019 }
22020 #[cfg(feature = "Win32_Foundation")]
22021 #[inline]
CryptRetrieveObjectByUrlW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param5: ::windows::runtime::IntoParam<'a, HCRYPTASYNC>>( pszurl: Param0, pszobjectoid: Param1, dwretrievalflags: u32, dwtimeout: u32, ppvobject: *mut *mut ::std::ffi::c_void, hasyncretrieve: Param5, pcredentials: *const CRYPT_CREDENTIALS, pvverify: *const ::std::ffi::c_void, pauxinfo: *mut CRYPT_RETRIEVE_AUX_INFO, ) -> super::super::Foundation::BOOL22022 pub unsafe fn CryptRetrieveObjectByUrlW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param5: ::windows::runtime::IntoParam<'a, HCRYPTASYNC>>(
22023     pszurl: Param0,
22024     pszobjectoid: Param1,
22025     dwretrievalflags: u32,
22026     dwtimeout: u32,
22027     ppvobject: *mut *mut ::std::ffi::c_void,
22028     hasyncretrieve: Param5,
22029     pcredentials: *const CRYPT_CREDENTIALS,
22030     pvverify: *const ::std::ffi::c_void,
22031     pauxinfo: *mut CRYPT_RETRIEVE_AUX_INFO,
22032 ) -> super::super::Foundation::BOOL {
22033     #[cfg(windows)]
22034     {
22035         #[link(name = "windows")]
22036         extern "system" {
22037             fn CryptRetrieveObjectByUrlW(pszurl: super::super::Foundation::PWSTR, pszobjectoid: super::super::Foundation::PSTR, dwretrievalflags: u32, dwtimeout: u32, ppvobject: *mut *mut ::std::ffi::c_void, hasyncretrieve: HCRYPTASYNC, pcredentials: *const CRYPT_CREDENTIALS, pvverify: *const ::std::ffi::c_void, pauxinfo: *mut CRYPT_RETRIEVE_AUX_INFO) -> super::super::Foundation::BOOL;
22038         }
22039         ::std::mem::transmute(CryptRetrieveObjectByUrlW(
22040             pszurl.into_param().abi(),
22041             pszobjectoid.into_param().abi(),
22042             ::std::mem::transmute(dwretrievalflags),
22043             ::std::mem::transmute(dwtimeout),
22044             ::std::mem::transmute(ppvobject),
22045             hasyncretrieve.into_param().abi(),
22046             ::std::mem::transmute(pcredentials),
22047             ::std::mem::transmute(pvverify),
22048             ::std::mem::transmute(pauxinfo),
22049         ))
22050     }
22051     #[cfg(not(windows))]
22052     unimplemented!("Unsupported target OS");
22053 }
22054 #[cfg(feature = "Win32_Foundation")]
22055 #[inline]
CryptRetrieveTimeStamp<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(wszurl: Param0, dwretrievalflags: u32, dwtimeout: u32, pszhashid: Param3, ppara: *const CRYPT_TIMESTAMP_PARA, pbdata: *const u8, cbdata: u32, pptscontext: *mut *mut CRYPT_TIMESTAMP_CONTEXT, pptssigner: *mut *mut CERT_CONTEXT, phstore: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL22056 pub unsafe fn CryptRetrieveTimeStamp<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(wszurl: Param0, dwretrievalflags: u32, dwtimeout: u32, pszhashid: Param3, ppara: *const CRYPT_TIMESTAMP_PARA, pbdata: *const u8, cbdata: u32, pptscontext: *mut *mut CRYPT_TIMESTAMP_CONTEXT, pptssigner: *mut *mut CERT_CONTEXT, phstore: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
22057     #[cfg(windows)]
22058     {
22059         #[link(name = "windows")]
22060         extern "system" {
22061             fn CryptRetrieveTimeStamp(wszurl: super::super::Foundation::PWSTR, dwretrievalflags: u32, dwtimeout: u32, pszhashid: super::super::Foundation::PSTR, ppara: *const CRYPT_TIMESTAMP_PARA, pbdata: *const u8, cbdata: u32, pptscontext: *mut *mut CRYPT_TIMESTAMP_CONTEXT, pptssigner: *mut *mut CERT_CONTEXT, phstore: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
22062         }
22063         ::std::mem::transmute(CryptRetrieveTimeStamp(
22064             wszurl.into_param().abi(),
22065             ::std::mem::transmute(dwretrievalflags),
22066             ::std::mem::transmute(dwtimeout),
22067             pszhashid.into_param().abi(),
22068             ::std::mem::transmute(ppara),
22069             ::std::mem::transmute(pbdata),
22070             ::std::mem::transmute(cbdata),
22071             ::std::mem::transmute(pptscontext),
22072             ::std::mem::transmute(pptssigner),
22073             ::std::mem::transmute(phstore),
22074         ))
22075     }
22076     #[cfg(not(windows))]
22077     unimplemented!("Unsupported target OS");
22078 }
22079 #[cfg(feature = "Win32_Foundation")]
22080 #[inline]
CryptSetAsyncParam<'a, Param0: ::windows::runtime::IntoParam<'a, HCRYPTASYNC>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hasync: Param0, pszparamoid: Param1, pvparam: *const ::std::ffi::c_void, pfnfree: ::std::option::Option<PFN_CRYPT_ASYNC_PARAM_FREE_FUNC>) -> super::super::Foundation::BOOL22081 pub unsafe fn CryptSetAsyncParam<'a, Param0: ::windows::runtime::IntoParam<'a, HCRYPTASYNC>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hasync: Param0, pszparamoid: Param1, pvparam: *const ::std::ffi::c_void, pfnfree: ::std::option::Option<PFN_CRYPT_ASYNC_PARAM_FREE_FUNC>) -> super::super::Foundation::BOOL {
22082     #[cfg(windows)]
22083     {
22084         #[link(name = "windows")]
22085         extern "system" {
22086             fn CryptSetAsyncParam(hasync: HCRYPTASYNC, pszparamoid: super::super::Foundation::PSTR, pvparam: *const ::std::ffi::c_void, pfnfree: ::windows::runtime::RawPtr) -> super::super::Foundation::BOOL;
22087         }
22088         ::std::mem::transmute(CryptSetAsyncParam(hasync.into_param().abi(), pszparamoid.into_param().abi(), ::std::mem::transmute(pvparam), ::std::mem::transmute(pfnfree)))
22089     }
22090     #[cfg(not(windows))]
22091     unimplemented!("Unsupported target OS");
22092 }
22093 #[cfg(feature = "Win32_Foundation")]
22094 #[inline]
CryptSetHashParam(hhash: usize, dwparam: CRYPT_SET_HASH_PARAM, pbdata: *const u8, dwflags: u32) -> super::super::Foundation::BOOL22095 pub unsafe fn CryptSetHashParam(hhash: usize, dwparam: CRYPT_SET_HASH_PARAM, pbdata: *const u8, dwflags: u32) -> super::super::Foundation::BOOL {
22096     #[cfg(windows)]
22097     {
22098         #[link(name = "windows")]
22099         extern "system" {
22100             fn CryptSetHashParam(hhash: usize, dwparam: CRYPT_SET_HASH_PARAM, pbdata: *const u8, dwflags: u32) -> super::super::Foundation::BOOL;
22101         }
22102         ::std::mem::transmute(CryptSetHashParam(::std::mem::transmute(hhash), ::std::mem::transmute(dwparam), ::std::mem::transmute(pbdata), ::std::mem::transmute(dwflags)))
22103     }
22104     #[cfg(not(windows))]
22105     unimplemented!("Unsupported target OS");
22106 }
22107 #[cfg(feature = "Win32_Foundation")]
22108 #[inline]
CryptSetKeyIdentifierProperty<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pkeyidentifier: *const CRYPTOAPI_BLOB, dwpropid: u32, dwflags: u32, pwszcomputername: Param3, pvreserved: *mut ::std::ffi::c_void, pvdata: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL22109 pub unsafe fn CryptSetKeyIdentifierProperty<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pkeyidentifier: *const CRYPTOAPI_BLOB, dwpropid: u32, dwflags: u32, pwszcomputername: Param3, pvreserved: *mut ::std::ffi::c_void, pvdata: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL {
22110     #[cfg(windows)]
22111     {
22112         #[link(name = "windows")]
22113         extern "system" {
22114             fn CryptSetKeyIdentifierProperty(pkeyidentifier: *const CRYPTOAPI_BLOB, dwpropid: u32, dwflags: u32, pwszcomputername: super::super::Foundation::PWSTR, pvreserved: *mut ::std::ffi::c_void, pvdata: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
22115         }
22116         ::std::mem::transmute(CryptSetKeyIdentifierProperty(::std::mem::transmute(pkeyidentifier), ::std::mem::transmute(dwpropid), ::std::mem::transmute(dwflags), pwszcomputername.into_param().abi(), ::std::mem::transmute(pvreserved), ::std::mem::transmute(pvdata)))
22117     }
22118     #[cfg(not(windows))]
22119     unimplemented!("Unsupported target OS");
22120 }
22121 #[cfg(feature = "Win32_Foundation")]
22122 #[inline]
CryptSetKeyParam(hkey: usize, dwparam: CRYPT_KEY_PARAM_ID, pbdata: *const u8, dwflags: u32) -> super::super::Foundation::BOOL22123 pub unsafe fn CryptSetKeyParam(hkey: usize, dwparam: CRYPT_KEY_PARAM_ID, pbdata: *const u8, dwflags: u32) -> super::super::Foundation::BOOL {
22124     #[cfg(windows)]
22125     {
22126         #[link(name = "windows")]
22127         extern "system" {
22128             fn CryptSetKeyParam(hkey: usize, dwparam: CRYPT_KEY_PARAM_ID, pbdata: *const u8, dwflags: u32) -> super::super::Foundation::BOOL;
22129         }
22130         ::std::mem::transmute(CryptSetKeyParam(::std::mem::transmute(hkey), ::std::mem::transmute(dwparam), ::std::mem::transmute(pbdata), ::std::mem::transmute(dwflags)))
22131     }
22132     #[cfg(not(windows))]
22133     unimplemented!("Unsupported target OS");
22134 }
22135 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
22136 #[inline]
CryptSetOIDFunctionValue<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwencodingtype: u32, pszfuncname: Param1, pszoid: Param2, pwszvaluename: Param3, dwvaluetype: super::super::System::Registry::REG_VALUE_TYPE, pbvaluedata: *const u8, cbvaluedata: u32) -> super::super::Foundation::BOOL22137 pub unsafe fn CryptSetOIDFunctionValue<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwencodingtype: u32, pszfuncname: Param1, pszoid: Param2, pwszvaluename: Param3, dwvaluetype: super::super::System::Registry::REG_VALUE_TYPE, pbvaluedata: *const u8, cbvaluedata: u32) -> super::super::Foundation::BOOL {
22138     #[cfg(windows)]
22139     {
22140         #[link(name = "windows")]
22141         extern "system" {
22142             fn CryptSetOIDFunctionValue(dwencodingtype: u32, pszfuncname: super::super::Foundation::PSTR, pszoid: super::super::Foundation::PSTR, pwszvaluename: super::super::Foundation::PWSTR, dwvaluetype: super::super::System::Registry::REG_VALUE_TYPE, pbvaluedata: *const u8, cbvaluedata: u32) -> super::super::Foundation::BOOL;
22143         }
22144         ::std::mem::transmute(CryptSetOIDFunctionValue(::std::mem::transmute(dwencodingtype), pszfuncname.into_param().abi(), pszoid.into_param().abi(), pwszvaluename.into_param().abi(), ::std::mem::transmute(dwvaluetype), ::std::mem::transmute(pbvaluedata), ::std::mem::transmute(cbvaluedata)))
22145     }
22146     #[cfg(not(windows))]
22147     unimplemented!("Unsupported target OS");
22148 }
22149 #[cfg(feature = "Win32_Foundation")]
22150 #[inline]
CryptSetProvParam(hprov: usize, dwparam: CRYPT_SET_PROV_PARAM_ID, pbdata: *const u8, dwflags: u32) -> super::super::Foundation::BOOL22151 pub unsafe fn CryptSetProvParam(hprov: usize, dwparam: CRYPT_SET_PROV_PARAM_ID, pbdata: *const u8, dwflags: u32) -> super::super::Foundation::BOOL {
22152     #[cfg(windows)]
22153     {
22154         #[link(name = "windows")]
22155         extern "system" {
22156             fn CryptSetProvParam(hprov: usize, dwparam: CRYPT_SET_PROV_PARAM_ID, pbdata: *const u8, dwflags: u32) -> super::super::Foundation::BOOL;
22157         }
22158         ::std::mem::transmute(CryptSetProvParam(::std::mem::transmute(hprov), ::std::mem::transmute(dwparam), ::std::mem::transmute(pbdata), ::std::mem::transmute(dwflags)))
22159     }
22160     #[cfg(not(windows))]
22161     unimplemented!("Unsupported target OS");
22162 }
22163 #[cfg(feature = "Win32_Foundation")]
22164 #[inline]
CryptSetProviderA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszprovname: Param0, dwprovtype: u32) -> super::super::Foundation::BOOL22165 pub unsafe fn CryptSetProviderA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszprovname: Param0, dwprovtype: u32) -> super::super::Foundation::BOOL {
22166     #[cfg(windows)]
22167     {
22168         #[link(name = "windows")]
22169         extern "system" {
22170             fn CryptSetProviderA(pszprovname: super::super::Foundation::PSTR, dwprovtype: u32) -> super::super::Foundation::BOOL;
22171         }
22172         ::std::mem::transmute(CryptSetProviderA(pszprovname.into_param().abi(), ::std::mem::transmute(dwprovtype)))
22173     }
22174     #[cfg(not(windows))]
22175     unimplemented!("Unsupported target OS");
22176 }
22177 #[cfg(feature = "Win32_Foundation")]
22178 #[inline]
CryptSetProviderExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszprovname: Param0, dwprovtype: u32, pdwreserved: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL22179 pub unsafe fn CryptSetProviderExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszprovname: Param0, dwprovtype: u32, pdwreserved: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL {
22180     #[cfg(windows)]
22181     {
22182         #[link(name = "windows")]
22183         extern "system" {
22184             fn CryptSetProviderExA(pszprovname: super::super::Foundation::PSTR, dwprovtype: u32, pdwreserved: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL;
22185         }
22186         ::std::mem::transmute(CryptSetProviderExA(pszprovname.into_param().abi(), ::std::mem::transmute(dwprovtype), ::std::mem::transmute(pdwreserved), ::std::mem::transmute(dwflags)))
22187     }
22188     #[cfg(not(windows))]
22189     unimplemented!("Unsupported target OS");
22190 }
22191 #[cfg(feature = "Win32_Foundation")]
22192 #[inline]
CryptSetProviderExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pszprovname: Param0, dwprovtype: u32, pdwreserved: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL22193 pub unsafe fn CryptSetProviderExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pszprovname: Param0, dwprovtype: u32, pdwreserved: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL {
22194     #[cfg(windows)]
22195     {
22196         #[link(name = "windows")]
22197         extern "system" {
22198             fn CryptSetProviderExW(pszprovname: super::super::Foundation::PWSTR, dwprovtype: u32, pdwreserved: *mut u32, dwflags: u32) -> super::super::Foundation::BOOL;
22199         }
22200         ::std::mem::transmute(CryptSetProviderExW(pszprovname.into_param().abi(), ::std::mem::transmute(dwprovtype), ::std::mem::transmute(pdwreserved), ::std::mem::transmute(dwflags)))
22201     }
22202     #[cfg(not(windows))]
22203     unimplemented!("Unsupported target OS");
22204 }
22205 #[cfg(feature = "Win32_Foundation")]
22206 #[inline]
CryptSetProviderW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pszprovname: Param0, dwprovtype: u32) -> super::super::Foundation::BOOL22207 pub unsafe fn CryptSetProviderW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pszprovname: Param0, dwprovtype: u32) -> super::super::Foundation::BOOL {
22208     #[cfg(windows)]
22209     {
22210         #[link(name = "windows")]
22211         extern "system" {
22212             fn CryptSetProviderW(pszprovname: super::super::Foundation::PWSTR, dwprovtype: u32) -> super::super::Foundation::BOOL;
22213         }
22214         ::std::mem::transmute(CryptSetProviderW(pszprovname.into_param().abi(), ::std::mem::transmute(dwprovtype)))
22215     }
22216     #[cfg(not(windows))]
22217     unimplemented!("Unsupported target OS");
22218 }
22219 #[cfg(feature = "Win32_Foundation")]
22220 #[inline]
CryptSignAndEncodeCertificate<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hcryptprovorncryptkey: usize, dwkeyspec: CERT_KEY_SPEC, dwcertencodingtype: u32, lpszstructtype: Param3, pvstructinfo: *const ::std::ffi::c_void, psignaturealgorithm: *const CRYPT_ALGORITHM_IDENTIFIER, pvhashauxinfo: *const ::std::ffi::c_void, pbencoded: *mut u8, pcbencoded: *mut u32) -> super::super::Foundation::BOOL22221 pub unsafe fn CryptSignAndEncodeCertificate<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hcryptprovorncryptkey: usize, dwkeyspec: CERT_KEY_SPEC, dwcertencodingtype: u32, lpszstructtype: Param3, pvstructinfo: *const ::std::ffi::c_void, psignaturealgorithm: *const CRYPT_ALGORITHM_IDENTIFIER, pvhashauxinfo: *const ::std::ffi::c_void, pbencoded: *mut u8, pcbencoded: *mut u32) -> super::super::Foundation::BOOL {
22222     #[cfg(windows)]
22223     {
22224         #[link(name = "windows")]
22225         extern "system" {
22226             fn CryptSignAndEncodeCertificate(hcryptprovorncryptkey: usize, dwkeyspec: CERT_KEY_SPEC, dwcertencodingtype: u32, lpszstructtype: super::super::Foundation::PSTR, pvstructinfo: *const ::std::ffi::c_void, psignaturealgorithm: *const CRYPT_ALGORITHM_IDENTIFIER, pvhashauxinfo: *const ::std::ffi::c_void, pbencoded: *mut u8, pcbencoded: *mut u32) -> super::super::Foundation::BOOL;
22227         }
22228         ::std::mem::transmute(CryptSignAndEncodeCertificate(
22229             ::std::mem::transmute(hcryptprovorncryptkey),
22230             ::std::mem::transmute(dwkeyspec),
22231             ::std::mem::transmute(dwcertencodingtype),
22232             lpszstructtype.into_param().abi(),
22233             ::std::mem::transmute(pvstructinfo),
22234             ::std::mem::transmute(psignaturealgorithm),
22235             ::std::mem::transmute(pvhashauxinfo),
22236             ::std::mem::transmute(pbencoded),
22237             ::std::mem::transmute(pcbencoded),
22238         ))
22239     }
22240     #[cfg(not(windows))]
22241     unimplemented!("Unsupported target OS");
22242 }
22243 #[cfg(feature = "Win32_Foundation")]
22244 #[inline]
CryptSignAndEncryptMessage(psignpara: *const CRYPT_SIGN_MESSAGE_PARA, pencryptpara: *const CRYPT_ENCRYPT_MESSAGE_PARA, crecipientcert: u32, rgprecipientcert: *const *const CERT_CONTEXT, pbtobesignedandencrypted: *const u8, cbtobesignedandencrypted: u32, pbsignedandencryptedblob: *mut u8, pcbsignedandencryptedblob: *mut u32) -> super::super::Foundation::BOOL22245 pub unsafe fn CryptSignAndEncryptMessage(psignpara: *const CRYPT_SIGN_MESSAGE_PARA, pencryptpara: *const CRYPT_ENCRYPT_MESSAGE_PARA, crecipientcert: u32, rgprecipientcert: *const *const CERT_CONTEXT, pbtobesignedandencrypted: *const u8, cbtobesignedandencrypted: u32, pbsignedandencryptedblob: *mut u8, pcbsignedandencryptedblob: *mut u32) -> super::super::Foundation::BOOL {
22246     #[cfg(windows)]
22247     {
22248         #[link(name = "windows")]
22249         extern "system" {
22250             fn CryptSignAndEncryptMessage(psignpara: *const CRYPT_SIGN_MESSAGE_PARA, pencryptpara: *const CRYPT_ENCRYPT_MESSAGE_PARA, crecipientcert: u32, rgprecipientcert: *const *const CERT_CONTEXT, pbtobesignedandencrypted: *const u8, cbtobesignedandencrypted: u32, pbsignedandencryptedblob: *mut u8, pcbsignedandencryptedblob: *mut u32) -> super::super::Foundation::BOOL;
22251         }
22252         ::std::mem::transmute(CryptSignAndEncryptMessage(
22253             ::std::mem::transmute(psignpara),
22254             ::std::mem::transmute(pencryptpara),
22255             ::std::mem::transmute(crecipientcert),
22256             ::std::mem::transmute(rgprecipientcert),
22257             ::std::mem::transmute(pbtobesignedandencrypted),
22258             ::std::mem::transmute(cbtobesignedandencrypted),
22259             ::std::mem::transmute(pbsignedandencryptedblob),
22260             ::std::mem::transmute(pcbsignedandencryptedblob),
22261         ))
22262     }
22263     #[cfg(not(windows))]
22264     unimplemented!("Unsupported target OS");
22265 }
22266 #[cfg(feature = "Win32_Foundation")]
22267 #[inline]
CryptSignCertificate(hcryptprovorncryptkey: usize, dwkeyspec: u32, dwcertencodingtype: u32, pbencodedtobesigned: *const u8, cbencodedtobesigned: u32, psignaturealgorithm: *const CRYPT_ALGORITHM_IDENTIFIER, pvhashauxinfo: *const ::std::ffi::c_void, pbsignature: *mut u8, pcbsignature: *mut u32) -> super::super::Foundation::BOOL22268 pub unsafe fn CryptSignCertificate(hcryptprovorncryptkey: usize, dwkeyspec: u32, dwcertencodingtype: u32, pbencodedtobesigned: *const u8, cbencodedtobesigned: u32, psignaturealgorithm: *const CRYPT_ALGORITHM_IDENTIFIER, pvhashauxinfo: *const ::std::ffi::c_void, pbsignature: *mut u8, pcbsignature: *mut u32) -> super::super::Foundation::BOOL {
22269     #[cfg(windows)]
22270     {
22271         #[link(name = "windows")]
22272         extern "system" {
22273             fn CryptSignCertificate(hcryptprovorncryptkey: usize, dwkeyspec: u32, dwcertencodingtype: u32, pbencodedtobesigned: *const u8, cbencodedtobesigned: u32, psignaturealgorithm: *const CRYPT_ALGORITHM_IDENTIFIER, pvhashauxinfo: *const ::std::ffi::c_void, pbsignature: *mut u8, pcbsignature: *mut u32) -> super::super::Foundation::BOOL;
22274         }
22275         ::std::mem::transmute(CryptSignCertificate(
22276             ::std::mem::transmute(hcryptprovorncryptkey),
22277             ::std::mem::transmute(dwkeyspec),
22278             ::std::mem::transmute(dwcertencodingtype),
22279             ::std::mem::transmute(pbencodedtobesigned),
22280             ::std::mem::transmute(cbencodedtobesigned),
22281             ::std::mem::transmute(psignaturealgorithm),
22282             ::std::mem::transmute(pvhashauxinfo),
22283             ::std::mem::transmute(pbsignature),
22284             ::std::mem::transmute(pcbsignature),
22285         ))
22286     }
22287     #[cfg(not(windows))]
22288     unimplemented!("Unsupported target OS");
22289 }
22290 #[cfg(feature = "Win32_Foundation")]
22291 #[inline]
CryptSignHashA<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hhash: usize, dwkeyspec: u32, szdescription: Param2, dwflags: u32, pbsignature: *mut u8, pdwsiglen: *mut u32) -> super::super::Foundation::BOOL22292 pub unsafe fn CryptSignHashA<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hhash: usize, dwkeyspec: u32, szdescription: Param2, dwflags: u32, pbsignature: *mut u8, pdwsiglen: *mut u32) -> super::super::Foundation::BOOL {
22293     #[cfg(windows)]
22294     {
22295         #[link(name = "windows")]
22296         extern "system" {
22297             fn CryptSignHashA(hhash: usize, dwkeyspec: u32, szdescription: super::super::Foundation::PSTR, dwflags: u32, pbsignature: *mut u8, pdwsiglen: *mut u32) -> super::super::Foundation::BOOL;
22298         }
22299         ::std::mem::transmute(CryptSignHashA(::std::mem::transmute(hhash), ::std::mem::transmute(dwkeyspec), szdescription.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(pbsignature), ::std::mem::transmute(pdwsiglen)))
22300     }
22301     #[cfg(not(windows))]
22302     unimplemented!("Unsupported target OS");
22303 }
22304 #[cfg(feature = "Win32_Foundation")]
22305 #[inline]
CryptSignHashW<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hhash: usize, dwkeyspec: u32, szdescription: Param2, dwflags: u32, pbsignature: *mut u8, pdwsiglen: *mut u32) -> super::super::Foundation::BOOL22306 pub unsafe fn CryptSignHashW<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hhash: usize, dwkeyspec: u32, szdescription: Param2, dwflags: u32, pbsignature: *mut u8, pdwsiglen: *mut u32) -> super::super::Foundation::BOOL {
22307     #[cfg(windows)]
22308     {
22309         #[link(name = "windows")]
22310         extern "system" {
22311             fn CryptSignHashW(hhash: usize, dwkeyspec: u32, szdescription: super::super::Foundation::PWSTR, dwflags: u32, pbsignature: *mut u8, pdwsiglen: *mut u32) -> super::super::Foundation::BOOL;
22312         }
22313         ::std::mem::transmute(CryptSignHashW(::std::mem::transmute(hhash), ::std::mem::transmute(dwkeyspec), szdescription.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(pbsignature), ::std::mem::transmute(pdwsiglen)))
22314     }
22315     #[cfg(not(windows))]
22316     unimplemented!("Unsupported target OS");
22317 }
22318 #[cfg(feature = "Win32_Foundation")]
22319 #[inline]
CryptSignMessage<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(psignpara: *const CRYPT_SIGN_MESSAGE_PARA, fdetachedsignature: Param1, ctobesigned: u32, rgpbtobesigned: *const *const u8, rgcbtobesigned: *const u32, pbsignedblob: *mut u8, pcbsignedblob: *mut u32) -> super::super::Foundation::BOOL22320 pub unsafe fn CryptSignMessage<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(psignpara: *const CRYPT_SIGN_MESSAGE_PARA, fdetachedsignature: Param1, ctobesigned: u32, rgpbtobesigned: *const *const u8, rgcbtobesigned: *const u32, pbsignedblob: *mut u8, pcbsignedblob: *mut u32) -> super::super::Foundation::BOOL {
22321     #[cfg(windows)]
22322     {
22323         #[link(name = "windows")]
22324         extern "system" {
22325             fn CryptSignMessage(psignpara: *const CRYPT_SIGN_MESSAGE_PARA, fdetachedsignature: super::super::Foundation::BOOL, ctobesigned: u32, rgpbtobesigned: *const *const u8, rgcbtobesigned: *const u32, pbsignedblob: *mut u8, pcbsignedblob: *mut u32) -> super::super::Foundation::BOOL;
22326         }
22327         ::std::mem::transmute(CryptSignMessage(::std::mem::transmute(psignpara), fdetachedsignature.into_param().abi(), ::std::mem::transmute(ctobesigned), ::std::mem::transmute(rgpbtobesigned), ::std::mem::transmute(rgcbtobesigned), ::std::mem::transmute(pbsignedblob), ::std::mem::transmute(pcbsignedblob)))
22328     }
22329     #[cfg(not(windows))]
22330     unimplemented!("Unsupported target OS");
22331 }
22332 #[cfg(feature = "Win32_Foundation")]
22333 #[inline]
CryptSignMessageWithKey(psignpara: *const CRYPT_KEY_SIGN_MESSAGE_PARA, pbtobesigned: *const u8, cbtobesigned: u32, pbsignedblob: *mut u8, pcbsignedblob: *mut u32) -> super::super::Foundation::BOOL22334 pub unsafe fn CryptSignMessageWithKey(psignpara: *const CRYPT_KEY_SIGN_MESSAGE_PARA, pbtobesigned: *const u8, cbtobesigned: u32, pbsignedblob: *mut u8, pcbsignedblob: *mut u32) -> super::super::Foundation::BOOL {
22335     #[cfg(windows)]
22336     {
22337         #[link(name = "windows")]
22338         extern "system" {
22339             fn CryptSignMessageWithKey(psignpara: *const CRYPT_KEY_SIGN_MESSAGE_PARA, pbtobesigned: *const u8, cbtobesigned: u32, pbsignedblob: *mut u8, pcbsignedblob: *mut u32) -> super::super::Foundation::BOOL;
22340         }
22341         ::std::mem::transmute(CryptSignMessageWithKey(::std::mem::transmute(psignpara), ::std::mem::transmute(pbtobesigned), ::std::mem::transmute(cbtobesigned), ::std::mem::transmute(pbsignedblob), ::std::mem::transmute(pcbsignedblob)))
22342     }
22343     #[cfg(not(windows))]
22344     unimplemented!("Unsupported target OS");
22345 }
22346 #[cfg(feature = "Win32_Foundation")]
22347 #[inline]
CryptStringToBinaryA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszstring: Param0, cchstring: u32, dwflags: CRYPT_STRING, pbbinary: *mut u8, pcbbinary: *mut u32, pdwskip: *mut u32, pdwflags: *mut u32) -> super::super::Foundation::BOOL22348 pub unsafe fn CryptStringToBinaryA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszstring: Param0, cchstring: u32, dwflags: CRYPT_STRING, pbbinary: *mut u8, pcbbinary: *mut u32, pdwskip: *mut u32, pdwflags: *mut u32) -> super::super::Foundation::BOOL {
22349     #[cfg(windows)]
22350     {
22351         #[link(name = "windows")]
22352         extern "system" {
22353             fn CryptStringToBinaryA(pszstring: super::super::Foundation::PSTR, cchstring: u32, dwflags: CRYPT_STRING, pbbinary: *mut u8, pcbbinary: *mut u32, pdwskip: *mut u32, pdwflags: *mut u32) -> super::super::Foundation::BOOL;
22354         }
22355         ::std::mem::transmute(CryptStringToBinaryA(pszstring.into_param().abi(), ::std::mem::transmute(cchstring), ::std::mem::transmute(dwflags), ::std::mem::transmute(pbbinary), ::std::mem::transmute(pcbbinary), ::std::mem::transmute(pdwskip), ::std::mem::transmute(pdwflags)))
22356     }
22357     #[cfg(not(windows))]
22358     unimplemented!("Unsupported target OS");
22359 }
22360 #[cfg(feature = "Win32_Foundation")]
22361 #[inline]
CryptStringToBinaryW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pszstring: Param0, cchstring: u32, dwflags: CRYPT_STRING, pbbinary: *mut u8, pcbbinary: *mut u32, pdwskip: *mut u32, pdwflags: *mut u32) -> super::super::Foundation::BOOL22362 pub unsafe fn CryptStringToBinaryW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pszstring: Param0, cchstring: u32, dwflags: CRYPT_STRING, pbbinary: *mut u8, pcbbinary: *mut u32, pdwskip: *mut u32, pdwflags: *mut u32) -> super::super::Foundation::BOOL {
22363     #[cfg(windows)]
22364     {
22365         #[link(name = "windows")]
22366         extern "system" {
22367             fn CryptStringToBinaryW(pszstring: super::super::Foundation::PWSTR, cchstring: u32, dwflags: CRYPT_STRING, pbbinary: *mut u8, pcbbinary: *mut u32, pdwskip: *mut u32, pdwflags: *mut u32) -> super::super::Foundation::BOOL;
22368         }
22369         ::std::mem::transmute(CryptStringToBinaryW(pszstring.into_param().abi(), ::std::mem::transmute(cchstring), ::std::mem::transmute(dwflags), ::std::mem::transmute(pbbinary), ::std::mem::transmute(pcbbinary), ::std::mem::transmute(pdwskip), ::std::mem::transmute(pdwflags)))
22370     }
22371     #[cfg(not(windows))]
22372     unimplemented!("Unsupported target OS");
22373 }
22374 #[cfg(feature = "Win32_Foundation")]
22375 #[inline]
CryptUIDlgCertMgr(pcryptuicertmgr: *const CRYPTUI_CERT_MGR_STRUCT) -> super::super::Foundation::BOOL22376 pub unsafe fn CryptUIDlgCertMgr(pcryptuicertmgr: *const CRYPTUI_CERT_MGR_STRUCT) -> super::super::Foundation::BOOL {
22377     #[cfg(windows)]
22378     {
22379         #[link(name = "windows")]
22380         extern "system" {
22381             fn CryptUIDlgCertMgr(pcryptuicertmgr: *const CRYPTUI_CERT_MGR_STRUCT) -> super::super::Foundation::BOOL;
22382         }
22383         ::std::mem::transmute(CryptUIDlgCertMgr(::std::mem::transmute(pcryptuicertmgr)))
22384     }
22385     #[cfg(not(windows))]
22386     unimplemented!("Unsupported target OS");
22387 }
22388 #[cfg(feature = "Win32_Foundation")]
22389 #[inline]
CryptUIDlgSelectCertificateFromStore<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hcertstore: *const ::std::ffi::c_void, hwnd: Param1, pwsztitle: Param2, pwszdisplaystring: Param3, dwdontusecolumn: u32, dwflags: u32, pvreserved: *const ::std::ffi::c_void) -> *mut CERT_CONTEXT22390 pub unsafe fn CryptUIDlgSelectCertificateFromStore<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hcertstore: *const ::std::ffi::c_void, hwnd: Param1, pwsztitle: Param2, pwszdisplaystring: Param3, dwdontusecolumn: u32, dwflags: u32, pvreserved: *const ::std::ffi::c_void) -> *mut CERT_CONTEXT {
22391     #[cfg(windows)]
22392     {
22393         #[link(name = "windows")]
22394         extern "system" {
22395             fn CryptUIDlgSelectCertificateFromStore(hcertstore: *const ::std::ffi::c_void, hwnd: super::super::Foundation::HWND, pwsztitle: super::super::Foundation::PWSTR, pwszdisplaystring: super::super::Foundation::PWSTR, dwdontusecolumn: u32, dwflags: u32, pvreserved: *const ::std::ffi::c_void) -> *mut CERT_CONTEXT;
22396         }
22397         ::std::mem::transmute(CryptUIDlgSelectCertificateFromStore(::std::mem::transmute(hcertstore), hwnd.into_param().abi(), pwsztitle.into_param().abi(), pwszdisplaystring.into_param().abi(), ::std::mem::transmute(dwdontusecolumn), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvreserved)))
22398     }
22399     #[cfg(not(windows))]
22400     unimplemented!("Unsupported target OS");
22401 }
22402 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
22403 #[inline]
CryptUIDlgViewCertificateA(pcertviewinfo: *const CRYPTUI_VIEWCERTIFICATE_STRUCTA, pfpropertieschanged: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL22404 pub unsafe fn CryptUIDlgViewCertificateA(pcertviewinfo: *const CRYPTUI_VIEWCERTIFICATE_STRUCTA, pfpropertieschanged: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL {
22405     #[cfg(windows)]
22406     {
22407         #[link(name = "windows")]
22408         extern "system" {
22409             fn CryptUIDlgViewCertificateA(pcertviewinfo: *const CRYPTUI_VIEWCERTIFICATE_STRUCTA, pfpropertieschanged: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL;
22410         }
22411         ::std::mem::transmute(CryptUIDlgViewCertificateA(::std::mem::transmute(pcertviewinfo), ::std::mem::transmute(pfpropertieschanged)))
22412     }
22413     #[cfg(not(windows))]
22414     unimplemented!("Unsupported target OS");
22415 }
22416 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip", feature = "Win32_Security_WinTrust", feature = "Win32_UI_Controls", feature = "Win32_UI_WindowsAndMessaging"))]
22417 #[inline]
CryptUIDlgViewCertificateW(pcertviewinfo: *const CRYPTUI_VIEWCERTIFICATE_STRUCTW, pfpropertieschanged: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL22418 pub unsafe fn CryptUIDlgViewCertificateW(pcertviewinfo: *const CRYPTUI_VIEWCERTIFICATE_STRUCTW, pfpropertieschanged: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL {
22419     #[cfg(windows)]
22420     {
22421         #[link(name = "windows")]
22422         extern "system" {
22423             fn CryptUIDlgViewCertificateW(pcertviewinfo: *const CRYPTUI_VIEWCERTIFICATE_STRUCTW, pfpropertieschanged: *mut super::super::Foundation::BOOL) -> super::super::Foundation::BOOL;
22424         }
22425         ::std::mem::transmute(CryptUIDlgViewCertificateW(::std::mem::transmute(pcertviewinfo), ::std::mem::transmute(pfpropertieschanged)))
22426     }
22427     #[cfg(not(windows))]
22428     unimplemented!("Unsupported target OS");
22429 }
22430 #[cfg(feature = "Win32_Foundation")]
22431 #[inline]
CryptUIDlgViewContext<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwcontexttype: u32, pvcontext: *const ::std::ffi::c_void, hwnd: Param2, pwsztitle: Param3, dwflags: u32, pvreserved: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL22432 pub unsafe fn CryptUIDlgViewContext<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwcontexttype: u32, pvcontext: *const ::std::ffi::c_void, hwnd: Param2, pwsztitle: Param3, dwflags: u32, pvreserved: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL {
22433     #[cfg(windows)]
22434     {
22435         #[link(name = "windows")]
22436         extern "system" {
22437             fn CryptUIDlgViewContext(dwcontexttype: u32, pvcontext: *const ::std::ffi::c_void, hwnd: super::super::Foundation::HWND, pwsztitle: super::super::Foundation::PWSTR, dwflags: u32, pvreserved: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
22438         }
22439         ::std::mem::transmute(CryptUIDlgViewContext(::std::mem::transmute(dwcontexttype), ::std::mem::transmute(pvcontext), hwnd.into_param().abi(), pwsztitle.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvreserved)))
22440     }
22441     #[cfg(not(windows))]
22442     unimplemented!("Unsupported target OS");
22443 }
22444 #[cfg(feature = "Win32_Foundation")]
22445 #[inline]
CryptUIWizDigitalSign<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwflags: u32, hwndparent: Param1, pwszwizardtitle: Param2, pdigitalsigninfo: *const CRYPTUI_WIZ_DIGITAL_SIGN_INFO, ppsigncontext: *mut *mut CRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT) -> super::super::Foundation::BOOL22446 pub unsafe fn CryptUIWizDigitalSign<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwflags: u32, hwndparent: Param1, pwszwizardtitle: Param2, pdigitalsigninfo: *const CRYPTUI_WIZ_DIGITAL_SIGN_INFO, ppsigncontext: *mut *mut CRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT) -> super::super::Foundation::BOOL {
22447     #[cfg(windows)]
22448     {
22449         #[link(name = "windows")]
22450         extern "system" {
22451             fn CryptUIWizDigitalSign(dwflags: u32, hwndparent: super::super::Foundation::HWND, pwszwizardtitle: super::super::Foundation::PWSTR, pdigitalsigninfo: *const CRYPTUI_WIZ_DIGITAL_SIGN_INFO, ppsigncontext: *mut *mut CRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT) -> super::super::Foundation::BOOL;
22452         }
22453         ::std::mem::transmute(CryptUIWizDigitalSign(::std::mem::transmute(dwflags), hwndparent.into_param().abi(), pwszwizardtitle.into_param().abi(), ::std::mem::transmute(pdigitalsigninfo), ::std::mem::transmute(ppsigncontext)))
22454     }
22455     #[cfg(not(windows))]
22456     unimplemented!("Unsupported target OS");
22457 }
22458 #[cfg(feature = "Win32_Foundation")]
22459 #[inline]
CryptUIWizExport<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwflags: CRYPTUI_WIZ_FLAGS, hwndparent: Param1, pwszwizardtitle: Param2, pexportinfo: *const CRYPTUI_WIZ_EXPORT_INFO, pvoid: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL22460 pub unsafe fn CryptUIWizExport<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwflags: CRYPTUI_WIZ_FLAGS, hwndparent: Param1, pwszwizardtitle: Param2, pexportinfo: *const CRYPTUI_WIZ_EXPORT_INFO, pvoid: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL {
22461     #[cfg(windows)]
22462     {
22463         #[link(name = "windows")]
22464         extern "system" {
22465             fn CryptUIWizExport(dwflags: CRYPTUI_WIZ_FLAGS, hwndparent: super::super::Foundation::HWND, pwszwizardtitle: super::super::Foundation::PWSTR, pexportinfo: *const CRYPTUI_WIZ_EXPORT_INFO, pvoid: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
22466         }
22467         ::std::mem::transmute(CryptUIWizExport(::std::mem::transmute(dwflags), hwndparent.into_param().abi(), pwszwizardtitle.into_param().abi(), ::std::mem::transmute(pexportinfo), ::std::mem::transmute(pvoid)))
22468     }
22469     #[cfg(not(windows))]
22470     unimplemented!("Unsupported target OS");
22471 }
22472 #[cfg(feature = "Win32_Foundation")]
22473 #[inline]
CryptUIWizFreeDigitalSignContext(psigncontext: *const CRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT) -> super::super::Foundation::BOOL22474 pub unsafe fn CryptUIWizFreeDigitalSignContext(psigncontext: *const CRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT) -> super::super::Foundation::BOOL {
22475     #[cfg(windows)]
22476     {
22477         #[link(name = "windows")]
22478         extern "system" {
22479             fn CryptUIWizFreeDigitalSignContext(psigncontext: *const CRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT) -> super::super::Foundation::BOOL;
22480         }
22481         ::std::mem::transmute(CryptUIWizFreeDigitalSignContext(::std::mem::transmute(psigncontext)))
22482     }
22483     #[cfg(not(windows))]
22484     unimplemented!("Unsupported target OS");
22485 }
22486 #[cfg(feature = "Win32_Foundation")]
22487 #[inline]
CryptUIWizImport<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwflags: CRYPTUI_WIZ_FLAGS, hwndparent: Param1, pwszwizardtitle: Param2, pimportsrc: *const CRYPTUI_WIZ_IMPORT_SRC_INFO, hdestcertstore: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL22488 pub unsafe fn CryptUIWizImport<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwflags: CRYPTUI_WIZ_FLAGS, hwndparent: Param1, pwszwizardtitle: Param2, pimportsrc: *const CRYPTUI_WIZ_IMPORT_SRC_INFO, hdestcertstore: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL {
22489     #[cfg(windows)]
22490     {
22491         #[link(name = "windows")]
22492         extern "system" {
22493             fn CryptUIWizImport(dwflags: CRYPTUI_WIZ_FLAGS, hwndparent: super::super::Foundation::HWND, pwszwizardtitle: super::super::Foundation::PWSTR, pimportsrc: *const CRYPTUI_WIZ_IMPORT_SRC_INFO, hdestcertstore: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
22494         }
22495         ::std::mem::transmute(CryptUIWizImport(::std::mem::transmute(dwflags), hwndparent.into_param().abi(), pwszwizardtitle.into_param().abi(), ::std::mem::transmute(pimportsrc), ::std::mem::transmute(hdestcertstore)))
22496     }
22497     #[cfg(not(windows))]
22498     unimplemented!("Unsupported target OS");
22499 }
22500 #[cfg(feature = "Win32_Foundation")]
22501 #[inline]
CryptUninstallCancelRetrieval(dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL22502 pub unsafe fn CryptUninstallCancelRetrieval(dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
22503     #[cfg(windows)]
22504     {
22505         #[link(name = "windows")]
22506         extern "system" {
22507             fn CryptUninstallCancelRetrieval(dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
22508         }
22509         ::std::mem::transmute(CryptUninstallCancelRetrieval(::std::mem::transmute(dwflags), ::std::mem::transmute(pvreserved)))
22510     }
22511     #[cfg(not(windows))]
22512     unimplemented!("Unsupported target OS");
22513 }
22514 #[cfg(feature = "Win32_Foundation")]
22515 #[inline]
CryptUninstallDefaultContext(hdefaultcontext: *const ::std::ffi::c_void, dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL22516 pub unsafe fn CryptUninstallDefaultContext(hdefaultcontext: *const ::std::ffi::c_void, dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
22517     #[cfg(windows)]
22518     {
22519         #[link(name = "windows")]
22520         extern "system" {
22521             fn CryptUninstallDefaultContext(hdefaultcontext: *const ::std::ffi::c_void, dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
22522         }
22523         ::std::mem::transmute(CryptUninstallDefaultContext(::std::mem::transmute(hdefaultcontext), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvreserved)))
22524     }
22525     #[cfg(not(windows))]
22526     unimplemented!("Unsupported target OS");
22527 }
22528 #[cfg(feature = "Win32_Foundation")]
22529 #[inline]
CryptUnprotectData(pdatain: *const CRYPTOAPI_BLOB, ppszdatadescr: *mut super::super::Foundation::PWSTR, poptionalentropy: *const CRYPTOAPI_BLOB, pvreserved: *mut ::std::ffi::c_void, ppromptstruct: *const CRYPTPROTECT_PROMPTSTRUCT, dwflags: u32, pdataout: *mut CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL22530 pub unsafe fn CryptUnprotectData(pdatain: *const CRYPTOAPI_BLOB, ppszdatadescr: *mut super::super::Foundation::PWSTR, poptionalentropy: *const CRYPTOAPI_BLOB, pvreserved: *mut ::std::ffi::c_void, ppromptstruct: *const CRYPTPROTECT_PROMPTSTRUCT, dwflags: u32, pdataout: *mut CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL {
22531     #[cfg(windows)]
22532     {
22533         #[link(name = "windows")]
22534         extern "system" {
22535             fn CryptUnprotectData(pdatain: *const CRYPTOAPI_BLOB, ppszdatadescr: *mut super::super::Foundation::PWSTR, poptionalentropy: *const CRYPTOAPI_BLOB, pvreserved: *mut ::std::ffi::c_void, ppromptstruct: *const CRYPTPROTECT_PROMPTSTRUCT, dwflags: u32, pdataout: *mut CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL;
22536         }
22537         ::std::mem::transmute(CryptUnprotectData(::std::mem::transmute(pdatain), ::std::mem::transmute(ppszdatadescr), ::std::mem::transmute(poptionalentropy), ::std::mem::transmute(pvreserved), ::std::mem::transmute(ppromptstruct), ::std::mem::transmute(dwflags), ::std::mem::transmute(pdataout)))
22538     }
22539     #[cfg(not(windows))]
22540     unimplemented!("Unsupported target OS");
22541 }
22542 #[cfg(feature = "Win32_Foundation")]
22543 #[inline]
CryptUnprotectMemory(pdatain: *mut ::std::ffi::c_void, cbdatain: u32, dwflags: u32) -> super::super::Foundation::BOOL22544 pub unsafe fn CryptUnprotectMemory(pdatain: *mut ::std::ffi::c_void, cbdatain: u32, dwflags: u32) -> super::super::Foundation::BOOL {
22545     #[cfg(windows)]
22546     {
22547         #[link(name = "windows")]
22548         extern "system" {
22549             fn CryptUnprotectMemory(pdatain: *mut ::std::ffi::c_void, cbdatain: u32, dwflags: u32) -> super::super::Foundation::BOOL;
22550         }
22551         ::std::mem::transmute(CryptUnprotectMemory(::std::mem::transmute(pdatain), ::std::mem::transmute(cbdatain), ::std::mem::transmute(dwflags)))
22552     }
22553     #[cfg(not(windows))]
22554     unimplemented!("Unsupported target OS");
22555 }
22556 #[cfg(feature = "Win32_Foundation")]
22557 #[inline]
CryptUnregisterDefaultOIDFunction<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwencodingtype: u32, pszfuncname: Param1, pwszdll: Param2) -> super::super::Foundation::BOOL22558 pub unsafe fn CryptUnregisterDefaultOIDFunction<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwencodingtype: u32, pszfuncname: Param1, pwszdll: Param2) -> super::super::Foundation::BOOL {
22559     #[cfg(windows)]
22560     {
22561         #[link(name = "windows")]
22562         extern "system" {
22563             fn CryptUnregisterDefaultOIDFunction(dwencodingtype: u32, pszfuncname: super::super::Foundation::PSTR, pwszdll: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
22564         }
22565         ::std::mem::transmute(CryptUnregisterDefaultOIDFunction(::std::mem::transmute(dwencodingtype), pszfuncname.into_param().abi(), pwszdll.into_param().abi()))
22566     }
22567     #[cfg(not(windows))]
22568     unimplemented!("Unsupported target OS");
22569 }
22570 #[cfg(feature = "Win32_Foundation")]
22571 #[inline]
CryptUnregisterOIDFunction<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwencodingtype: u32, pszfuncname: Param1, pszoid: Param2) -> super::super::Foundation::BOOL22572 pub unsafe fn CryptUnregisterOIDFunction<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwencodingtype: u32, pszfuncname: Param1, pszoid: Param2) -> super::super::Foundation::BOOL {
22573     #[cfg(windows)]
22574     {
22575         #[link(name = "windows")]
22576         extern "system" {
22577             fn CryptUnregisterOIDFunction(dwencodingtype: u32, pszfuncname: super::super::Foundation::PSTR, pszoid: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
22578         }
22579         ::std::mem::transmute(CryptUnregisterOIDFunction(::std::mem::transmute(dwencodingtype), pszfuncname.into_param().abi(), pszoid.into_param().abi()))
22580     }
22581     #[cfg(not(windows))]
22582     unimplemented!("Unsupported target OS");
22583 }
22584 #[cfg(feature = "Win32_Foundation")]
22585 #[inline]
CryptUnregisterOIDInfo(pinfo: *const CRYPT_OID_INFO) -> super::super::Foundation::BOOL22586 pub unsafe fn CryptUnregisterOIDInfo(pinfo: *const CRYPT_OID_INFO) -> super::super::Foundation::BOOL {
22587     #[cfg(windows)]
22588     {
22589         #[link(name = "windows")]
22590         extern "system" {
22591             fn CryptUnregisterOIDInfo(pinfo: *const CRYPT_OID_INFO) -> super::super::Foundation::BOOL;
22592         }
22593         ::std::mem::transmute(CryptUnregisterOIDInfo(::std::mem::transmute(pinfo)))
22594     }
22595     #[cfg(not(windows))]
22596     unimplemented!("Unsupported target OS");
22597 }
22598 #[cfg(feature = "Win32_Foundation")]
22599 #[inline]
CryptUpdateProtectedState<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSID>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(poldsid: Param0, pwszoldpassword: Param1, dwflags: u32, pdwsuccesscount: *mut u32, pdwfailurecount: *mut u32) -> super::super::Foundation::BOOL22600 pub unsafe fn CryptUpdateProtectedState<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSID>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(poldsid: Param0, pwszoldpassword: Param1, dwflags: u32, pdwsuccesscount: *mut u32, pdwfailurecount: *mut u32) -> super::super::Foundation::BOOL {
22601     #[cfg(windows)]
22602     {
22603         #[link(name = "windows")]
22604         extern "system" {
22605             fn CryptUpdateProtectedState(poldsid: super::super::Foundation::PSID, pwszoldpassword: super::super::Foundation::PWSTR, dwflags: u32, pdwsuccesscount: *mut u32, pdwfailurecount: *mut u32) -> super::super::Foundation::BOOL;
22606         }
22607         ::std::mem::transmute(CryptUpdateProtectedState(poldsid.into_param().abi(), pwszoldpassword.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(pdwsuccesscount), ::std::mem::transmute(pdwfailurecount)))
22608     }
22609     #[cfg(not(windows))]
22610     unimplemented!("Unsupported target OS");
22611 }
22612 #[cfg(feature = "Win32_Foundation")]
22613 #[inline]
CryptVerifyCertificateSignature(hcryptprov: usize, dwcertencodingtype: u32, pbencoded: *const u8, cbencoded: u32, ppublickey: *const CERT_PUBLIC_KEY_INFO) -> super::super::Foundation::BOOL22614 pub unsafe fn CryptVerifyCertificateSignature(hcryptprov: usize, dwcertencodingtype: u32, pbencoded: *const u8, cbencoded: u32, ppublickey: *const CERT_PUBLIC_KEY_INFO) -> super::super::Foundation::BOOL {
22615     #[cfg(windows)]
22616     {
22617         #[link(name = "windows")]
22618         extern "system" {
22619             fn CryptVerifyCertificateSignature(hcryptprov: usize, dwcertencodingtype: u32, pbencoded: *const u8, cbencoded: u32, ppublickey: *const CERT_PUBLIC_KEY_INFO) -> super::super::Foundation::BOOL;
22620         }
22621         ::std::mem::transmute(CryptVerifyCertificateSignature(::std::mem::transmute(hcryptprov), ::std::mem::transmute(dwcertencodingtype), ::std::mem::transmute(pbencoded), ::std::mem::transmute(cbencoded), ::std::mem::transmute(ppublickey)))
22622     }
22623     #[cfg(not(windows))]
22624     unimplemented!("Unsupported target OS");
22625 }
22626 #[cfg(feature = "Win32_Foundation")]
22627 #[inline]
CryptVerifyCertificateSignatureEx(hcryptprov: usize, dwcertencodingtype: u32, dwsubjecttype: u32, pvsubject: *const ::std::ffi::c_void, dwissuertype: u32, pvissuer: *const ::std::ffi::c_void, dwflags: CRYPT_VERIFY_CERT_FLAGS, pvextra: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL22628 pub unsafe fn CryptVerifyCertificateSignatureEx(hcryptprov: usize, dwcertencodingtype: u32, dwsubjecttype: u32, pvsubject: *const ::std::ffi::c_void, dwissuertype: u32, pvissuer: *const ::std::ffi::c_void, dwflags: CRYPT_VERIFY_CERT_FLAGS, pvextra: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
22629     #[cfg(windows)]
22630     {
22631         #[link(name = "windows")]
22632         extern "system" {
22633             fn CryptVerifyCertificateSignatureEx(hcryptprov: usize, dwcertencodingtype: u32, dwsubjecttype: u32, pvsubject: *const ::std::ffi::c_void, dwissuertype: u32, pvissuer: *const ::std::ffi::c_void, dwflags: CRYPT_VERIFY_CERT_FLAGS, pvextra: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
22634         }
22635         ::std::mem::transmute(CryptVerifyCertificateSignatureEx(
22636             ::std::mem::transmute(hcryptprov),
22637             ::std::mem::transmute(dwcertencodingtype),
22638             ::std::mem::transmute(dwsubjecttype),
22639             ::std::mem::transmute(pvsubject),
22640             ::std::mem::transmute(dwissuertype),
22641             ::std::mem::transmute(pvissuer),
22642             ::std::mem::transmute(dwflags),
22643             ::std::mem::transmute(pvextra),
22644         ))
22645     }
22646     #[cfg(not(windows))]
22647     unimplemented!("Unsupported target OS");
22648 }
22649 #[cfg(feature = "Win32_Foundation")]
22650 #[inline]
CryptVerifyDetachedMessageHash(phashpara: *const CRYPT_HASH_MESSAGE_PARA, pbdetachedhashblob: *const u8, cbdetachedhashblob: u32, ctobehashed: u32, rgpbtobehashed: *const *const u8, rgcbtobehashed: *const u32, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL22651 pub unsafe fn CryptVerifyDetachedMessageHash(phashpara: *const CRYPT_HASH_MESSAGE_PARA, pbdetachedhashblob: *const u8, cbdetachedhashblob: u32, ctobehashed: u32, rgpbtobehashed: *const *const u8, rgcbtobehashed: *const u32, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL {
22652     #[cfg(windows)]
22653     {
22654         #[link(name = "windows")]
22655         extern "system" {
22656             fn CryptVerifyDetachedMessageHash(phashpara: *const CRYPT_HASH_MESSAGE_PARA, pbdetachedhashblob: *const u8, cbdetachedhashblob: u32, ctobehashed: u32, rgpbtobehashed: *const *const u8, rgcbtobehashed: *const u32, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL;
22657         }
22658         ::std::mem::transmute(CryptVerifyDetachedMessageHash(
22659             ::std::mem::transmute(phashpara),
22660             ::std::mem::transmute(pbdetachedhashblob),
22661             ::std::mem::transmute(cbdetachedhashblob),
22662             ::std::mem::transmute(ctobehashed),
22663             ::std::mem::transmute(rgpbtobehashed),
22664             ::std::mem::transmute(rgcbtobehashed),
22665             ::std::mem::transmute(pbcomputedhash),
22666             ::std::mem::transmute(pcbcomputedhash),
22667         ))
22668     }
22669     #[cfg(not(windows))]
22670     unimplemented!("Unsupported target OS");
22671 }
22672 #[cfg(feature = "Win32_Foundation")]
22673 #[inline]
CryptVerifyDetachedMessageSignature(pverifypara: *const CRYPT_VERIFY_MESSAGE_PARA, dwsignerindex: u32, pbdetachedsignblob: *const u8, cbdetachedsignblob: u32, ctobesigned: u32, rgpbtobesigned: *const *const u8, rgcbtobesigned: *const u32, ppsignercert: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL22674 pub unsafe fn CryptVerifyDetachedMessageSignature(pverifypara: *const CRYPT_VERIFY_MESSAGE_PARA, dwsignerindex: u32, pbdetachedsignblob: *const u8, cbdetachedsignblob: u32, ctobesigned: u32, rgpbtobesigned: *const *const u8, rgcbtobesigned: *const u32, ppsignercert: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL {
22675     #[cfg(windows)]
22676     {
22677         #[link(name = "windows")]
22678         extern "system" {
22679             fn CryptVerifyDetachedMessageSignature(pverifypara: *const ::std::mem::ManuallyDrop<CRYPT_VERIFY_MESSAGE_PARA>, dwsignerindex: u32, pbdetachedsignblob: *const u8, cbdetachedsignblob: u32, ctobesigned: u32, rgpbtobesigned: *const *const u8, rgcbtobesigned: *const u32, ppsignercert: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL;
22680         }
22681         ::std::mem::transmute(CryptVerifyDetachedMessageSignature(
22682             ::std::mem::transmute(pverifypara),
22683             ::std::mem::transmute(dwsignerindex),
22684             ::std::mem::transmute(pbdetachedsignblob),
22685             ::std::mem::transmute(cbdetachedsignblob),
22686             ::std::mem::transmute(ctobesigned),
22687             ::std::mem::transmute(rgpbtobesigned),
22688             ::std::mem::transmute(rgcbtobesigned),
22689             ::std::mem::transmute(ppsignercert),
22690         ))
22691     }
22692     #[cfg(not(windows))]
22693     unimplemented!("Unsupported target OS");
22694 }
22695 #[cfg(feature = "Win32_Foundation")]
22696 #[inline]
CryptVerifyMessageHash(phashpara: *const CRYPT_HASH_MESSAGE_PARA, pbhashedblob: *const u8, cbhashedblob: u32, pbtobehashed: *mut u8, pcbtobehashed: *mut u32, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL22697 pub unsafe fn CryptVerifyMessageHash(phashpara: *const CRYPT_HASH_MESSAGE_PARA, pbhashedblob: *const u8, cbhashedblob: u32, pbtobehashed: *mut u8, pcbtobehashed: *mut u32, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL {
22698     #[cfg(windows)]
22699     {
22700         #[link(name = "windows")]
22701         extern "system" {
22702             fn CryptVerifyMessageHash(phashpara: *const CRYPT_HASH_MESSAGE_PARA, pbhashedblob: *const u8, cbhashedblob: u32, pbtobehashed: *mut u8, pcbtobehashed: *mut u32, pbcomputedhash: *mut u8, pcbcomputedhash: *mut u32) -> super::super::Foundation::BOOL;
22703         }
22704         ::std::mem::transmute(CryptVerifyMessageHash(::std::mem::transmute(phashpara), ::std::mem::transmute(pbhashedblob), ::std::mem::transmute(cbhashedblob), ::std::mem::transmute(pbtobehashed), ::std::mem::transmute(pcbtobehashed), ::std::mem::transmute(pbcomputedhash), ::std::mem::transmute(pcbcomputedhash)))
22705     }
22706     #[cfg(not(windows))]
22707     unimplemented!("Unsupported target OS");
22708 }
22709 #[cfg(feature = "Win32_Foundation")]
22710 #[inline]
CryptVerifyMessageSignature(pverifypara: *const CRYPT_VERIFY_MESSAGE_PARA, dwsignerindex: u32, pbsignedblob: *const u8, cbsignedblob: u32, pbdecoded: *mut u8, pcbdecoded: *mut u32, ppsignercert: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL22711 pub unsafe fn CryptVerifyMessageSignature(pverifypara: *const CRYPT_VERIFY_MESSAGE_PARA, dwsignerindex: u32, pbsignedblob: *const u8, cbsignedblob: u32, pbdecoded: *mut u8, pcbdecoded: *mut u32, ppsignercert: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL {
22712     #[cfg(windows)]
22713     {
22714         #[link(name = "windows")]
22715         extern "system" {
22716             fn CryptVerifyMessageSignature(pverifypara: *const ::std::mem::ManuallyDrop<CRYPT_VERIFY_MESSAGE_PARA>, dwsignerindex: u32, pbsignedblob: *const u8, cbsignedblob: u32, pbdecoded: *mut u8, pcbdecoded: *mut u32, ppsignercert: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL;
22717         }
22718         ::std::mem::transmute(CryptVerifyMessageSignature(::std::mem::transmute(pverifypara), ::std::mem::transmute(dwsignerindex), ::std::mem::transmute(pbsignedblob), ::std::mem::transmute(cbsignedblob), ::std::mem::transmute(pbdecoded), ::std::mem::transmute(pcbdecoded), ::std::mem::transmute(ppsignercert)))
22719     }
22720     #[cfg(not(windows))]
22721     unimplemented!("Unsupported target OS");
22722 }
22723 #[cfg(feature = "Win32_Foundation")]
22724 #[inline]
CryptVerifyMessageSignatureWithKey(pverifypara: *const CRYPT_KEY_VERIFY_MESSAGE_PARA, ppublickeyinfo: *const CERT_PUBLIC_KEY_INFO, pbsignedblob: *const u8, cbsignedblob: u32, pbdecoded: *mut u8, pcbdecoded: *mut u32) -> super::super::Foundation::BOOL22725 pub unsafe fn CryptVerifyMessageSignatureWithKey(pverifypara: *const CRYPT_KEY_VERIFY_MESSAGE_PARA, ppublickeyinfo: *const CERT_PUBLIC_KEY_INFO, pbsignedblob: *const u8, cbsignedblob: u32, pbdecoded: *mut u8, pcbdecoded: *mut u32) -> super::super::Foundation::BOOL {
22726     #[cfg(windows)]
22727     {
22728         #[link(name = "windows")]
22729         extern "system" {
22730             fn CryptVerifyMessageSignatureWithKey(pverifypara: *const CRYPT_KEY_VERIFY_MESSAGE_PARA, ppublickeyinfo: *const CERT_PUBLIC_KEY_INFO, pbsignedblob: *const u8, cbsignedblob: u32, pbdecoded: *mut u8, pcbdecoded: *mut u32) -> super::super::Foundation::BOOL;
22731         }
22732         ::std::mem::transmute(CryptVerifyMessageSignatureWithKey(::std::mem::transmute(pverifypara), ::std::mem::transmute(ppublickeyinfo), ::std::mem::transmute(pbsignedblob), ::std::mem::transmute(cbsignedblob), ::std::mem::transmute(pbdecoded), ::std::mem::transmute(pcbdecoded)))
22733     }
22734     #[cfg(not(windows))]
22735     unimplemented!("Unsupported target OS");
22736 }
22737 #[cfg(feature = "Win32_Foundation")]
22738 #[inline]
CryptVerifySignatureA<'a, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hhash: usize, pbsignature: *const u8, dwsiglen: u32, hpubkey: usize, szdescription: Param4, dwflags: u32) -> super::super::Foundation::BOOL22739 pub unsafe fn CryptVerifySignatureA<'a, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hhash: usize, pbsignature: *const u8, dwsiglen: u32, hpubkey: usize, szdescription: Param4, dwflags: u32) -> super::super::Foundation::BOOL {
22740     #[cfg(windows)]
22741     {
22742         #[link(name = "windows")]
22743         extern "system" {
22744             fn CryptVerifySignatureA(hhash: usize, pbsignature: *const u8, dwsiglen: u32, hpubkey: usize, szdescription: super::super::Foundation::PSTR, dwflags: u32) -> super::super::Foundation::BOOL;
22745         }
22746         ::std::mem::transmute(CryptVerifySignatureA(::std::mem::transmute(hhash), ::std::mem::transmute(pbsignature), ::std::mem::transmute(dwsiglen), ::std::mem::transmute(hpubkey), szdescription.into_param().abi(), ::std::mem::transmute(dwflags)))
22747     }
22748     #[cfg(not(windows))]
22749     unimplemented!("Unsupported target OS");
22750 }
22751 #[cfg(feature = "Win32_Foundation")]
22752 #[inline]
CryptVerifySignatureW<'a, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hhash: usize, pbsignature: *const u8, dwsiglen: u32, hpubkey: usize, szdescription: Param4, dwflags: u32) -> super::super::Foundation::BOOL22753 pub unsafe fn CryptVerifySignatureW<'a, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hhash: usize, pbsignature: *const u8, dwsiglen: u32, hpubkey: usize, szdescription: Param4, dwflags: u32) -> super::super::Foundation::BOOL {
22754     #[cfg(windows)]
22755     {
22756         #[link(name = "windows")]
22757         extern "system" {
22758             fn CryptVerifySignatureW(hhash: usize, pbsignature: *const u8, dwsiglen: u32, hpubkey: usize, szdescription: super::super::Foundation::PWSTR, dwflags: u32) -> super::super::Foundation::BOOL;
22759         }
22760         ::std::mem::transmute(CryptVerifySignatureW(::std::mem::transmute(hhash), ::std::mem::transmute(pbsignature), ::std::mem::transmute(dwsiglen), ::std::mem::transmute(hpubkey), szdescription.into_param().abi(), ::std::mem::transmute(dwflags)))
22761     }
22762     #[cfg(not(windows))]
22763     unimplemented!("Unsupported target OS");
22764 }
22765 #[cfg(feature = "Win32_Foundation")]
22766 #[inline]
CryptVerifyTimeStampSignature(pbtscontentinfo: *const u8, cbtscontentinfo: u32, pbdata: *const u8, cbdata: u32, hadditionalstore: *const ::std::ffi::c_void, pptscontext: *mut *mut CRYPT_TIMESTAMP_CONTEXT, pptssigner: *mut *mut CERT_CONTEXT, phstore: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL22767 pub unsafe fn CryptVerifyTimeStampSignature(pbtscontentinfo: *const u8, cbtscontentinfo: u32, pbdata: *const u8, cbdata: u32, hadditionalstore: *const ::std::ffi::c_void, pptscontext: *mut *mut CRYPT_TIMESTAMP_CONTEXT, pptssigner: *mut *mut CERT_CONTEXT, phstore: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
22768     #[cfg(windows)]
22769     {
22770         #[link(name = "windows")]
22771         extern "system" {
22772             fn CryptVerifyTimeStampSignature(pbtscontentinfo: *const u8, cbtscontentinfo: u32, pbdata: *const u8, cbdata: u32, hadditionalstore: *const ::std::ffi::c_void, pptscontext: *mut *mut CRYPT_TIMESTAMP_CONTEXT, pptssigner: *mut *mut CERT_CONTEXT, phstore: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
22773         }
22774         ::std::mem::transmute(CryptVerifyTimeStampSignature(
22775             ::std::mem::transmute(pbtscontentinfo),
22776             ::std::mem::transmute(cbtscontentinfo),
22777             ::std::mem::transmute(pbdata),
22778             ::std::mem::transmute(cbdata),
22779             ::std::mem::transmute(hadditionalstore),
22780             ::std::mem::transmute(pptscontext),
22781             ::std::mem::transmute(pptssigner),
22782             ::std::mem::transmute(phstore),
22783         ))
22784     }
22785     #[cfg(not(windows))]
22786     unimplemented!("Unsupported target OS");
22787 }
22788 #[cfg(feature = "Win32_Foundation")]
22789 #[inline]
CryptXmlAddObject(hsignatureorobject: *const ::std::ffi::c_void, dwflags: u32, rgproperty: *const CRYPT_XML_PROPERTY, cproperty: u32, pencoded: *const CRYPT_XML_BLOB) -> ::windows::runtime::Result<*mut CRYPT_XML_OBJECT>22790 pub unsafe fn CryptXmlAddObject(hsignatureorobject: *const ::std::ffi::c_void, dwflags: u32, rgproperty: *const CRYPT_XML_PROPERTY, cproperty: u32, pencoded: *const CRYPT_XML_BLOB) -> ::windows::runtime::Result<*mut CRYPT_XML_OBJECT> {
22791     #[cfg(windows)]
22792     {
22793         #[link(name = "windows")]
22794         extern "system" {
22795             fn CryptXmlAddObject(hsignatureorobject: *const ::std::ffi::c_void, dwflags: u32, rgproperty: *const CRYPT_XML_PROPERTY, cproperty: u32, pencoded: *const CRYPT_XML_BLOB, ppobject: *mut *mut CRYPT_XML_OBJECT) -> ::windows::runtime::HRESULT;
22796         }
22797         let mut result__: <*mut CRYPT_XML_OBJECT as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
22798         CryptXmlAddObject(::std::mem::transmute(hsignatureorobject), ::std::mem::transmute(dwflags), ::std::mem::transmute(rgproperty), ::std::mem::transmute(cproperty), ::std::mem::transmute(pencoded), &mut result__).from_abi::<*mut CRYPT_XML_OBJECT>(result__)
22799     }
22800     #[cfg(not(windows))]
22801     unimplemented!("Unsupported target OS");
22802 }
22803 #[inline]
CryptXmlClose(hcryptxml: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()>22804 pub unsafe fn CryptXmlClose(hcryptxml: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
22805     #[cfg(windows)]
22806     {
22807         #[link(name = "windows")]
22808         extern "system" {
22809             fn CryptXmlClose(hcryptxml: *const ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
22810         }
22811         CryptXmlClose(::std::mem::transmute(hcryptxml)).ok()
22812     }
22813     #[cfg(not(windows))]
22814     unimplemented!("Unsupported target OS");
22815 }
22816 #[cfg(feature = "Win32_Foundation")]
22817 #[inline]
CryptXmlCreateReference<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>( hcryptxml: *const ::std::ffi::c_void, dwflags: u32, wszid: Param2, wszuri: Param3, wsztype: Param4, pdigestmethod: *const CRYPT_XML_ALGORITHM, ctransform: u32, rgtransform: *const CRYPT_XML_ALGORITHM, phreference: *mut *mut ::std::ffi::c_void, ) -> ::windows::runtime::Result<()>22818 pub unsafe fn CryptXmlCreateReference<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(
22819     hcryptxml: *const ::std::ffi::c_void,
22820     dwflags: u32,
22821     wszid: Param2,
22822     wszuri: Param3,
22823     wsztype: Param4,
22824     pdigestmethod: *const CRYPT_XML_ALGORITHM,
22825     ctransform: u32,
22826     rgtransform: *const CRYPT_XML_ALGORITHM,
22827     phreference: *mut *mut ::std::ffi::c_void,
22828 ) -> ::windows::runtime::Result<()> {
22829     #[cfg(windows)]
22830     {
22831         #[link(name = "windows")]
22832         extern "system" {
22833             fn CryptXmlCreateReference(hcryptxml: *const ::std::ffi::c_void, dwflags: u32, wszid: super::super::Foundation::PWSTR, wszuri: super::super::Foundation::PWSTR, wsztype: super::super::Foundation::PWSTR, pdigestmethod: *const CRYPT_XML_ALGORITHM, ctransform: u32, rgtransform: *const CRYPT_XML_ALGORITHM, phreference: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
22834         }
22835         CryptXmlCreateReference(::std::mem::transmute(hcryptxml), ::std::mem::transmute(dwflags), wszid.into_param().abi(), wszuri.into_param().abi(), wsztype.into_param().abi(), ::std::mem::transmute(pdigestmethod), ::std::mem::transmute(ctransform), ::std::mem::transmute(rgtransform), ::std::mem::transmute(phreference)).ok()
22836     }
22837     #[cfg(not(windows))]
22838     unimplemented!("Unsupported target OS");
22839 }
22840 #[inline]
CryptXmlDigestReference(hreference: *const ::std::ffi::c_void, dwflags: u32, pdataproviderin: *const CRYPT_XML_DATA_PROVIDER) -> ::windows::runtime::Result<()>22841 pub unsafe fn CryptXmlDigestReference(hreference: *const ::std::ffi::c_void, dwflags: u32, pdataproviderin: *const CRYPT_XML_DATA_PROVIDER) -> ::windows::runtime::Result<()> {
22842     #[cfg(windows)]
22843     {
22844         #[link(name = "windows")]
22845         extern "system" {
22846             fn CryptXmlDigestReference(hreference: *const ::std::ffi::c_void, dwflags: u32, pdataproviderin: *const ::std::mem::ManuallyDrop<CRYPT_XML_DATA_PROVIDER>) -> ::windows::runtime::HRESULT;
22847         }
22848         CryptXmlDigestReference(::std::mem::transmute(hreference), ::std::mem::transmute(dwflags), ::std::mem::transmute(pdataproviderin)).ok()
22849     }
22850     #[cfg(not(windows))]
22851     unimplemented!("Unsupported target OS");
22852 }
22853 pub type CryptXmlDllCloseDigest = unsafe extern "system" fn(hdigest: *const ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
22854 #[cfg(feature = "Win32_Foundation")]
22855 pub type CryptXmlDllCreateDigest = unsafe extern "system" fn(pdigestmethod: *const CRYPT_XML_ALGORITHM, pcbsize: *mut u32, phdigest: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
22856 pub type CryptXmlDllCreateKey = unsafe extern "system" fn(pencoded: *const CRYPT_XML_BLOB, phkey: *mut BCRYPT_KEY_HANDLE) -> ::windows::runtime::HRESULT;
22857 pub type CryptXmlDllDigestData = unsafe extern "system" fn(hdigest: *const ::std::ffi::c_void, pbdata: *const u8, cbdata: u32) -> ::windows::runtime::HRESULT;
22858 #[cfg(feature = "Win32_Foundation")]
22859 pub type CryptXmlDllEncodeAlgorithm = unsafe extern "system" fn(palginfo: *const CRYPT_XML_ALGORITHM_INFO, dwcharset: CRYPT_XML_CHARSET, pvcallbackstate: *mut ::std::ffi::c_void, pfnwrite: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT;
22860 pub type CryptXmlDllEncodeKeyValue = unsafe extern "system" fn(hkey: usize, dwcharset: CRYPT_XML_CHARSET, pvcallbackstate: *mut ::std::ffi::c_void, pfnwrite: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT;
22861 pub type CryptXmlDllFinalizeDigest = unsafe extern "system" fn(hdigest: *const ::std::ffi::c_void, pbdigest: *mut u8, cbdigest: u32) -> ::windows::runtime::HRESULT;
22862 #[cfg(feature = "Win32_Foundation")]
22863 pub type CryptXmlDllGetAlgorithmInfo = unsafe extern "system" fn(pxmlalgorithm: *const CRYPT_XML_ALGORITHM, ppalginfo: *mut *mut CRYPT_XML_ALGORITHM_INFO) -> ::windows::runtime::HRESULT;
22864 #[cfg(feature = "Win32_Foundation")]
22865 pub type CryptXmlDllGetInterface = unsafe extern "system" fn(dwflags: u32, pmethod: *const CRYPT_XML_ALGORITHM_INFO, pinterface: *mut ::std::mem::ManuallyDrop<CRYPT_XML_CRYPTOGRAPHIC_INTERFACE>) -> ::windows::runtime::HRESULT;
22866 #[cfg(feature = "Win32_Foundation")]
22867 pub type CryptXmlDllSignData = unsafe extern "system" fn(psignaturemethod: *const CRYPT_XML_ALGORITHM, hcryptprovorncryptkey: usize, dwkeyspec: u32, pbinput: *const u8, cbinput: u32, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32) -> ::windows::runtime::HRESULT;
22868 #[cfg(feature = "Win32_Foundation")]
22869 pub type CryptXmlDllVerifySignature = unsafe extern "system" fn(psignaturemethod: *const CRYPT_XML_ALGORITHM, hkey: BCRYPT_KEY_HANDLE, pbinput: *const u8, cbinput: u32, pbsignature: *const u8, cbsignature: u32) -> ::windows::runtime::HRESULT;
22870 #[inline]
CryptXmlEncode(hcryptxml: *const ::std::ffi::c_void, dwcharset: CRYPT_XML_CHARSET, rgproperty: *const CRYPT_XML_PROPERTY, cproperty: u32, pvcallbackstate: *mut ::std::ffi::c_void, pfnwrite: ::std::option::Option<PFN_CRYPT_XML_WRITE_CALLBACK>) -> ::windows::runtime::Result<()>22871 pub unsafe fn CryptXmlEncode(hcryptxml: *const ::std::ffi::c_void, dwcharset: CRYPT_XML_CHARSET, rgproperty: *const CRYPT_XML_PROPERTY, cproperty: u32, pvcallbackstate: *mut ::std::ffi::c_void, pfnwrite: ::std::option::Option<PFN_CRYPT_XML_WRITE_CALLBACK>) -> ::windows::runtime::Result<()> {
22872     #[cfg(windows)]
22873     {
22874         #[link(name = "windows")]
22875         extern "system" {
22876             fn CryptXmlEncode(hcryptxml: *const ::std::ffi::c_void, dwcharset: CRYPT_XML_CHARSET, rgproperty: *const CRYPT_XML_PROPERTY, cproperty: u32, pvcallbackstate: *mut ::std::ffi::c_void, pfnwrite: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT;
22877         }
22878         CryptXmlEncode(::std::mem::transmute(hcryptxml), ::std::mem::transmute(dwcharset), ::std::mem::transmute(rgproperty), ::std::mem::transmute(cproperty), ::std::mem::transmute(pvcallbackstate), ::std::mem::transmute(pfnwrite)).ok()
22879     }
22880     #[cfg(not(windows))]
22881     unimplemented!("Unsupported target OS");
22882 }
22883 #[cfg(feature = "Win32_Foundation")]
22884 #[inline]
CryptXmlEnumAlgorithmInfo(dwgroupid: u32, dwflags: u32, pvarg: *mut ::std::ffi::c_void, pfnenumalginfo: ::std::option::Option<PFN_CRYPT_XML_ENUM_ALG_INFO>) -> ::windows::runtime::Result<()>22885 pub unsafe fn CryptXmlEnumAlgorithmInfo(dwgroupid: u32, dwflags: u32, pvarg: *mut ::std::ffi::c_void, pfnenumalginfo: ::std::option::Option<PFN_CRYPT_XML_ENUM_ALG_INFO>) -> ::windows::runtime::Result<()> {
22886     #[cfg(windows)]
22887     {
22888         #[link(name = "windows")]
22889         extern "system" {
22890             fn CryptXmlEnumAlgorithmInfo(dwgroupid: u32, dwflags: u32, pvarg: *mut ::std::ffi::c_void, pfnenumalginfo: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT;
22891         }
22892         CryptXmlEnumAlgorithmInfo(::std::mem::transmute(dwgroupid), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvarg), ::std::mem::transmute(pfnenumalginfo)).ok()
22893     }
22894     #[cfg(not(windows))]
22895     unimplemented!("Unsupported target OS");
22896 }
22897 #[cfg(feature = "Win32_Foundation")]
22898 #[inline]
CryptXmlFindAlgorithmInfo(dwfindbytype: u32, pvfindby: *const ::std::ffi::c_void, dwgroupid: u32, dwflags: u32) -> *mut CRYPT_XML_ALGORITHM_INFO22899 pub unsafe fn CryptXmlFindAlgorithmInfo(dwfindbytype: u32, pvfindby: *const ::std::ffi::c_void, dwgroupid: u32, dwflags: u32) -> *mut CRYPT_XML_ALGORITHM_INFO {
22900     #[cfg(windows)]
22901     {
22902         #[link(name = "windows")]
22903         extern "system" {
22904             fn CryptXmlFindAlgorithmInfo(dwfindbytype: u32, pvfindby: *const ::std::ffi::c_void, dwgroupid: u32, dwflags: u32) -> *mut CRYPT_XML_ALGORITHM_INFO;
22905         }
22906         ::std::mem::transmute(CryptXmlFindAlgorithmInfo(::std::mem::transmute(dwfindbytype), ::std::mem::transmute(pvfindby), ::std::mem::transmute(dwgroupid), ::std::mem::transmute(dwflags)))
22907     }
22908     #[cfg(not(windows))]
22909     unimplemented!("Unsupported target OS");
22910 }
22911 #[cfg(feature = "Win32_Foundation")]
22912 #[inline]
CryptXmlGetAlgorithmInfo(pxmlalgorithm: *const CRYPT_XML_ALGORITHM, dwflags: CRYPT_XML_FLAGS) -> ::windows::runtime::Result<*mut CRYPT_XML_ALGORITHM_INFO>22913 pub unsafe fn CryptXmlGetAlgorithmInfo(pxmlalgorithm: *const CRYPT_XML_ALGORITHM, dwflags: CRYPT_XML_FLAGS) -> ::windows::runtime::Result<*mut CRYPT_XML_ALGORITHM_INFO> {
22914     #[cfg(windows)]
22915     {
22916         #[link(name = "windows")]
22917         extern "system" {
22918             fn CryptXmlGetAlgorithmInfo(pxmlalgorithm: *const CRYPT_XML_ALGORITHM, dwflags: CRYPT_XML_FLAGS, ppalginfo: *mut *mut CRYPT_XML_ALGORITHM_INFO) -> ::windows::runtime::HRESULT;
22919         }
22920         let mut result__: <*mut CRYPT_XML_ALGORITHM_INFO as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
22921         CryptXmlGetAlgorithmInfo(::std::mem::transmute(pxmlalgorithm), ::std::mem::transmute(dwflags), &mut result__).from_abi::<*mut CRYPT_XML_ALGORITHM_INFO>(result__)
22922     }
22923     #[cfg(not(windows))]
22924     unimplemented!("Unsupported target OS");
22925 }
22926 #[cfg(feature = "Win32_Foundation")]
22927 #[inline]
CryptXmlGetDocContext(hcryptxml: *const ::std::ffi::c_void) -> ::windows::runtime::Result<*mut CRYPT_XML_DOC_CTXT>22928 pub unsafe fn CryptXmlGetDocContext(hcryptxml: *const ::std::ffi::c_void) -> ::windows::runtime::Result<*mut CRYPT_XML_DOC_CTXT> {
22929     #[cfg(windows)]
22930     {
22931         #[link(name = "windows")]
22932         extern "system" {
22933             fn CryptXmlGetDocContext(hcryptxml: *const ::std::ffi::c_void, ppstruct: *mut *mut CRYPT_XML_DOC_CTXT) -> ::windows::runtime::HRESULT;
22934         }
22935         let mut result__: <*mut CRYPT_XML_DOC_CTXT as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
22936         CryptXmlGetDocContext(::std::mem::transmute(hcryptxml), &mut result__).from_abi::<*mut CRYPT_XML_DOC_CTXT>(result__)
22937     }
22938     #[cfg(not(windows))]
22939     unimplemented!("Unsupported target OS");
22940 }
22941 #[cfg(feature = "Win32_Foundation")]
22942 #[inline]
CryptXmlGetReference(hcryptxml: *const ::std::ffi::c_void) -> ::windows::runtime::Result<*mut CRYPT_XML_REFERENCE>22943 pub unsafe fn CryptXmlGetReference(hcryptxml: *const ::std::ffi::c_void) -> ::windows::runtime::Result<*mut CRYPT_XML_REFERENCE> {
22944     #[cfg(windows)]
22945     {
22946         #[link(name = "windows")]
22947         extern "system" {
22948             fn CryptXmlGetReference(hcryptxml: *const ::std::ffi::c_void, ppstruct: *mut *mut CRYPT_XML_REFERENCE) -> ::windows::runtime::HRESULT;
22949         }
22950         let mut result__: <*mut CRYPT_XML_REFERENCE as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
22951         CryptXmlGetReference(::std::mem::transmute(hcryptxml), &mut result__).from_abi::<*mut CRYPT_XML_REFERENCE>(result__)
22952     }
22953     #[cfg(not(windows))]
22954     unimplemented!("Unsupported target OS");
22955 }
22956 #[cfg(feature = "Win32_Foundation")]
22957 #[inline]
CryptXmlGetSignature(hcryptxml: *const ::std::ffi::c_void) -> ::windows::runtime::Result<*mut CRYPT_XML_SIGNATURE>22958 pub unsafe fn CryptXmlGetSignature(hcryptxml: *const ::std::ffi::c_void) -> ::windows::runtime::Result<*mut CRYPT_XML_SIGNATURE> {
22959     #[cfg(windows)]
22960     {
22961         #[link(name = "windows")]
22962         extern "system" {
22963             fn CryptXmlGetSignature(hcryptxml: *const ::std::ffi::c_void, ppstruct: *mut *mut CRYPT_XML_SIGNATURE) -> ::windows::runtime::HRESULT;
22964         }
22965         let mut result__: <*mut CRYPT_XML_SIGNATURE as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
22966         CryptXmlGetSignature(::std::mem::transmute(hcryptxml), &mut result__).from_abi::<*mut CRYPT_XML_SIGNATURE>(result__)
22967     }
22968     #[cfg(not(windows))]
22969     unimplemented!("Unsupported target OS");
22970 }
22971 #[inline]
CryptXmlGetStatus(hcryptxml: *const ::std::ffi::c_void) -> ::windows::runtime::Result<CRYPT_XML_STATUS>22972 pub unsafe fn CryptXmlGetStatus(hcryptxml: *const ::std::ffi::c_void) -> ::windows::runtime::Result<CRYPT_XML_STATUS> {
22973     #[cfg(windows)]
22974     {
22975         #[link(name = "windows")]
22976         extern "system" {
22977             fn CryptXmlGetStatus(hcryptxml: *const ::std::ffi::c_void, pstatus: *mut CRYPT_XML_STATUS) -> ::windows::runtime::HRESULT;
22978         }
22979         let mut result__: <CRYPT_XML_STATUS as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
22980         CryptXmlGetStatus(::std::mem::transmute(hcryptxml), &mut result__).from_abi::<CRYPT_XML_STATUS>(result__)
22981     }
22982     #[cfg(not(windows))]
22983     unimplemented!("Unsupported target OS");
22984 }
22985 #[cfg(feature = "Win32_Foundation")]
22986 #[inline]
CryptXmlGetTransforms() -> ::windows::runtime::Result<*mut CRYPT_XML_TRANSFORM_CHAIN_CONFIG>22987 pub unsafe fn CryptXmlGetTransforms() -> ::windows::runtime::Result<*mut CRYPT_XML_TRANSFORM_CHAIN_CONFIG> {
22988     #[cfg(windows)]
22989     {
22990         #[link(name = "windows")]
22991         extern "system" {
22992             fn CryptXmlGetTransforms(ppconfig: *mut *mut CRYPT_XML_TRANSFORM_CHAIN_CONFIG) -> ::windows::runtime::HRESULT;
22993         }
22994         let mut result__: <*mut CRYPT_XML_TRANSFORM_CHAIN_CONFIG as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
22995         CryptXmlGetTransforms(&mut result__).from_abi::<*mut CRYPT_XML_TRANSFORM_CHAIN_CONFIG>(result__)
22996     }
22997     #[cfg(not(windows))]
22998     unimplemented!("Unsupported target OS");
22999 }
23000 #[cfg(feature = "Win32_Foundation")]
23001 #[inline]
CryptXmlImportPublicKey(dwflags: CRYPT_XML_FLAGS, pkeyvalue: *const CRYPT_XML_KEY_VALUE) -> ::windows::runtime::Result<BCRYPT_KEY_HANDLE>23002 pub unsafe fn CryptXmlImportPublicKey(dwflags: CRYPT_XML_FLAGS, pkeyvalue: *const CRYPT_XML_KEY_VALUE) -> ::windows::runtime::Result<BCRYPT_KEY_HANDLE> {
23003     #[cfg(windows)]
23004     {
23005         #[link(name = "windows")]
23006         extern "system" {
23007             fn CryptXmlImportPublicKey(dwflags: CRYPT_XML_FLAGS, pkeyvalue: *const CRYPT_XML_KEY_VALUE, phkey: *mut BCRYPT_KEY_HANDLE) -> ::windows::runtime::HRESULT;
23008         }
23009         let mut result__: <BCRYPT_KEY_HANDLE as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23010         CryptXmlImportPublicKey(::std::mem::transmute(dwflags), ::std::mem::transmute(pkeyvalue), &mut result__).from_abi::<BCRYPT_KEY_HANDLE>(result__)
23011     }
23012     #[cfg(not(windows))]
23013     unimplemented!("Unsupported target OS");
23014 }
23015 #[cfg(feature = "Win32_Foundation")]
23016 #[inline]
CryptXmlOpenToDecode(pconfig: *const CRYPT_XML_TRANSFORM_CHAIN_CONFIG, dwflags: CRYPT_XML_FLAGS, rgproperty: *const CRYPT_XML_PROPERTY, cproperty: u32, pencoded: *const CRYPT_XML_BLOB, phcryptxml: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>23017 pub unsafe fn CryptXmlOpenToDecode(pconfig: *const CRYPT_XML_TRANSFORM_CHAIN_CONFIG, dwflags: CRYPT_XML_FLAGS, rgproperty: *const CRYPT_XML_PROPERTY, cproperty: u32, pencoded: *const CRYPT_XML_BLOB, phcryptxml: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
23018     #[cfg(windows)]
23019     {
23020         #[link(name = "windows")]
23021         extern "system" {
23022             fn CryptXmlOpenToDecode(pconfig: *const CRYPT_XML_TRANSFORM_CHAIN_CONFIG, dwflags: CRYPT_XML_FLAGS, rgproperty: *const CRYPT_XML_PROPERTY, cproperty: u32, pencoded: *const CRYPT_XML_BLOB, phcryptxml: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
23023         }
23024         CryptXmlOpenToDecode(::std::mem::transmute(pconfig), ::std::mem::transmute(dwflags), ::std::mem::transmute(rgproperty), ::std::mem::transmute(cproperty), ::std::mem::transmute(pencoded), ::std::mem::transmute(phcryptxml)).ok()
23025     }
23026     #[cfg(not(windows))]
23027     unimplemented!("Unsupported target OS");
23028 }
23029 #[cfg(feature = "Win32_Foundation")]
23030 #[inline]
CryptXmlOpenToEncode<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pconfig: *const CRYPT_XML_TRANSFORM_CHAIN_CONFIG, dwflags: CRYPT_XML_FLAGS, wszid: Param2, rgproperty: *const CRYPT_XML_PROPERTY, cproperty: u32, pencoded: *const CRYPT_XML_BLOB, phsignature: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>23031 pub unsafe fn CryptXmlOpenToEncode<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pconfig: *const CRYPT_XML_TRANSFORM_CHAIN_CONFIG, dwflags: CRYPT_XML_FLAGS, wszid: Param2, rgproperty: *const CRYPT_XML_PROPERTY, cproperty: u32, pencoded: *const CRYPT_XML_BLOB, phsignature: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
23032     #[cfg(windows)]
23033     {
23034         #[link(name = "windows")]
23035         extern "system" {
23036             fn CryptXmlOpenToEncode(pconfig: *const CRYPT_XML_TRANSFORM_CHAIN_CONFIG, dwflags: CRYPT_XML_FLAGS, wszid: super::super::Foundation::PWSTR, rgproperty: *const CRYPT_XML_PROPERTY, cproperty: u32, pencoded: *const CRYPT_XML_BLOB, phsignature: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
23037         }
23038         CryptXmlOpenToEncode(::std::mem::transmute(pconfig), ::std::mem::transmute(dwflags), wszid.into_param().abi(), ::std::mem::transmute(rgproperty), ::std::mem::transmute(cproperty), ::std::mem::transmute(pencoded), ::std::mem::transmute(phsignature)).ok()
23039     }
23040     #[cfg(not(windows))]
23041     unimplemented!("Unsupported target OS");
23042 }
23043 #[inline]
CryptXmlSetHMACSecret(hsignature: *const ::std::ffi::c_void, pbsecret: *const u8, cbsecret: u32) -> ::windows::runtime::Result<()>23044 pub unsafe fn CryptXmlSetHMACSecret(hsignature: *const ::std::ffi::c_void, pbsecret: *const u8, cbsecret: u32) -> ::windows::runtime::Result<()> {
23045     #[cfg(windows)]
23046     {
23047         #[link(name = "windows")]
23048         extern "system" {
23049             fn CryptXmlSetHMACSecret(hsignature: *const ::std::ffi::c_void, pbsecret: *const u8, cbsecret: u32) -> ::windows::runtime::HRESULT;
23050         }
23051         CryptXmlSetHMACSecret(::std::mem::transmute(hsignature), ::std::mem::transmute(pbsecret), ::std::mem::transmute(cbsecret)).ok()
23052     }
23053     #[cfg(not(windows))]
23054     unimplemented!("Unsupported target OS");
23055 }
23056 #[cfg(feature = "Win32_Foundation")]
23057 #[inline]
CryptXmlSign(hsignature: *const ::std::ffi::c_void, hkey: usize, dwkeyspec: CERT_KEY_SPEC, dwflags: CRYPT_XML_FLAGS, dwkeyinfospec: CRYPT_XML_KEYINFO_SPEC, pvkeyinfospec: *const ::std::ffi::c_void, psignaturemethod: *const CRYPT_XML_ALGORITHM, pcanonicalization: *const CRYPT_XML_ALGORITHM) -> ::windows::runtime::Result<()>23058 pub unsafe fn CryptXmlSign(hsignature: *const ::std::ffi::c_void, hkey: usize, dwkeyspec: CERT_KEY_SPEC, dwflags: CRYPT_XML_FLAGS, dwkeyinfospec: CRYPT_XML_KEYINFO_SPEC, pvkeyinfospec: *const ::std::ffi::c_void, psignaturemethod: *const CRYPT_XML_ALGORITHM, pcanonicalization: *const CRYPT_XML_ALGORITHM) -> ::windows::runtime::Result<()> {
23059     #[cfg(windows)]
23060     {
23061         #[link(name = "windows")]
23062         extern "system" {
23063             fn CryptXmlSign(hsignature: *const ::std::ffi::c_void, hkey: usize, dwkeyspec: CERT_KEY_SPEC, dwflags: CRYPT_XML_FLAGS, dwkeyinfospec: CRYPT_XML_KEYINFO_SPEC, pvkeyinfospec: *const ::std::ffi::c_void, psignaturemethod: *const CRYPT_XML_ALGORITHM, pcanonicalization: *const CRYPT_XML_ALGORITHM) -> ::windows::runtime::HRESULT;
23064         }
23065         CryptXmlSign(::std::mem::transmute(hsignature), ::std::mem::transmute(hkey), ::std::mem::transmute(dwkeyspec), ::std::mem::transmute(dwflags), ::std::mem::transmute(dwkeyinfospec), ::std::mem::transmute(pvkeyinfospec), ::std::mem::transmute(psignaturemethod), ::std::mem::transmute(pcanonicalization)).ok()
23066     }
23067     #[cfg(not(windows))]
23068     unimplemented!("Unsupported target OS");
23069 }
23070 #[inline]
CryptXmlVerifySignature<'a, Param1: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hsignature: *const ::std::ffi::c_void, hkey: Param1, dwflags: CRYPT_XML_FLAGS) -> ::windows::runtime::Result<()>23071 pub unsafe fn CryptXmlVerifySignature<'a, Param1: ::windows::runtime::IntoParam<'a, BCRYPT_KEY_HANDLE>>(hsignature: *const ::std::ffi::c_void, hkey: Param1, dwflags: CRYPT_XML_FLAGS) -> ::windows::runtime::Result<()> {
23072     #[cfg(windows)]
23073     {
23074         #[link(name = "windows")]
23075         extern "system" {
23076             fn CryptXmlVerifySignature(hsignature: *const ::std::ffi::c_void, hkey: BCRYPT_KEY_HANDLE, dwflags: CRYPT_XML_FLAGS) -> ::windows::runtime::HRESULT;
23077         }
23078         CryptXmlVerifySignature(::std::mem::transmute(hsignature), hkey.into_param().abi(), ::std::mem::transmute(dwflags)).ok()
23079     }
23080     #[cfg(not(windows))]
23081     unimplemented!("Unsupported target OS");
23082 }
23083 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
23084 #[repr(transparent)]
23085 pub struct DSAFIPSVERSION_ENUM(pub i32);
23086 pub const DSA_FIPS186_2: DSAFIPSVERSION_ENUM = DSAFIPSVERSION_ENUM(0i32);
23087 pub const DSA_FIPS186_3: DSAFIPSVERSION_ENUM = DSAFIPSVERSION_ENUM(1i32);
23088 impl ::std::convert::From<i32> for DSAFIPSVERSION_ENUM {
from(value: i32) -> Self23089     fn from(value: i32) -> Self {
23090         Self(value)
23091     }
23092 }
23093 unsafe impl ::windows::runtime::Abi for DSAFIPSVERSION_ENUM {
23094     type Abi = Self;
23095     type DefaultType = Self;
23096 }
23097 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
23098 #[repr(C)]
23099 pub struct DSSSEED {
23100     pub counter: u32,
23101     pub seed: [u8; 20],
23102 }
23103 impl DSSSEED {}
23104 impl ::std::default::Default for DSSSEED {
default() -> Self23105     fn default() -> Self {
23106         unsafe { ::std::mem::zeroed() }
23107     }
23108 }
23109 impl ::std::fmt::Debug for DSSSEED {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result23110     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
23111         fmt.debug_struct("DSSSEED").field("counter", &self.counter).field("seed", &self.seed).finish()
23112     }
23113 }
23114 impl ::std::cmp::PartialEq for DSSSEED {
eq(&self, other: &Self) -> bool23115     fn eq(&self, other: &Self) -> bool {
23116         self.counter == other.counter && self.seed == other.seed
23117     }
23118 }
23119 impl ::std::cmp::Eq for DSSSEED {}
23120 unsafe impl ::windows::runtime::Abi for DSSSEED {
23121     type Abi = Self;
23122     type DefaultType = Self;
23123 }
23124 #[cfg(feature = "Win32_Foundation")]
23125 #[inline]
Decrypt<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, foaep: Param1, cbindata: u32, pindata: *const u8, pcboutdata: *mut u32, ppoutdata: *mut *mut u8) -> ::windows::runtime::Result<()>23126 pub unsafe fn Decrypt<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, foaep: Param1, cbindata: u32, pindata: *const u8, pcboutdata: *mut u32, ppoutdata: *mut *mut u8) -> ::windows::runtime::Result<()> {
23127     #[cfg(windows)]
23128     {
23129         #[link(name = "windows")]
23130         extern "system" {
23131             fn Decrypt(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, foaep: super::super::Foundation::BOOL, cbindata: u32, pindata: *const u8, pcboutdata: *mut u32, ppoutdata: *mut *mut u8) -> ::windows::runtime::HRESULT;
23132         }
23133         Decrypt(::std::mem::transmute(hcrypto), foaep.into_param().abi(), ::std::mem::transmute(cbindata), ::std::mem::transmute(pindata), ::std::mem::transmute(pcboutdata), ::std::mem::transmute(ppoutdata)).ok()
23134     }
23135     #[cfg(not(windows))]
23136     unimplemented!("Unsupported target OS");
23137 }
23138 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
23139 #[repr(transparent)]
23140 pub struct Direction(pub i32);
23141 pub const DirectionEncrypt: Direction = Direction(1i32);
23142 pub const DirectionDecrypt: Direction = Direction(2i32);
23143 impl ::std::convert::From<i32> for Direction {
from(value: i32) -> Self23144     fn from(value: i32) -> Self {
23145         Self(value)
23146     }
23147 }
23148 unsafe impl ::windows::runtime::Abi for Direction {
23149     type Abi = Self;
23150     type DefaultType = Self;
23151 }
23152 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
23153 #[repr(transparent)]
23154 pub struct ECC_CURVE_ALG_ID_ENUM(pub i32);
23155 pub const BCRYPT_NO_CURVE_GENERATION_ALG_ID: ECC_CURVE_ALG_ID_ENUM = ECC_CURVE_ALG_ID_ENUM(0i32);
23156 impl ::std::convert::From<i32> for ECC_CURVE_ALG_ID_ENUM {
from(value: i32) -> Self23157     fn from(value: i32) -> Self {
23158         Self(value)
23159     }
23160 }
23161 unsafe impl ::windows::runtime::Abi for ECC_CURVE_ALG_ID_ENUM {
23162     type Abi = Self;
23163     type DefaultType = Self;
23164 }
23165 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
23166 #[repr(transparent)]
23167 pub struct ECC_CURVE_TYPE_ENUM(pub i32);
23168 pub const BCRYPT_ECC_PRIME_SHORT_WEIERSTRASS_CURVE: ECC_CURVE_TYPE_ENUM = ECC_CURVE_TYPE_ENUM(1i32);
23169 pub const BCRYPT_ECC_PRIME_TWISTED_EDWARDS_CURVE: ECC_CURVE_TYPE_ENUM = ECC_CURVE_TYPE_ENUM(2i32);
23170 pub const BCRYPT_ECC_PRIME_MONTGOMERY_CURVE: ECC_CURVE_TYPE_ENUM = ECC_CURVE_TYPE_ENUM(3i32);
23171 impl ::std::convert::From<i32> for ECC_CURVE_TYPE_ENUM {
from(value: i32) -> Self23172     fn from(value: i32) -> Self {
23173         Self(value)
23174     }
23175 }
23176 unsafe impl ::windows::runtime::Abi for ECC_CURVE_TYPE_ENUM {
23177     type Abi = Self;
23178     type DefaultType = Self;
23179 }
23180 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
23181 #[repr(C)]
23182 #[cfg(feature = "Win32_Foundation")]
23183 pub struct ENDPOINTADDRESS {
23184     pub serviceUrl: super::super::Foundation::PWSTR,
23185     pub policyUrl: super::super::Foundation::PWSTR,
23186     pub rawCertificate: CRYPTOAPI_BLOB,
23187 }
23188 #[cfg(feature = "Win32_Foundation")]
23189 impl ENDPOINTADDRESS {}
23190 #[cfg(feature = "Win32_Foundation")]
23191 impl ::std::default::Default for ENDPOINTADDRESS {
default() -> Self23192     fn default() -> Self {
23193         unsafe { ::std::mem::zeroed() }
23194     }
23195 }
23196 #[cfg(feature = "Win32_Foundation")]
23197 impl ::std::fmt::Debug for ENDPOINTADDRESS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result23198     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
23199         fmt.debug_struct("ENDPOINTADDRESS").field("serviceUrl", &self.serviceUrl).field("policyUrl", &self.policyUrl).field("rawCertificate", &self.rawCertificate).finish()
23200     }
23201 }
23202 #[cfg(feature = "Win32_Foundation")]
23203 impl ::std::cmp::PartialEq for ENDPOINTADDRESS {
eq(&self, other: &Self) -> bool23204     fn eq(&self, other: &Self) -> bool {
23205         self.serviceUrl == other.serviceUrl && self.policyUrl == other.policyUrl && self.rawCertificate == other.rawCertificate
23206     }
23207 }
23208 #[cfg(feature = "Win32_Foundation")]
23209 impl ::std::cmp::Eq for ENDPOINTADDRESS {}
23210 #[cfg(feature = "Win32_Foundation")]
23211 unsafe impl ::windows::runtime::Abi for ENDPOINTADDRESS {
23212     type Abi = Self;
23213     type DefaultType = Self;
23214 }
23215 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
23216 #[repr(C)]
23217 #[cfg(feature = "Win32_Foundation")]
23218 pub struct ENDPOINTADDRESS2 {
23219     pub serviceUrl: super::super::Foundation::PWSTR,
23220     pub policyUrl: super::super::Foundation::PWSTR,
23221     pub identityType: u32,
23222     pub identityBytes: *mut ::std::ffi::c_void,
23223 }
23224 #[cfg(feature = "Win32_Foundation")]
23225 impl ENDPOINTADDRESS2 {}
23226 #[cfg(feature = "Win32_Foundation")]
23227 impl ::std::default::Default for ENDPOINTADDRESS2 {
default() -> Self23228     fn default() -> Self {
23229         unsafe { ::std::mem::zeroed() }
23230     }
23231 }
23232 #[cfg(feature = "Win32_Foundation")]
23233 impl ::std::fmt::Debug for ENDPOINTADDRESS2 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result23234     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
23235         fmt.debug_struct("ENDPOINTADDRESS2").field("serviceUrl", &self.serviceUrl).field("policyUrl", &self.policyUrl).field("identityType", &self.identityType).field("identityBytes", &self.identityBytes).finish()
23236     }
23237 }
23238 #[cfg(feature = "Win32_Foundation")]
23239 impl ::std::cmp::PartialEq for ENDPOINTADDRESS2 {
eq(&self, other: &Self) -> bool23240     fn eq(&self, other: &Self) -> bool {
23241         self.serviceUrl == other.serviceUrl && self.policyUrl == other.policyUrl && self.identityType == other.identityType && self.identityBytes == other.identityBytes
23242     }
23243 }
23244 #[cfg(feature = "Win32_Foundation")]
23245 impl ::std::cmp::Eq for ENDPOINTADDRESS2 {}
23246 #[cfg(feature = "Win32_Foundation")]
23247 unsafe impl ::windows::runtime::Abi for ENDPOINTADDRESS2 {
23248     type Abi = Self;
23249     type DefaultType = Self;
23250 }
23251 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
23252 #[repr(C)]
23253 pub struct EV_EXTRA_CERT_CHAIN_POLICY_PARA {
23254     pub cbSize: u32,
23255     pub dwRootProgramQualifierFlags: CERT_ROOT_PROGRAM_FLAGS,
23256 }
23257 impl EV_EXTRA_CERT_CHAIN_POLICY_PARA {}
23258 impl ::std::default::Default for EV_EXTRA_CERT_CHAIN_POLICY_PARA {
default() -> Self23259     fn default() -> Self {
23260         unsafe { ::std::mem::zeroed() }
23261     }
23262 }
23263 impl ::std::fmt::Debug for EV_EXTRA_CERT_CHAIN_POLICY_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result23264     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
23265         fmt.debug_struct("EV_EXTRA_CERT_CHAIN_POLICY_PARA").field("cbSize", &self.cbSize).field("dwRootProgramQualifierFlags", &self.dwRootProgramQualifierFlags).finish()
23266     }
23267 }
23268 impl ::std::cmp::PartialEq for EV_EXTRA_CERT_CHAIN_POLICY_PARA {
eq(&self, other: &Self) -> bool23269     fn eq(&self, other: &Self) -> bool {
23270         self.cbSize == other.cbSize && self.dwRootProgramQualifierFlags == other.dwRootProgramQualifierFlags
23271     }
23272 }
23273 impl ::std::cmp::Eq for EV_EXTRA_CERT_CHAIN_POLICY_PARA {}
23274 unsafe impl ::windows::runtime::Abi for EV_EXTRA_CERT_CHAIN_POLICY_PARA {
23275     type Abi = Self;
23276     type DefaultType = Self;
23277 }
23278 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
23279 #[repr(C)]
23280 pub struct EV_EXTRA_CERT_CHAIN_POLICY_STATUS {
23281     pub cbSize: u32,
23282     pub dwQualifiers: u32,
23283     pub dwIssuanceUsageIndex: u32,
23284 }
23285 impl EV_EXTRA_CERT_CHAIN_POLICY_STATUS {}
23286 impl ::std::default::Default for EV_EXTRA_CERT_CHAIN_POLICY_STATUS {
default() -> Self23287     fn default() -> Self {
23288         unsafe { ::std::mem::zeroed() }
23289     }
23290 }
23291 impl ::std::fmt::Debug for EV_EXTRA_CERT_CHAIN_POLICY_STATUS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result23292     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
23293         fmt.debug_struct("EV_EXTRA_CERT_CHAIN_POLICY_STATUS").field("cbSize", &self.cbSize).field("dwQualifiers", &self.dwQualifiers).field("dwIssuanceUsageIndex", &self.dwIssuanceUsageIndex).finish()
23294     }
23295 }
23296 impl ::std::cmp::PartialEq for EV_EXTRA_CERT_CHAIN_POLICY_STATUS {
eq(&self, other: &Self) -> bool23297     fn eq(&self, other: &Self) -> bool {
23298         self.cbSize == other.cbSize && self.dwQualifiers == other.dwQualifiers && self.dwIssuanceUsageIndex == other.dwIssuanceUsageIndex
23299     }
23300 }
23301 impl ::std::cmp::Eq for EV_EXTRA_CERT_CHAIN_POLICY_STATUS {}
23302 unsafe impl ::windows::runtime::Abi for EV_EXTRA_CERT_CHAIN_POLICY_STATUS {
23303     type Abi = Self;
23304     type DefaultType = Self;
23305 }
23306 pub const EXPORT_PRIVATE_KEYS: u32 = 4u32;
23307 pub const E_ICARD_ARGUMENT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413883i32 as _);
23308 pub const E_ICARD_COMMUNICATION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413888i32 as _);
23309 pub const E_ICARD_DATA_ACCESS: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413887i32 as _);
23310 pub const E_ICARD_EXPORT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413886i32 as _);
23311 pub const E_ICARD_FAIL: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413867i32 as _);
23312 pub const E_ICARD_FAILED_REQUIRED_CLAIMS: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413756i32 as _);
23313 pub const E_ICARD_IDENTITY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413885i32 as _);
23314 pub const E_ICARD_IMPORT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413884i32 as _);
23315 pub const E_ICARD_INFORMATIONCARD: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413881i32 as _);
23316 pub const E_ICARD_INVALID_PROOF_KEY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413758i32 as _);
23317 pub const E_ICARD_LOGOVALIDATION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413879i32 as _);
23318 pub const E_ICARD_MISSING_APPLIESTO: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413759i32 as _);
23319 pub const E_ICARD_PASSWORDVALIDATION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413878i32 as _);
23320 pub const E_ICARD_POLICY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413877i32 as _);
23321 pub const E_ICARD_PROCESSDIED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413876i32 as _);
23322 pub const E_ICARD_REFRESH_REQUIRED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413760i32 as _);
23323 pub const E_ICARD_REQUEST: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413882i32 as _);
23324 pub const E_ICARD_SERVICE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413874i32 as _);
23325 pub const E_ICARD_SERVICEBUSY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413875i32 as _);
23326 pub const E_ICARD_SHUTTINGDOWN: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413873i32 as _);
23327 pub const E_ICARD_STOREKEY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413880i32 as _);
23328 pub const E_ICARD_STORE_IMPORT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413868i32 as _);
23329 pub const E_ICARD_TOKENCREATION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413872i32 as _);
23330 pub const E_ICARD_TRUSTEXCHANGE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413871i32 as _);
23331 pub const E_ICARD_UI_INITIALIZATION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413862i32 as _);
23332 pub const E_ICARD_UNKNOWN_REFERENCE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413757i32 as _);
23333 pub const E_ICARD_UNTRUSTED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413870i32 as _);
23334 pub const E_ICARD_USERCANCELLED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073413869i32 as _);
23335 #[cfg(feature = "Win32_Foundation")]
23336 #[inline]
Encrypt<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, foaep: Param1, cbindata: u32, pindata: *const u8, pcboutdata: *mut u32, ppoutdata: *mut *mut u8) -> ::windows::runtime::Result<()>23337 pub unsafe fn Encrypt<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, foaep: Param1, cbindata: u32, pindata: *const u8, pcboutdata: *mut u32, ppoutdata: *mut *mut u8) -> ::windows::runtime::Result<()> {
23338     #[cfg(windows)]
23339     {
23340         #[link(name = "windows")]
23341         extern "system" {
23342             fn Encrypt(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, foaep: super::super::Foundation::BOOL, cbindata: u32, pindata: *const u8, pcboutdata: *mut u32, ppoutdata: *mut *mut u8) -> ::windows::runtime::HRESULT;
23343         }
23344         Encrypt(::std::mem::transmute(hcrypto), foaep.into_param().abi(), ::std::mem::transmute(cbindata), ::std::mem::transmute(pindata), ::std::mem::transmute(pcboutdata), ::std::mem::transmute(ppoutdata)).ok()
23345     }
23346     #[cfg(not(windows))]
23347     unimplemented!("Unsupported target OS");
23348 }
23349 #[cfg(feature = "Win32_Foundation")]
23350 #[inline]
FindCertsByIssuer<'a, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pcertchains: *mut CERT_CHAIN, pcbcertchains: *mut u32, pccertchains: *mut u32, pbencodedissuername: *const u8, cbencodedissuername: u32, pwszpurpose: Param5, dwkeyspec: u32) -> ::windows::runtime::Result<()>23351 pub unsafe fn FindCertsByIssuer<'a, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pcertchains: *mut CERT_CHAIN, pcbcertchains: *mut u32, pccertchains: *mut u32, pbencodedissuername: *const u8, cbencodedissuername: u32, pwszpurpose: Param5, dwkeyspec: u32) -> ::windows::runtime::Result<()> {
23352     #[cfg(windows)]
23353     {
23354         #[link(name = "windows")]
23355         extern "system" {
23356             fn FindCertsByIssuer(pcertchains: *mut CERT_CHAIN, pcbcertchains: *mut u32, pccertchains: *mut u32, pbencodedissuername: *const u8, cbencodedissuername: u32, pwszpurpose: super::super::Foundation::PWSTR, dwkeyspec: u32) -> ::windows::runtime::HRESULT;
23357         }
23358         FindCertsByIssuer(::std::mem::transmute(pcertchains), ::std::mem::transmute(pcbcertchains), ::std::mem::transmute(pccertchains), ::std::mem::transmute(pbencodedissuername), ::std::mem::transmute(cbencodedissuername), pwszpurpose.into_param().abi(), ::std::mem::transmute(dwkeyspec)).ok()
23359     }
23360     #[cfg(not(windows))]
23361     unimplemented!("Unsupported target OS");
23362 }
23363 #[cfg(feature = "Win32_Foundation")]
23364 #[inline]
FreeToken(pallocmemory: *const GENERIC_XML_TOKEN) -> super::super::Foundation::BOOL23365 pub unsafe fn FreeToken(pallocmemory: *const GENERIC_XML_TOKEN) -> super::super::Foundation::BOOL {
23366     #[cfg(windows)]
23367     {
23368         #[link(name = "windows")]
23369         extern "system" {
23370             fn FreeToken(pallocmemory: *const GENERIC_XML_TOKEN) -> super::super::Foundation::BOOL;
23371         }
23372         ::std::mem::transmute(FreeToken(::std::mem::transmute(pallocmemory)))
23373     }
23374     #[cfg(not(windows))]
23375     unimplemented!("Unsupported target OS");
23376 }
23377 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
23378 #[repr(C, packed(1))]
23379 #[cfg(feature = "Win32_Foundation")]
23380 pub struct GENERIC_XML_TOKEN {
23381     pub createDate: super::super::Foundation::FILETIME,
23382     pub expiryDate: super::super::Foundation::FILETIME,
23383     pub xmlToken: super::super::Foundation::PWSTR,
23384     pub internalTokenReference: super::super::Foundation::PWSTR,
23385     pub externalTokenReference: super::super::Foundation::PWSTR,
23386 }
23387 #[cfg(feature = "Win32_Foundation")]
23388 impl GENERIC_XML_TOKEN {}
23389 #[cfg(feature = "Win32_Foundation")]
23390 impl ::std::default::Default for GENERIC_XML_TOKEN {
default() -> Self23391     fn default() -> Self {
23392         unsafe { ::std::mem::zeroed() }
23393     }
23394 }
23395 #[cfg(feature = "Win32_Foundation")]
23396 impl ::std::cmp::PartialEq for GENERIC_XML_TOKEN {
eq(&self, _other: &Self) -> bool23397     fn eq(&self, _other: &Self) -> bool {
23398         unimplemented!()
23399     }
23400 }
23401 #[cfg(feature = "Win32_Foundation")]
23402 impl ::std::cmp::Eq for GENERIC_XML_TOKEN {}
23403 #[cfg(feature = "Win32_Foundation")]
23404 unsafe impl ::windows::runtime::Abi for GENERIC_XML_TOKEN {
23405     type Abi = Self;
23406     type DefaultType = Self;
23407 }
23408 #[cfg(feature = "Win32_Foundation")]
23409 #[inline]
GenerateDerivedKey<'a, Param7: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cblabel: u32, plabel: *const u8, cbnonce: u32, pnonce: *const u8, derivedkeylength: u32, offset: u32, algid: Param7, pcbkey: *mut u32, ppkey: *mut *mut u8) -> ::windows::runtime::Result<()>23410 pub unsafe fn GenerateDerivedKey<'a, Param7: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cblabel: u32, plabel: *const u8, cbnonce: u32, pnonce: *const u8, derivedkeylength: u32, offset: u32, algid: Param7, pcbkey: *mut u32, ppkey: *mut *mut u8) -> ::windows::runtime::Result<()> {
23411     #[cfg(windows)]
23412     {
23413         #[link(name = "windows")]
23414         extern "system" {
23415             fn GenerateDerivedKey(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cblabel: u32, plabel: *const u8, cbnonce: u32, pnonce: *const u8, derivedkeylength: u32, offset: u32, algid: super::super::Foundation::PWSTR, pcbkey: *mut u32, ppkey: *mut *mut u8) -> ::windows::runtime::HRESULT;
23416         }
23417         GenerateDerivedKey(
23418             ::std::mem::transmute(hcrypto),
23419             ::std::mem::transmute(cblabel),
23420             ::std::mem::transmute(plabel),
23421             ::std::mem::transmute(cbnonce),
23422             ::std::mem::transmute(pnonce),
23423             ::std::mem::transmute(derivedkeylength),
23424             ::std::mem::transmute(offset),
23425             algid.into_param().abi(),
23426             ::std::mem::transmute(pcbkey),
23427             ::std::mem::transmute(ppkey),
23428         )
23429         .ok()
23430     }
23431     #[cfg(not(windows))]
23432     unimplemented!("Unsupported target OS");
23433 }
23434 #[inline]
GetBrowserToken(dwparamtype: u32, pparam: *const ::std::ffi::c_void, pcbtoken: *mut u32, pptoken: *mut *mut u8) -> ::windows::runtime::Result<()>23435 pub unsafe fn GetBrowserToken(dwparamtype: u32, pparam: *const ::std::ffi::c_void, pcbtoken: *mut u32, pptoken: *mut *mut u8) -> ::windows::runtime::Result<()> {
23436     #[cfg(windows)]
23437     {
23438         #[link(name = "windows")]
23439         extern "system" {
23440             fn GetBrowserToken(dwparamtype: u32, pparam: *const ::std::ffi::c_void, pcbtoken: *mut u32, pptoken: *mut *mut u8) -> ::windows::runtime::HRESULT;
23441         }
23442         GetBrowserToken(::std::mem::transmute(dwparamtype), ::std::mem::transmute(pparam), ::std::mem::transmute(pcbtoken), ::std::mem::transmute(pptoken)).ok()
23443     }
23444     #[cfg(not(windows))]
23445     unimplemented!("Unsupported target OS");
23446 }
23447 #[inline]
GetCryptoTransform(hsymmetriccrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, mode: u32, padding: PaddingMode, feedbacksize: u32, direction: Direction, cbiv: u32, piv: *const u8) -> ::windows::runtime::Result<*mut INFORMATIONCARD_CRYPTO_HANDLE>23448 pub unsafe fn GetCryptoTransform(hsymmetriccrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, mode: u32, padding: PaddingMode, feedbacksize: u32, direction: Direction, cbiv: u32, piv: *const u8) -> ::windows::runtime::Result<*mut INFORMATIONCARD_CRYPTO_HANDLE> {
23449     #[cfg(windows)]
23450     {
23451         #[link(name = "windows")]
23452         extern "system" {
23453             fn GetCryptoTransform(hsymmetriccrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, mode: u32, padding: PaddingMode, feedbacksize: u32, direction: Direction, cbiv: u32, piv: *const u8, pphtransform: *mut *mut INFORMATIONCARD_CRYPTO_HANDLE) -> ::windows::runtime::HRESULT;
23454         }
23455         let mut result__: <*mut INFORMATIONCARD_CRYPTO_HANDLE as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23456         GetCryptoTransform(::std::mem::transmute(hsymmetriccrypto), ::std::mem::transmute(mode), ::std::mem::transmute(padding), ::std::mem::transmute(feedbacksize), ::std::mem::transmute(direction), ::std::mem::transmute(cbiv), ::std::mem::transmute(piv), &mut result__).from_abi::<*mut INFORMATIONCARD_CRYPTO_HANDLE>(result__)
23457     }
23458     #[cfg(not(windows))]
23459     unimplemented!("Unsupported target OS");
23460 }
23461 #[inline]
GetKeyedHash(hsymmetriccrypto: *const INFORMATIONCARD_CRYPTO_HANDLE) -> ::windows::runtime::Result<*mut INFORMATIONCARD_CRYPTO_HANDLE>23462 pub unsafe fn GetKeyedHash(hsymmetriccrypto: *const INFORMATIONCARD_CRYPTO_HANDLE) -> ::windows::runtime::Result<*mut INFORMATIONCARD_CRYPTO_HANDLE> {
23463     #[cfg(windows)]
23464     {
23465         #[link(name = "windows")]
23466         extern "system" {
23467             fn GetKeyedHash(hsymmetriccrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, pphhash: *mut *mut INFORMATIONCARD_CRYPTO_HANDLE) -> ::windows::runtime::HRESULT;
23468         }
23469         let mut result__: <*mut INFORMATIONCARD_CRYPTO_HANDLE as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23470         GetKeyedHash(::std::mem::transmute(hsymmetriccrypto), &mut result__).from_abi::<*mut INFORMATIONCARD_CRYPTO_HANDLE>(result__)
23471     }
23472     #[cfg(not(windows))]
23473     unimplemented!("Unsupported target OS");
23474 }
23475 #[cfg(feature = "Win32_Foundation")]
23476 #[inline]
GetToken(cpolicychain: u32, ppolicychain: *const POLICY_ELEMENT, securitytoken: *mut *mut GENERIC_XML_TOKEN, phprooftokencrypto: *mut *mut INFORMATIONCARD_CRYPTO_HANDLE) -> ::windows::runtime::Result<()>23477 pub unsafe fn GetToken(cpolicychain: u32, ppolicychain: *const POLICY_ELEMENT, securitytoken: *mut *mut GENERIC_XML_TOKEN, phprooftokencrypto: *mut *mut INFORMATIONCARD_CRYPTO_HANDLE) -> ::windows::runtime::Result<()> {
23478     #[cfg(windows)]
23479     {
23480         #[link(name = "windows")]
23481         extern "system" {
23482             fn GetToken(cpolicychain: u32, ppolicychain: *const POLICY_ELEMENT, securitytoken: *mut *mut GENERIC_XML_TOKEN, phprooftokencrypto: *mut *mut INFORMATIONCARD_CRYPTO_HANDLE) -> ::windows::runtime::HRESULT;
23483         }
23484         GetToken(::std::mem::transmute(cpolicychain), ::std::mem::transmute(ppolicychain), ::std::mem::transmute(securitytoken), ::std::mem::transmute(phprooftokencrypto)).ok()
23485     }
23486     #[cfg(not(windows))]
23487     unimplemented!("Unsupported target OS");
23488 }
23489 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
23490 #[repr(transparent)]
23491 pub struct HASHALGORITHM_ENUM(pub i32);
23492 pub const DSA_HASH_ALGORITHM_SHA1: HASHALGORITHM_ENUM = HASHALGORITHM_ENUM(0i32);
23493 pub const DSA_HASH_ALGORITHM_SHA256: HASHALGORITHM_ENUM = HASHALGORITHM_ENUM(1i32);
23494 pub const DSA_HASH_ALGORITHM_SHA512: HASHALGORITHM_ENUM = HASHALGORITHM_ENUM(2i32);
23495 impl ::std::convert::From<i32> for HASHALGORITHM_ENUM {
from(value: i32) -> Self23496     fn from(value: i32) -> Self {
23497         Self(value)
23498     }
23499 }
23500 unsafe impl ::windows::runtime::Abi for HASHALGORITHM_ENUM {
23501     type Abi = Self;
23502     type DefaultType = Self;
23503 }
23504 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
23505 #[repr(transparent)]
23506 pub struct HCERTCHAINENGINE(pub isize);
23507 impl ::std::default::Default for HCERTCHAINENGINE {
default() -> Self23508     fn default() -> Self {
23509         unsafe { ::std::mem::zeroed() }
23510     }
23511 }
23512 unsafe impl ::windows::runtime::Handle for HCERTCHAINENGINE {}
23513 unsafe impl ::windows::runtime::Abi for HCERTCHAINENGINE {
23514     type Abi = Self;
23515     type DefaultType = Self;
23516 }
23517 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
23518 #[repr(transparent)]
23519 pub struct HCRYPTASYNC(pub isize);
23520 impl ::std::default::Default for HCRYPTASYNC {
default() -> Self23521     fn default() -> Self {
23522         unsafe { ::std::mem::zeroed() }
23523     }
23524 }
23525 unsafe impl ::windows::runtime::Handle for HCRYPTASYNC {}
23526 unsafe impl ::windows::runtime::Abi for HCRYPTASYNC {
23527     type Abi = Self;
23528     type DefaultType = Self;
23529 }
23530 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
23531 #[repr(C)]
23532 pub struct HMAC_Info {
23533     pub HashAlgid: u32,
23534     pub pbInnerString: *mut u8,
23535     pub cbInnerString: u32,
23536     pub pbOuterString: *mut u8,
23537     pub cbOuterString: u32,
23538 }
23539 impl HMAC_Info {}
23540 impl ::std::default::Default for HMAC_Info {
default() -> Self23541     fn default() -> Self {
23542         unsafe { ::std::mem::zeroed() }
23543     }
23544 }
23545 impl ::std::fmt::Debug for HMAC_Info {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result23546     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
23547         fmt.debug_struct("HMAC_Info").field("HashAlgid", &self.HashAlgid).field("pbInnerString", &self.pbInnerString).field("cbInnerString", &self.cbInnerString).field("pbOuterString", &self.pbOuterString).field("cbOuterString", &self.cbOuterString).finish()
23548     }
23549 }
23550 impl ::std::cmp::PartialEq for HMAC_Info {
eq(&self, other: &Self) -> bool23551     fn eq(&self, other: &Self) -> bool {
23552         self.HashAlgid == other.HashAlgid && self.pbInnerString == other.pbInnerString && self.cbInnerString == other.cbInnerString && self.pbOuterString == other.pbOuterString && self.cbOuterString == other.cbOuterString
23553     }
23554 }
23555 impl ::std::cmp::Eq for HMAC_Info {}
23556 unsafe impl ::windows::runtime::Abi for HMAC_Info {
23557     type Abi = Self;
23558     type DefaultType = Self;
23559 }
23560 pub const HP_ALGID: u32 = 1u32;
23561 pub const HP_HASHSIZE: u32 = 4u32;
23562 pub const HP_TLS1PRF_LABEL: u32 = 6u32;
23563 pub const HP_TLS1PRF_SEED: u32 = 7u32;
23564 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
23565 #[repr(transparent)]
23566 pub struct HTTPSPOLICY_CALLBACK_DATA_AUTH_TYPE(pub u32);
23567 pub const AUTHTYPE_CLIENT: HTTPSPOLICY_CALLBACK_DATA_AUTH_TYPE = HTTPSPOLICY_CALLBACK_DATA_AUTH_TYPE(1u32);
23568 pub const AUTHTYPE_SERVER: HTTPSPOLICY_CALLBACK_DATA_AUTH_TYPE = HTTPSPOLICY_CALLBACK_DATA_AUTH_TYPE(2u32);
23569 impl ::std::convert::From<u32> for HTTPSPOLICY_CALLBACK_DATA_AUTH_TYPE {
from(value: u32) -> Self23570     fn from(value: u32) -> Self {
23571         Self(value)
23572     }
23573 }
23574 unsafe impl ::windows::runtime::Abi for HTTPSPOLICY_CALLBACK_DATA_AUTH_TYPE {
23575     type Abi = Self;
23576     type DefaultType = Self;
23577 }
23578 impl ::std::ops::BitOr for HTTPSPOLICY_CALLBACK_DATA_AUTH_TYPE {
23579     type Output = Self;
bitor(self, rhs: Self) -> Self23580     fn bitor(self, rhs: Self) -> Self {
23581         Self(self.0 | rhs.0)
23582     }
23583 }
23584 impl ::std::ops::BitAnd for HTTPSPOLICY_CALLBACK_DATA_AUTH_TYPE {
23585     type Output = Self;
bitand(self, rhs: Self) -> Self23586     fn bitand(self, rhs: Self) -> Self {
23587         Self(self.0 & rhs.0)
23588     }
23589 }
23590 impl ::std::ops::BitOrAssign for HTTPSPOLICY_CALLBACK_DATA_AUTH_TYPE {
bitor_assign(&mut self, rhs: Self)23591     fn bitor_assign(&mut self, rhs: Self) {
23592         self.0.bitor_assign(rhs.0)
23593     }
23594 }
23595 impl ::std::ops::BitAndAssign for HTTPSPOLICY_CALLBACK_DATA_AUTH_TYPE {
bitand_assign(&mut self, rhs: Self)23596     fn bitand_assign(&mut self, rhs: Self) {
23597         self.0.bitand_assign(rhs.0)
23598     }
23599 }
23600 impl ::std::ops::Not for HTTPSPOLICY_CALLBACK_DATA_AUTH_TYPE {
23601     type Output = Self;
not(self) -> Self23602     fn not(self) -> Self {
23603         Self(self.0.not())
23604     }
23605 }
23606 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
23607 #[repr(C)]
23608 #[cfg(feature = "Win32_Foundation")]
23609 pub struct HTTPSPolicyCallbackData {
23610     pub Anonymous: HTTPSPolicyCallbackData_0,
23611     pub dwAuthType: HTTPSPOLICY_CALLBACK_DATA_AUTH_TYPE,
23612     pub fdwChecks: u32,
23613     pub pwszServerName: super::super::Foundation::PWSTR,
23614 }
23615 #[cfg(feature = "Win32_Foundation")]
23616 impl HTTPSPolicyCallbackData {}
23617 #[cfg(feature = "Win32_Foundation")]
23618 impl ::std::default::Default for HTTPSPolicyCallbackData {
default() -> Self23619     fn default() -> Self {
23620         unsafe { ::std::mem::zeroed() }
23621     }
23622 }
23623 #[cfg(feature = "Win32_Foundation")]
23624 impl ::std::cmp::PartialEq for HTTPSPolicyCallbackData {
eq(&self, _other: &Self) -> bool23625     fn eq(&self, _other: &Self) -> bool {
23626         unimplemented!()
23627     }
23628 }
23629 #[cfg(feature = "Win32_Foundation")]
23630 impl ::std::cmp::Eq for HTTPSPolicyCallbackData {}
23631 #[cfg(feature = "Win32_Foundation")]
23632 unsafe impl ::windows::runtime::Abi for HTTPSPolicyCallbackData {
23633     type Abi = Self;
23634     type DefaultType = Self;
23635 }
23636 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
23637 #[repr(C)]
23638 pub union HTTPSPolicyCallbackData_0 {
23639     pub cbStruct: u32,
23640     pub cbSize: u32,
23641 }
23642 impl HTTPSPolicyCallbackData_0 {}
23643 impl ::std::default::Default for HTTPSPolicyCallbackData_0 {
default() -> Self23644     fn default() -> Self {
23645         unsafe { ::std::mem::zeroed() }
23646     }
23647 }
23648 impl ::std::cmp::PartialEq for HTTPSPolicyCallbackData_0 {
eq(&self, _other: &Self) -> bool23649     fn eq(&self, _other: &Self) -> bool {
23650         unimplemented!()
23651     }
23652 }
23653 impl ::std::cmp::Eq for HTTPSPolicyCallbackData_0 {}
23654 unsafe impl ::windows::runtime::Abi for HTTPSPolicyCallbackData_0 {
23655     type Abi = Self;
23656     type DefaultType = Self;
23657 }
23658 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
23659 #[repr(transparent)]
23660 pub struct HandleType(pub i32);
23661 impl HandleType {
23662     pub const Asymmetric: HandleType = HandleType(1i32);
23663     pub const Symmetric: HandleType = HandleType(2i32);
23664     pub const Transform: HandleType = HandleType(3i32);
23665     pub const Hash: HandleType = HandleType(4i32);
23666 }
23667 impl ::std::convert::From<i32> for HandleType {
from(value: i32) -> Self23668     fn from(value: i32) -> Self {
23669         Self(value)
23670     }
23671 }
23672 unsafe impl ::windows::runtime::Abi for HandleType {
23673     type Abi = Self;
23674     type DefaultType = Self;
23675 }
23676 #[inline]
HashCore(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cbindata: u32, pindata: *const u8) -> ::windows::runtime::Result<()>23677 pub unsafe fn HashCore(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cbindata: u32, pindata: *const u8) -> ::windows::runtime::Result<()> {
23678     #[cfg(windows)]
23679     {
23680         #[link(name = "windows")]
23681         extern "system" {
23682             fn HashCore(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cbindata: u32, pindata: *const u8) -> ::windows::runtime::HRESULT;
23683         }
23684         HashCore(::std::mem::transmute(hcrypto), ::std::mem::transmute(cbindata), ::std::mem::transmute(pindata)).ok()
23685     }
23686     #[cfg(not(windows))]
23687     unimplemented!("Unsupported target OS");
23688 }
23689 #[inline]
HashFinal(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cbindata: u32, pindata: *const u8, pcboutdata: *mut u32, ppoutdata: *mut *mut u8) -> ::windows::runtime::Result<()>23690 pub unsafe fn HashFinal(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cbindata: u32, pindata: *const u8, pcboutdata: *mut u32, ppoutdata: *mut *mut u8) -> ::windows::runtime::Result<()> {
23691     #[cfg(windows)]
23692     {
23693         #[link(name = "windows")]
23694         extern "system" {
23695             fn HashFinal(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cbindata: u32, pindata: *const u8, pcboutdata: *mut u32, ppoutdata: *mut *mut u8) -> ::windows::runtime::HRESULT;
23696         }
23697         HashFinal(::std::mem::transmute(hcrypto), ::std::mem::transmute(cbindata), ::std::mem::transmute(pindata), ::std::mem::transmute(pcboutdata), ::std::mem::transmute(ppoutdata)).ok()
23698     }
23699     #[cfg(not(windows))]
23700     unimplemented!("Unsupported target OS");
23701 }
23702 #[repr(transparent)]
23703 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
23704 pub struct ICertSrvSetup(::windows::runtime::IUnknown);
23705 impl ICertSrvSetup {
CAErrorId(&self) -> ::windows::runtime::Result<i32>23706     pub unsafe fn CAErrorId(&self) -> ::windows::runtime::Result<i32> {
23707         let mut result__: <i32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23708         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
23709     }
23710     #[cfg(feature = "Win32_Foundation")]
CAErrorString(&self) -> ::windows::runtime::Result<super::super::Foundation::BSTR>23711     pub unsafe fn CAErrorString(&self) -> ::windows::runtime::Result<super::super::Foundation::BSTR> {
23712         let mut result__: <super::super::Foundation::BSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23713         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
23714     }
InitializeDefaults(&self, bserver: i16, bclient: i16) -> ::windows::runtime::Result<()>23715     pub unsafe fn InitializeDefaults(&self, bserver: i16, bclient: i16) -> ::windows::runtime::Result<()> {
23716         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), ::std::mem::transmute(bserver), ::std::mem::transmute(bclient)).ok()
23717     }
23718     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
GetCASetupProperty(&self, propertyid: CASetupProperty) -> ::windows::runtime::Result<super::super::System::Com::VARIANT>23719     pub unsafe fn GetCASetupProperty(&self, propertyid: CASetupProperty) -> ::windows::runtime::Result<super::super::System::Com::VARIANT> {
23720         let mut result__: <super::super::System::Com::VARIANT as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23721         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), ::std::mem::transmute(propertyid), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
23722     }
23723     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
SetCASetupProperty(&self, propertyid: CASetupProperty, ppropertyvalue: *const super::super::System::Com::VARIANT) -> ::windows::runtime::Result<()>23724     pub unsafe fn SetCASetupProperty(&self, propertyid: CASetupProperty, ppropertyvalue: *const super::super::System::Com::VARIANT) -> ::windows::runtime::Result<()> {
23725         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), ::std::mem::transmute(propertyid), ::std::mem::transmute(ppropertyvalue)).ok()
23726     }
IsPropertyEditable(&self, propertyid: CASetupProperty) -> ::windows::runtime::Result<i16>23727     pub unsafe fn IsPropertyEditable(&self, propertyid: CASetupProperty) -> ::windows::runtime::Result<i16> {
23728         let mut result__: <i16 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23729         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), ::std::mem::transmute(propertyid), &mut result__).from_abi::<i16>(result__)
23730     }
23731     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
GetSupportedCATypes(&self) -> ::windows::runtime::Result<super::super::System::Com::VARIANT>23732     pub unsafe fn GetSupportedCATypes(&self) -> ::windows::runtime::Result<super::super::System::Com::VARIANT> {
23733         let mut result__: <super::super::System::Com::VARIANT as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23734         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
23735     }
23736     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
GetProviderNameList(&self) -> ::windows::runtime::Result<super::super::System::Com::VARIANT>23737     pub unsafe fn GetProviderNameList(&self) -> ::windows::runtime::Result<super::super::System::Com::VARIANT> {
23738         let mut result__: <super::super::System::Com::VARIANT as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23739         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
23740     }
23741     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
GetKeyLengthList<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrprovidername: Param0) -> ::windows::runtime::Result<super::super::System::Com::VARIANT>23742     pub unsafe fn GetKeyLengthList<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrprovidername: Param0) -> ::windows::runtime::Result<super::super::System::Com::VARIANT> {
23743         let mut result__: <super::super::System::Com::VARIANT as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23744         (::windows::runtime::Interface::vtable(self).15)(::std::mem::transmute_copy(self), bstrprovidername.into_param().abi(), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
23745     }
23746     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
GetHashAlgorithmList<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrprovidername: Param0) -> ::windows::runtime::Result<super::super::System::Com::VARIANT>23747     pub unsafe fn GetHashAlgorithmList<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrprovidername: Param0) -> ::windows::runtime::Result<super::super::System::Com::VARIANT> {
23748         let mut result__: <super::super::System::Com::VARIANT as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23749         (::windows::runtime::Interface::vtable(self).16)(::std::mem::transmute_copy(self), bstrprovidername.into_param().abi(), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
23750     }
23751     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
GetPrivateKeyContainerList<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrprovidername: Param0) -> ::windows::runtime::Result<super::super::System::Com::VARIANT>23752     pub unsafe fn GetPrivateKeyContainerList<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrprovidername: Param0) -> ::windows::runtime::Result<super::super::System::Com::VARIANT> {
23753         let mut result__: <super::super::System::Com::VARIANT as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23754         (::windows::runtime::Interface::vtable(self).17)(::std::mem::transmute_copy(self), bstrprovidername.into_param().abi(), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
23755     }
GetExistingCACertificates(&self) -> ::windows::runtime::Result<ICertSrvSetupKeyInformationCollection>23756     pub unsafe fn GetExistingCACertificates(&self) -> ::windows::runtime::Result<ICertSrvSetupKeyInformationCollection> {
23757         let mut result__: <ICertSrvSetupKeyInformationCollection as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23758         (::windows::runtime::Interface::vtable(self).18)(::std::mem::transmute_copy(self), &mut result__).from_abi::<ICertSrvSetupKeyInformationCollection>(result__)
23759     }
23760     #[cfg(feature = "Win32_Foundation")]
CAImportPFX<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrfilename: Param0, bstrpasswd: Param1, boverwriteexistingkey: i16) -> ::windows::runtime::Result<ICertSrvSetupKeyInformation>23761     pub unsafe fn CAImportPFX<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrfilename: Param0, bstrpasswd: Param1, boverwriteexistingkey: i16) -> ::windows::runtime::Result<ICertSrvSetupKeyInformation> {
23762         let mut result__: <ICertSrvSetupKeyInformation as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23763         (::windows::runtime::Interface::vtable(self).19)(::std::mem::transmute_copy(self), bstrfilename.into_param().abi(), bstrpasswd.into_param().abi(), ::std::mem::transmute(boverwriteexistingkey), &mut result__).from_abi::<ICertSrvSetupKeyInformation>(result__)
23764     }
23765     #[cfg(feature = "Win32_Foundation")]
SetCADistinguishedName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrcadn: Param0, bignoreunicode: i16, boverwriteexistingkey: i16, boverwriteexistingcainds: i16) -> ::windows::runtime::Result<()>23766     pub unsafe fn SetCADistinguishedName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrcadn: Param0, bignoreunicode: i16, boverwriteexistingkey: i16, boverwriteexistingcainds: i16) -> ::windows::runtime::Result<()> {
23767         (::windows::runtime::Interface::vtable(self).20)(::std::mem::transmute_copy(self), bstrcadn.into_param().abi(), ::std::mem::transmute(bignoreunicode), ::std::mem::transmute(boverwriteexistingkey), ::std::mem::transmute(boverwriteexistingcainds)).ok()
23768     }
23769     #[cfg(feature = "Win32_Foundation")]
SetDatabaseInformation<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrdbdirectory: Param0, bstrlogdirectory: Param1, bstrsharedfolder: Param2, bforceoverwrite: i16) -> ::windows::runtime::Result<()>23770     pub unsafe fn SetDatabaseInformation<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrdbdirectory: Param0, bstrlogdirectory: Param1, bstrsharedfolder: Param2, bforceoverwrite: i16) -> ::windows::runtime::Result<()> {
23771         (::windows::runtime::Interface::vtable(self).21)(::std::mem::transmute_copy(self), bstrdbdirectory.into_param().abi(), bstrlogdirectory.into_param().abi(), bstrsharedfolder.into_param().abi(), ::std::mem::transmute(bforceoverwrite)).ok()
23772     }
23773     #[cfg(feature = "Win32_Foundation")]
SetParentCAInformation<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrcaconfiguration: Param0) -> ::windows::runtime::Result<()>23774     pub unsafe fn SetParentCAInformation<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrcaconfiguration: Param0) -> ::windows::runtime::Result<()> {
23775         (::windows::runtime::Interface::vtable(self).22)(::std::mem::transmute_copy(self), bstrcaconfiguration.into_param().abi()).ok()
23776     }
23777     #[cfg(feature = "Win32_Foundation")]
SetWebCAInformation<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrcaconfiguration: Param0) -> ::windows::runtime::Result<()>23778     pub unsafe fn SetWebCAInformation<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrcaconfiguration: Param0) -> ::windows::runtime::Result<()> {
23779         (::windows::runtime::Interface::vtable(self).23)(::std::mem::transmute_copy(self), bstrcaconfiguration.into_param().abi()).ok()
23780     }
Install(&self) -> ::windows::runtime::Result<()>23781     pub unsafe fn Install(&self) -> ::windows::runtime::Result<()> {
23782         (::windows::runtime::Interface::vtable(self).24)(::std::mem::transmute_copy(self)).ok()
23783     }
PreUnInstall(&self, bclientonly: i16) -> ::windows::runtime::Result<()>23784     pub unsafe fn PreUnInstall(&self, bclientonly: i16) -> ::windows::runtime::Result<()> {
23785         (::windows::runtime::Interface::vtable(self).25)(::std::mem::transmute_copy(self), ::std::mem::transmute(bclientonly)).ok()
23786     }
PostUnInstall(&self) -> ::windows::runtime::Result<()>23787     pub unsafe fn PostUnInstall(&self) -> ::windows::runtime::Result<()> {
23788         (::windows::runtime::Interface::vtable(self).26)(::std::mem::transmute_copy(self)).ok()
23789     }
23790 }
23791 unsafe impl ::windows::runtime::Interface for ICertSrvSetup {
23792     type Vtable = ICertSrvSetup_abi;
23793     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3076563387, 18308, 17600, [143, 18, 85, 95, 7, 128, 255, 37]);
23794 }
23795 impl ::std::convert::From<ICertSrvSetup> for ::windows::runtime::IUnknown {
from(value: ICertSrvSetup) -> Self23796     fn from(value: ICertSrvSetup) -> Self {
23797         unsafe { ::std::mem::transmute(value) }
23798     }
23799 }
23800 impl ::std::convert::From<&ICertSrvSetup> for ::windows::runtime::IUnknown {
from(value: &ICertSrvSetup) -> Self23801     fn from(value: &ICertSrvSetup) -> Self {
23802         ::std::convert::From::from(::std::clone::Clone::clone(value))
23803     }
23804 }
23805 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for ICertSrvSetup {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>23806     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
23807         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
23808     }
23809 }
23810 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &ICertSrvSetup {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>23811     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
23812         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
23813     }
23814 }
23815 #[cfg(feature = "Win32_System_Ole_Automation")]
23816 impl ::std::convert::From<ICertSrvSetup> for super::super::System::Ole::Automation::IDispatch {
from(value: ICertSrvSetup) -> Self23817     fn from(value: ICertSrvSetup) -> Self {
23818         unsafe { ::std::mem::transmute(value) }
23819     }
23820 }
23821 #[cfg(feature = "Win32_System_Ole_Automation")]
23822 impl ::std::convert::From<&ICertSrvSetup> for super::super::System::Ole::Automation::IDispatch {
from(value: &ICertSrvSetup) -> Self23823     fn from(value: &ICertSrvSetup) -> Self {
23824         ::std::convert::From::from(::std::clone::Clone::clone(value))
23825     }
23826 }
23827 #[cfg(feature = "Win32_System_Ole_Automation")]
23828 impl<'a> ::windows::runtime::IntoParam<'a, super::super::System::Ole::Automation::IDispatch> for ICertSrvSetup {
into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch>23829     fn into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch> {
23830         ::windows::runtime::Param::Owned(::std::convert::Into::<super::super::System::Ole::Automation::IDispatch>::into(self))
23831     }
23832 }
23833 #[cfg(feature = "Win32_System_Ole_Automation")]
23834 impl<'a> ::windows::runtime::IntoParam<'a, super::super::System::Ole::Automation::IDispatch> for &ICertSrvSetup {
into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch>23835     fn into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch> {
23836         ::windows::runtime::Param::Owned(::std::convert::Into::<super::super::System::Ole::Automation::IDispatch>::into(::std::clone::Clone::clone(self)))
23837     }
23838 }
23839 #[repr(C)]
23840 #[doc(hidden)]
23841 pub struct ICertSrvSetup_abi(
23842     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
23843     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
23844     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
23845     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pctinfo: *mut u32) -> ::windows::runtime::HRESULT,
23846     #[cfg(feature = "Win32_System_Ole_Automation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
23847     #[cfg(not(feature = "Win32_System_Ole_Automation"))] usize,
23848     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::runtime::HRESULT,
23849     #[cfg(not(feature = "Win32_Foundation"))] usize,
23850     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
23851     pub  unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dispidmember: i32, riid: *const ::windows::runtime::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Ole::Automation::DISPPARAMS, pvarresult: *mut ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::std::mem::ManuallyDrop<super::super::System::Ole::Automation::EXCEPINFO>, puargerr: *mut u32) -> ::windows::runtime::HRESULT,
23852     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
23853     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pval: *mut i32) -> ::windows::runtime::HRESULT,
23854     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pval: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
23855     #[cfg(not(feature = "Win32_Foundation"))] usize,
23856     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bserver: i16, bclient: i16) -> ::windows::runtime::HRESULT,
23857     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, propertyid: CASetupProperty, ppropertyvalue: *mut ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
23858     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
23859     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, propertyid: CASetupProperty, ppropertyvalue: *const ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
23860     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
23861     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, propertyid: CASetupProperty, pbeditable: *mut i16) -> ::windows::runtime::HRESULT,
23862     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pcatypes: *mut ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
23863     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
23864     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pval: *mut ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
23865     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
23866     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bstrprovidername: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, pval: *mut ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
23867     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
23868     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bstrprovidername: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, pval: *mut ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
23869     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
23870     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bstrprovidername: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, pval: *mut ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
23871     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
23872     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppval: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
23873     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bstrfilename: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, bstrpasswd: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, boverwriteexistingkey: i16, ppval: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
23874     #[cfg(not(feature = "Win32_Foundation"))] usize,
23875     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bstrcadn: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, bignoreunicode: i16, boverwriteexistingkey: i16, boverwriteexistingcainds: i16) -> ::windows::runtime::HRESULT,
23876     #[cfg(not(feature = "Win32_Foundation"))] usize,
23877     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bstrdbdirectory: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, bstrlogdirectory: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, bstrsharedfolder: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, bforceoverwrite: i16) -> ::windows::runtime::HRESULT,
23878     #[cfg(not(feature = "Win32_Foundation"))] usize,
23879     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bstrcaconfiguration: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
23880     #[cfg(not(feature = "Win32_Foundation"))] usize,
23881     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bstrcaconfiguration: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
23882     #[cfg(not(feature = "Win32_Foundation"))] usize,
23883     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
23884     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bclientonly: i16) -> ::windows::runtime::HRESULT,
23885     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
23886 );
23887 #[repr(transparent)]
23888 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
23889 pub struct ICertSrvSetupKeyInformation(::windows::runtime::IUnknown);
23890 impl ICertSrvSetupKeyInformation {
23891     #[cfg(feature = "Win32_Foundation")]
ProviderName(&self) -> ::windows::runtime::Result<super::super::Foundation::BSTR>23892     pub unsafe fn ProviderName(&self) -> ::windows::runtime::Result<super::super::Foundation::BSTR> {
23893         let mut result__: <super::super::Foundation::BSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23894         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
23895     }
23896     #[cfg(feature = "Win32_Foundation")]
SetProviderName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrval: Param0) -> ::windows::runtime::Result<()>23897     pub unsafe fn SetProviderName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrval: Param0) -> ::windows::runtime::Result<()> {
23898         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), bstrval.into_param().abi()).ok()
23899     }
Length(&self) -> ::windows::runtime::Result<i32>23900     pub unsafe fn Length(&self) -> ::windows::runtime::Result<i32> {
23901         let mut result__: <i32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23902         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
23903     }
SetLength(&self, lval: i32) -> ::windows::runtime::Result<()>23904     pub unsafe fn SetLength(&self, lval: i32) -> ::windows::runtime::Result<()> {
23905         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), ::std::mem::transmute(lval)).ok()
23906     }
Existing(&self) -> ::windows::runtime::Result<i16>23907     pub unsafe fn Existing(&self) -> ::windows::runtime::Result<i16> {
23908         let mut result__: <i16 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23909         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), &mut result__).from_abi::<i16>(result__)
23910     }
SetExisting(&self, bval: i16) -> ::windows::runtime::Result<()>23911     pub unsafe fn SetExisting(&self, bval: i16) -> ::windows::runtime::Result<()> {
23912         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), ::std::mem::transmute(bval)).ok()
23913     }
23914     #[cfg(feature = "Win32_Foundation")]
ContainerName(&self) -> ::windows::runtime::Result<super::super::Foundation::BSTR>23915     pub unsafe fn ContainerName(&self) -> ::windows::runtime::Result<super::super::Foundation::BSTR> {
23916         let mut result__: <super::super::Foundation::BSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23917         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
23918     }
23919     #[cfg(feature = "Win32_Foundation")]
SetContainerName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrval: Param0) -> ::windows::runtime::Result<()>23920     pub unsafe fn SetContainerName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrval: Param0) -> ::windows::runtime::Result<()> {
23921         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), bstrval.into_param().abi()).ok()
23922     }
23923     #[cfg(feature = "Win32_Foundation")]
HashAlgorithm(&self) -> ::windows::runtime::Result<super::super::Foundation::BSTR>23924     pub unsafe fn HashAlgorithm(&self) -> ::windows::runtime::Result<super::super::Foundation::BSTR> {
23925         let mut result__: <super::super::Foundation::BSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23926         (::windows::runtime::Interface::vtable(self).15)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
23927     }
23928     #[cfg(feature = "Win32_Foundation")]
SetHashAlgorithm<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrval: Param0) -> ::windows::runtime::Result<()>23929     pub unsafe fn SetHashAlgorithm<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrval: Param0) -> ::windows::runtime::Result<()> {
23930         (::windows::runtime::Interface::vtable(self).16)(::std::mem::transmute_copy(self), bstrval.into_param().abi()).ok()
23931     }
23932     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
ExistingCACertificate(&self) -> ::windows::runtime::Result<super::super::System::Com::VARIANT>23933     pub unsafe fn ExistingCACertificate(&self) -> ::windows::runtime::Result<super::super::System::Com::VARIANT> {
23934         let mut result__: <super::super::System::Com::VARIANT as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
23935         (::windows::runtime::Interface::vtable(self).17)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
23936     }
23937     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
SetExistingCACertificate<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, varval: Param0) -> ::windows::runtime::Result<()>23938     pub unsafe fn SetExistingCACertificate<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, varval: Param0) -> ::windows::runtime::Result<()> {
23939         (::windows::runtime::Interface::vtable(self).18)(::std::mem::transmute_copy(self), varval.into_param().abi()).ok()
23940     }
23941 }
23942 unsafe impl ::windows::runtime::Interface for ICertSrvSetupKeyInformation {
23943     type Vtable = ICertSrvSetupKeyInformation_abi;
23944     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1806120824, 14042, 19513, [138, 133, 188, 250, 125, 0, 7, 147]);
23945 }
23946 impl ::std::convert::From<ICertSrvSetupKeyInformation> for ::windows::runtime::IUnknown {
from(value: ICertSrvSetupKeyInformation) -> Self23947     fn from(value: ICertSrvSetupKeyInformation) -> Self {
23948         unsafe { ::std::mem::transmute(value) }
23949     }
23950 }
23951 impl ::std::convert::From<&ICertSrvSetupKeyInformation> for ::windows::runtime::IUnknown {
from(value: &ICertSrvSetupKeyInformation) -> Self23952     fn from(value: &ICertSrvSetupKeyInformation) -> Self {
23953         ::std::convert::From::from(::std::clone::Clone::clone(value))
23954     }
23955 }
23956 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for ICertSrvSetupKeyInformation {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>23957     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
23958         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
23959     }
23960 }
23961 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &ICertSrvSetupKeyInformation {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>23962     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
23963         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
23964     }
23965 }
23966 #[cfg(feature = "Win32_System_Ole_Automation")]
23967 impl ::std::convert::From<ICertSrvSetupKeyInformation> for super::super::System::Ole::Automation::IDispatch {
from(value: ICertSrvSetupKeyInformation) -> Self23968     fn from(value: ICertSrvSetupKeyInformation) -> Self {
23969         unsafe { ::std::mem::transmute(value) }
23970     }
23971 }
23972 #[cfg(feature = "Win32_System_Ole_Automation")]
23973 impl ::std::convert::From<&ICertSrvSetupKeyInformation> for super::super::System::Ole::Automation::IDispatch {
from(value: &ICertSrvSetupKeyInformation) -> Self23974     fn from(value: &ICertSrvSetupKeyInformation) -> Self {
23975         ::std::convert::From::from(::std::clone::Clone::clone(value))
23976     }
23977 }
23978 #[cfg(feature = "Win32_System_Ole_Automation")]
23979 impl<'a> ::windows::runtime::IntoParam<'a, super::super::System::Ole::Automation::IDispatch> for ICertSrvSetupKeyInformation {
into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch>23980     fn into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch> {
23981         ::windows::runtime::Param::Owned(::std::convert::Into::<super::super::System::Ole::Automation::IDispatch>::into(self))
23982     }
23983 }
23984 #[cfg(feature = "Win32_System_Ole_Automation")]
23985 impl<'a> ::windows::runtime::IntoParam<'a, super::super::System::Ole::Automation::IDispatch> for &ICertSrvSetupKeyInformation {
into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch>23986     fn into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch> {
23987         ::windows::runtime::Param::Owned(::std::convert::Into::<super::super::System::Ole::Automation::IDispatch>::into(::std::clone::Clone::clone(self)))
23988     }
23989 }
23990 #[repr(C)]
23991 #[doc(hidden)]
23992 pub struct ICertSrvSetupKeyInformation_abi(
23993     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
23994     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
23995     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
23996     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pctinfo: *mut u32) -> ::windows::runtime::HRESULT,
23997     #[cfg(feature = "Win32_System_Ole_Automation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
23998     #[cfg(not(feature = "Win32_System_Ole_Automation"))] usize,
23999     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::runtime::HRESULT,
24000     #[cfg(not(feature = "Win32_Foundation"))] usize,
24001     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
24002     pub  unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dispidmember: i32, riid: *const ::windows::runtime::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Ole::Automation::DISPPARAMS, pvarresult: *mut ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::std::mem::ManuallyDrop<super::super::System::Ole::Automation::EXCEPINFO>, puargerr: *mut u32) -> ::windows::runtime::HRESULT,
24003     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
24004     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pval: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
24005     #[cfg(not(feature = "Win32_Foundation"))] usize,
24006     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bstrval: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
24007     #[cfg(not(feature = "Win32_Foundation"))] usize,
24008     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pval: *mut i32) -> ::windows::runtime::HRESULT,
24009     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, lval: i32) -> ::windows::runtime::HRESULT,
24010     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pval: *mut i16) -> ::windows::runtime::HRESULT,
24011     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bval: i16) -> ::windows::runtime::HRESULT,
24012     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pval: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
24013     #[cfg(not(feature = "Win32_Foundation"))] usize,
24014     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bstrval: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
24015     #[cfg(not(feature = "Win32_Foundation"))] usize,
24016     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pval: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
24017     #[cfg(not(feature = "Win32_Foundation"))] usize,
24018     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bstrval: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
24019     #[cfg(not(feature = "Win32_Foundation"))] usize,
24020     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pval: *mut ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
24021     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
24022     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, varval: ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
24023     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
24024 );
24025 #[repr(transparent)]
24026 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
24027 pub struct ICertSrvSetupKeyInformationCollection(::windows::runtime::IUnknown);
24028 impl ICertSrvSetupKeyInformationCollection {
_NewEnum(&self) -> ::windows::runtime::Result<::windows::runtime::IUnknown>24029     pub unsafe fn _NewEnum(&self) -> ::windows::runtime::Result<::windows::runtime::IUnknown> {
24030         let mut result__: <::windows::runtime::IUnknown as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
24031         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), &mut result__).from_abi::<::windows::runtime::IUnknown>(result__)
24032     }
24033     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
Item(&self, index: i32) -> ::windows::runtime::Result<super::super::System::Com::VARIANT>24034     pub unsafe fn Item(&self, index: i32) -> ::windows::runtime::Result<super::super::System::Com::VARIANT> {
24035         let mut result__: <super::super::System::Com::VARIANT as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
24036         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(index), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
24037     }
Count(&self) -> ::windows::runtime::Result<i32>24038     pub unsafe fn Count(&self) -> ::windows::runtime::Result<i32> {
24039         let mut result__: <i32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
24040         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
24041     }
Add<'a, Param0: ::windows::runtime::IntoParam<'a, ICertSrvSetupKeyInformation>>(&self, pikeyinformation: Param0) -> ::windows::runtime::Result<()>24042     pub unsafe fn Add<'a, Param0: ::windows::runtime::IntoParam<'a, ICertSrvSetupKeyInformation>>(&self, pikeyinformation: Param0) -> ::windows::runtime::Result<()> {
24043         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), pikeyinformation.into_param().abi()).ok()
24044     }
24045 }
24046 unsafe impl ::windows::runtime::Interface for ICertSrvSetupKeyInformationCollection {
24047     type Vtable = ICertSrvSetupKeyInformationCollection_abi;
24048     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3864824576, 58767, 16889, [169, 236, 162, 141, 116, 39, 200, 68]);
24049 }
24050 impl ::std::convert::From<ICertSrvSetupKeyInformationCollection> for ::windows::runtime::IUnknown {
from(value: ICertSrvSetupKeyInformationCollection) -> Self24051     fn from(value: ICertSrvSetupKeyInformationCollection) -> Self {
24052         unsafe { ::std::mem::transmute(value) }
24053     }
24054 }
24055 impl ::std::convert::From<&ICertSrvSetupKeyInformationCollection> for ::windows::runtime::IUnknown {
from(value: &ICertSrvSetupKeyInformationCollection) -> Self24056     fn from(value: &ICertSrvSetupKeyInformationCollection) -> Self {
24057         ::std::convert::From::from(::std::clone::Clone::clone(value))
24058     }
24059 }
24060 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for ICertSrvSetupKeyInformationCollection {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>24061     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
24062         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
24063     }
24064 }
24065 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &ICertSrvSetupKeyInformationCollection {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>24066     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
24067         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
24068     }
24069 }
24070 #[cfg(feature = "Win32_System_Ole_Automation")]
24071 impl ::std::convert::From<ICertSrvSetupKeyInformationCollection> for super::super::System::Ole::Automation::IDispatch {
from(value: ICertSrvSetupKeyInformationCollection) -> Self24072     fn from(value: ICertSrvSetupKeyInformationCollection) -> Self {
24073         unsafe { ::std::mem::transmute(value) }
24074     }
24075 }
24076 #[cfg(feature = "Win32_System_Ole_Automation")]
24077 impl ::std::convert::From<&ICertSrvSetupKeyInformationCollection> for super::super::System::Ole::Automation::IDispatch {
from(value: &ICertSrvSetupKeyInformationCollection) -> Self24078     fn from(value: &ICertSrvSetupKeyInformationCollection) -> Self {
24079         ::std::convert::From::from(::std::clone::Clone::clone(value))
24080     }
24081 }
24082 #[cfg(feature = "Win32_System_Ole_Automation")]
24083 impl<'a> ::windows::runtime::IntoParam<'a, super::super::System::Ole::Automation::IDispatch> for ICertSrvSetupKeyInformationCollection {
into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch>24084     fn into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch> {
24085         ::windows::runtime::Param::Owned(::std::convert::Into::<super::super::System::Ole::Automation::IDispatch>::into(self))
24086     }
24087 }
24088 #[cfg(feature = "Win32_System_Ole_Automation")]
24089 impl<'a> ::windows::runtime::IntoParam<'a, super::super::System::Ole::Automation::IDispatch> for &ICertSrvSetupKeyInformationCollection {
into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch>24090     fn into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch> {
24091         ::windows::runtime::Param::Owned(::std::convert::Into::<super::super::System::Ole::Automation::IDispatch>::into(::std::clone::Clone::clone(self)))
24092     }
24093 }
24094 #[repr(C)]
24095 #[doc(hidden)]
24096 pub struct ICertSrvSetupKeyInformationCollection_abi(
24097     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
24098     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
24099     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
24100     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pctinfo: *mut u32) -> ::windows::runtime::HRESULT,
24101     #[cfg(feature = "Win32_System_Ole_Automation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
24102     #[cfg(not(feature = "Win32_System_Ole_Automation"))] usize,
24103     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::runtime::HRESULT,
24104     #[cfg(not(feature = "Win32_Foundation"))] usize,
24105     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
24106     pub  unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dispidmember: i32, riid: *const ::windows::runtime::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Ole::Automation::DISPPARAMS, pvarresult: *mut ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::std::mem::ManuallyDrop<super::super::System::Ole::Automation::EXCEPINFO>, puargerr: *mut u32) -> ::windows::runtime::HRESULT,
24107     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
24108     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppval: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
24109     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, index: i32, pval: *mut ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
24110     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
24111     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pval: *mut i32) -> ::windows::runtime::HRESULT,
24112     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pikeyinformation: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
24113 );
24114 #[repr(transparent)]
24115 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
24116 pub struct ICertificateEnrollmentPolicyServerSetup(::windows::runtime::IUnknown);
24117 impl ICertificateEnrollmentPolicyServerSetup {
24118     #[cfg(feature = "Win32_Foundation")]
ErrorString(&self) -> ::windows::runtime::Result<super::super::Foundation::BSTR>24119     pub unsafe fn ErrorString(&self) -> ::windows::runtime::Result<super::super::Foundation::BSTR> {
24120         let mut result__: <super::super::Foundation::BSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
24121         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
24122     }
InitializeInstallDefaults(&self) -> ::windows::runtime::Result<()>24123     pub unsafe fn InitializeInstallDefaults(&self) -> ::windows::runtime::Result<()> {
24124         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self)).ok()
24125     }
24126     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
GetProperty(&self, propertyid: CEPSetupProperty) -> ::windows::runtime::Result<super::super::System::Com::VARIANT>24127     pub unsafe fn GetProperty(&self, propertyid: CEPSetupProperty) -> ::windows::runtime::Result<super::super::System::Com::VARIANT> {
24128         let mut result__: <super::super::System::Com::VARIANT as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
24129         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), ::std::mem::transmute(propertyid), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
24130     }
24131     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
SetProperty(&self, propertyid: CEPSetupProperty, ppropertyvalue: *const super::super::System::Com::VARIANT) -> ::windows::runtime::Result<()>24132     pub unsafe fn SetProperty(&self, propertyid: CEPSetupProperty, ppropertyvalue: *const super::super::System::Com::VARIANT) -> ::windows::runtime::Result<()> {
24133         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), ::std::mem::transmute(propertyid), ::std::mem::transmute(ppropertyvalue)).ok()
24134     }
Install(&self) -> ::windows::runtime::Result<()>24135     pub unsafe fn Install(&self) -> ::windows::runtime::Result<()> {
24136         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self)).ok()
24137     }
24138     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
UnInstall(&self, pauthkeybasedrenewal: *const super::super::System::Com::VARIANT) -> ::windows::runtime::Result<()>24139     pub unsafe fn UnInstall(&self, pauthkeybasedrenewal: *const super::super::System::Com::VARIANT) -> ::windows::runtime::Result<()> {
24140         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), ::std::mem::transmute(pauthkeybasedrenewal)).ok()
24141     }
24142 }
24143 unsafe impl ::windows::runtime::Interface for ICertificateEnrollmentPolicyServerSetup {
24144     type Vtable = ICertificateEnrollmentPolicyServerSetup_abi;
24145     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2240959180, 9100, 19080, [184, 253, 163, 126, 125, 4, 230, 139]);
24146 }
24147 impl ::std::convert::From<ICertificateEnrollmentPolicyServerSetup> for ::windows::runtime::IUnknown {
from(value: ICertificateEnrollmentPolicyServerSetup) -> Self24148     fn from(value: ICertificateEnrollmentPolicyServerSetup) -> Self {
24149         unsafe { ::std::mem::transmute(value) }
24150     }
24151 }
24152 impl ::std::convert::From<&ICertificateEnrollmentPolicyServerSetup> for ::windows::runtime::IUnknown {
from(value: &ICertificateEnrollmentPolicyServerSetup) -> Self24153     fn from(value: &ICertificateEnrollmentPolicyServerSetup) -> Self {
24154         ::std::convert::From::from(::std::clone::Clone::clone(value))
24155     }
24156 }
24157 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for ICertificateEnrollmentPolicyServerSetup {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>24158     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
24159         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
24160     }
24161 }
24162 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &ICertificateEnrollmentPolicyServerSetup {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>24163     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
24164         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
24165     }
24166 }
24167 #[cfg(feature = "Win32_System_Ole_Automation")]
24168 impl ::std::convert::From<ICertificateEnrollmentPolicyServerSetup> for super::super::System::Ole::Automation::IDispatch {
from(value: ICertificateEnrollmentPolicyServerSetup) -> Self24169     fn from(value: ICertificateEnrollmentPolicyServerSetup) -> Self {
24170         unsafe { ::std::mem::transmute(value) }
24171     }
24172 }
24173 #[cfg(feature = "Win32_System_Ole_Automation")]
24174 impl ::std::convert::From<&ICertificateEnrollmentPolicyServerSetup> for super::super::System::Ole::Automation::IDispatch {
from(value: &ICertificateEnrollmentPolicyServerSetup) -> Self24175     fn from(value: &ICertificateEnrollmentPolicyServerSetup) -> Self {
24176         ::std::convert::From::from(::std::clone::Clone::clone(value))
24177     }
24178 }
24179 #[cfg(feature = "Win32_System_Ole_Automation")]
24180 impl<'a> ::windows::runtime::IntoParam<'a, super::super::System::Ole::Automation::IDispatch> for ICertificateEnrollmentPolicyServerSetup {
into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch>24181     fn into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch> {
24182         ::windows::runtime::Param::Owned(::std::convert::Into::<super::super::System::Ole::Automation::IDispatch>::into(self))
24183     }
24184 }
24185 #[cfg(feature = "Win32_System_Ole_Automation")]
24186 impl<'a> ::windows::runtime::IntoParam<'a, super::super::System::Ole::Automation::IDispatch> for &ICertificateEnrollmentPolicyServerSetup {
into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch>24187     fn into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch> {
24188         ::windows::runtime::Param::Owned(::std::convert::Into::<super::super::System::Ole::Automation::IDispatch>::into(::std::clone::Clone::clone(self)))
24189     }
24190 }
24191 #[repr(C)]
24192 #[doc(hidden)]
24193 pub struct ICertificateEnrollmentPolicyServerSetup_abi(
24194     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
24195     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
24196     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
24197     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pctinfo: *mut u32) -> ::windows::runtime::HRESULT,
24198     #[cfg(feature = "Win32_System_Ole_Automation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
24199     #[cfg(not(feature = "Win32_System_Ole_Automation"))] usize,
24200     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::runtime::HRESULT,
24201     #[cfg(not(feature = "Win32_Foundation"))] usize,
24202     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
24203     pub  unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dispidmember: i32, riid: *const ::windows::runtime::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Ole::Automation::DISPPARAMS, pvarresult: *mut ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::std::mem::ManuallyDrop<super::super::System::Ole::Automation::EXCEPINFO>, puargerr: *mut u32) -> ::windows::runtime::HRESULT,
24204     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
24205     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pval: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
24206     #[cfg(not(feature = "Win32_Foundation"))] usize,
24207     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
24208     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, propertyid: CEPSetupProperty, ppropertyvalue: *mut ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
24209     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
24210     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, propertyid: CEPSetupProperty, ppropertyvalue: *const ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
24211     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
24212     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
24213     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pauthkeybasedrenewal: *const ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
24214     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
24215 );
24216 #[repr(transparent)]
24217 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
24218 pub struct ICertificateEnrollmentServerSetup(::windows::runtime::IUnknown);
24219 impl ICertificateEnrollmentServerSetup {
24220     #[cfg(feature = "Win32_Foundation")]
ErrorString(&self) -> ::windows::runtime::Result<super::super::Foundation::BSTR>24221     pub unsafe fn ErrorString(&self) -> ::windows::runtime::Result<super::super::Foundation::BSTR> {
24222         let mut result__: <super::super::Foundation::BSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
24223         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
24224     }
InitializeInstallDefaults(&self) -> ::windows::runtime::Result<()>24225     pub unsafe fn InitializeInstallDefaults(&self) -> ::windows::runtime::Result<()> {
24226         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self)).ok()
24227     }
24228     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
GetProperty(&self, propertyid: CESSetupProperty) -> ::windows::runtime::Result<super::super::System::Com::VARIANT>24229     pub unsafe fn GetProperty(&self, propertyid: CESSetupProperty) -> ::windows::runtime::Result<super::super::System::Com::VARIANT> {
24230         let mut result__: <super::super::System::Com::VARIANT as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
24231         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), ::std::mem::transmute(propertyid), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
24232     }
24233     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
SetProperty(&self, propertyid: CESSetupProperty, ppropertyvalue: *const super::super::System::Com::VARIANT) -> ::windows::runtime::Result<()>24234     pub unsafe fn SetProperty(&self, propertyid: CESSetupProperty, ppropertyvalue: *const super::super::System::Com::VARIANT) -> ::windows::runtime::Result<()> {
24235         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), ::std::mem::transmute(propertyid), ::std::mem::transmute(ppropertyvalue)).ok()
24236     }
24237     #[cfg(feature = "Win32_Foundation")]
SetApplicationPoolCredentials<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrusername: Param0, bstrpassword: Param1) -> ::windows::runtime::Result<()>24238     pub unsafe fn SetApplicationPoolCredentials<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrusername: Param0, bstrpassword: Param1) -> ::windows::runtime::Result<()> {
24239         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), bstrusername.into_param().abi(), bstrpassword.into_param().abi()).ok()
24240     }
Install(&self) -> ::windows::runtime::Result<()>24241     pub unsafe fn Install(&self) -> ::windows::runtime::Result<()> {
24242         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self)).ok()
24243     }
24244     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
UnInstall(&self, pcaconfig: *const super::super::System::Com::VARIANT, pauthentication: *const super::super::System::Com::VARIANT) -> ::windows::runtime::Result<()>24245     pub unsafe fn UnInstall(&self, pcaconfig: *const super::super::System::Com::VARIANT, pauthentication: *const super::super::System::Com::VARIANT) -> ::windows::runtime::Result<()> {
24246         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), ::std::mem::transmute(pcaconfig), ::std::mem::transmute(pauthentication)).ok()
24247     }
24248 }
24249 unsafe impl ::windows::runtime::Interface for ICertificateEnrollmentServerSetup {
24250     type Vtable = ICertificateEnrollmentServerSetup_abi;
24251     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1879211995, 40409, 18721, [137, 68, 179, 92, 179, 27, 210, 236]);
24252 }
24253 impl ::std::convert::From<ICertificateEnrollmentServerSetup> for ::windows::runtime::IUnknown {
from(value: ICertificateEnrollmentServerSetup) -> Self24254     fn from(value: ICertificateEnrollmentServerSetup) -> Self {
24255         unsafe { ::std::mem::transmute(value) }
24256     }
24257 }
24258 impl ::std::convert::From<&ICertificateEnrollmentServerSetup> for ::windows::runtime::IUnknown {
from(value: &ICertificateEnrollmentServerSetup) -> Self24259     fn from(value: &ICertificateEnrollmentServerSetup) -> Self {
24260         ::std::convert::From::from(::std::clone::Clone::clone(value))
24261     }
24262 }
24263 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for ICertificateEnrollmentServerSetup {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>24264     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
24265         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
24266     }
24267 }
24268 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &ICertificateEnrollmentServerSetup {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>24269     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
24270         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
24271     }
24272 }
24273 #[cfg(feature = "Win32_System_Ole_Automation")]
24274 impl ::std::convert::From<ICertificateEnrollmentServerSetup> for super::super::System::Ole::Automation::IDispatch {
from(value: ICertificateEnrollmentServerSetup) -> Self24275     fn from(value: ICertificateEnrollmentServerSetup) -> Self {
24276         unsafe { ::std::mem::transmute(value) }
24277     }
24278 }
24279 #[cfg(feature = "Win32_System_Ole_Automation")]
24280 impl ::std::convert::From<&ICertificateEnrollmentServerSetup> for super::super::System::Ole::Automation::IDispatch {
from(value: &ICertificateEnrollmentServerSetup) -> Self24281     fn from(value: &ICertificateEnrollmentServerSetup) -> Self {
24282         ::std::convert::From::from(::std::clone::Clone::clone(value))
24283     }
24284 }
24285 #[cfg(feature = "Win32_System_Ole_Automation")]
24286 impl<'a> ::windows::runtime::IntoParam<'a, super::super::System::Ole::Automation::IDispatch> for ICertificateEnrollmentServerSetup {
into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch>24287     fn into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch> {
24288         ::windows::runtime::Param::Owned(::std::convert::Into::<super::super::System::Ole::Automation::IDispatch>::into(self))
24289     }
24290 }
24291 #[cfg(feature = "Win32_System_Ole_Automation")]
24292 impl<'a> ::windows::runtime::IntoParam<'a, super::super::System::Ole::Automation::IDispatch> for &ICertificateEnrollmentServerSetup {
into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch>24293     fn into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch> {
24294         ::windows::runtime::Param::Owned(::std::convert::Into::<super::super::System::Ole::Automation::IDispatch>::into(::std::clone::Clone::clone(self)))
24295     }
24296 }
24297 #[repr(C)]
24298 #[doc(hidden)]
24299 pub struct ICertificateEnrollmentServerSetup_abi(
24300     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
24301     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
24302     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
24303     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pctinfo: *mut u32) -> ::windows::runtime::HRESULT,
24304     #[cfg(feature = "Win32_System_Ole_Automation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
24305     #[cfg(not(feature = "Win32_System_Ole_Automation"))] usize,
24306     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::runtime::HRESULT,
24307     #[cfg(not(feature = "Win32_Foundation"))] usize,
24308     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
24309     pub  unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dispidmember: i32, riid: *const ::windows::runtime::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Ole::Automation::DISPPARAMS, pvarresult: *mut ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::std::mem::ManuallyDrop<super::super::System::Ole::Automation::EXCEPINFO>, puargerr: *mut u32) -> ::windows::runtime::HRESULT,
24310     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
24311     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pval: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
24312     #[cfg(not(feature = "Win32_Foundation"))] usize,
24313     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
24314     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, propertyid: CESSetupProperty, ppropertyvalue: *mut ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
24315     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
24316     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, propertyid: CESSetupProperty, ppropertyvalue: *const ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
24317     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
24318     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bstrusername: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, bstrpassword: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
24319     #[cfg(not(feature = "Win32_Foundation"))] usize,
24320     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
24321     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pcaconfig: *const ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pauthentication: *const ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
24322     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
24323 );
24324 pub const IFX_RSA_KEYGEN_VUL_AFFECTED_LEVEL_1: u32 = 1u32;
24325 pub const IFX_RSA_KEYGEN_VUL_AFFECTED_LEVEL_2: u32 = 2u32;
24326 pub const IFX_RSA_KEYGEN_VUL_NOT_AFFECTED: u32 = 0u32;
24327 #[repr(transparent)]
24328 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
24329 pub struct IMSCEPSetup(::windows::runtime::IUnknown);
24330 impl IMSCEPSetup {
MSCEPErrorId(&self) -> ::windows::runtime::Result<i32>24331     pub unsafe fn MSCEPErrorId(&self) -> ::windows::runtime::Result<i32> {
24332         let mut result__: <i32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
24333         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
24334     }
24335     #[cfg(feature = "Win32_Foundation")]
MSCEPErrorString(&self) -> ::windows::runtime::Result<super::super::Foundation::BSTR>24336     pub unsafe fn MSCEPErrorString(&self) -> ::windows::runtime::Result<super::super::Foundation::BSTR> {
24337         let mut result__: <super::super::Foundation::BSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
24338         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
24339     }
InitializeDefaults(&self) -> ::windows::runtime::Result<()>24340     pub unsafe fn InitializeDefaults(&self) -> ::windows::runtime::Result<()> {
24341         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self)).ok()
24342     }
24343     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
GetMSCEPSetupProperty(&self, propertyid: MSCEPSetupProperty) -> ::windows::runtime::Result<super::super::System::Com::VARIANT>24344     pub unsafe fn GetMSCEPSetupProperty(&self, propertyid: MSCEPSetupProperty) -> ::windows::runtime::Result<super::super::System::Com::VARIANT> {
24345         let mut result__: <super::super::System::Com::VARIANT as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
24346         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), ::std::mem::transmute(propertyid), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
24347     }
24348     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
SetMSCEPSetupProperty(&self, propertyid: MSCEPSetupProperty, ppropertyvalue: *const super::super::System::Com::VARIANT) -> ::windows::runtime::Result<()>24349     pub unsafe fn SetMSCEPSetupProperty(&self, propertyid: MSCEPSetupProperty, ppropertyvalue: *const super::super::System::Com::VARIANT) -> ::windows::runtime::Result<()> {
24350         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), ::std::mem::transmute(propertyid), ::std::mem::transmute(ppropertyvalue)).ok()
24351     }
24352     #[cfg(feature = "Win32_Foundation")]
SetAccountInformation<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrusername: Param0, bstrpassword: Param1) -> ::windows::runtime::Result<()>24353     pub unsafe fn SetAccountInformation<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrusername: Param0, bstrpassword: Param1) -> ::windows::runtime::Result<()> {
24354         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), bstrusername.into_param().abi(), bstrpassword.into_param().abi()).ok()
24355     }
IsMSCEPStoreEmpty(&self) -> ::windows::runtime::Result<i16>24356     pub unsafe fn IsMSCEPStoreEmpty(&self) -> ::windows::runtime::Result<i16> {
24357         let mut result__: <i16 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
24358         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), &mut result__).from_abi::<i16>(result__)
24359     }
24360     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
GetProviderNameList(&self, bexchange: i16) -> ::windows::runtime::Result<super::super::System::Com::VARIANT>24361     pub unsafe fn GetProviderNameList(&self, bexchange: i16) -> ::windows::runtime::Result<super::super::System::Com::VARIANT> {
24362         let mut result__: <super::super::System::Com::VARIANT as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
24363         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), ::std::mem::transmute(bexchange), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
24364     }
24365     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
GetKeyLengthList<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bexchange: i16, bstrprovidername: Param1) -> ::windows::runtime::Result<super::super::System::Com::VARIANT>24366     pub unsafe fn GetKeyLengthList<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bexchange: i16, bstrprovidername: Param1) -> ::windows::runtime::Result<super::super::System::Com::VARIANT> {
24367         let mut result__: <super::super::System::Com::VARIANT as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
24368         (::windows::runtime::Interface::vtable(self).15)(::std::mem::transmute_copy(self), ::std::mem::transmute(bexchange), bstrprovidername.into_param().abi(), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
24369     }
Install(&self) -> ::windows::runtime::Result<()>24370     pub unsafe fn Install(&self) -> ::windows::runtime::Result<()> {
24371         (::windows::runtime::Interface::vtable(self).16)(::std::mem::transmute_copy(self)).ok()
24372     }
PreUnInstall(&self) -> ::windows::runtime::Result<()>24373     pub unsafe fn PreUnInstall(&self) -> ::windows::runtime::Result<()> {
24374         (::windows::runtime::Interface::vtable(self).17)(::std::mem::transmute_copy(self)).ok()
24375     }
PostUnInstall(&self) -> ::windows::runtime::Result<()>24376     pub unsafe fn PostUnInstall(&self) -> ::windows::runtime::Result<()> {
24377         (::windows::runtime::Interface::vtable(self).18)(::std::mem::transmute_copy(self)).ok()
24378     }
24379 }
24380 unsafe impl ::windows::runtime::Interface for IMSCEPSetup {
24381     type Vtable = IMSCEPSetup_abi;
24382     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1333223867, 40763, 17810, [158, 224, 154, 115, 37, 156, 49, 62]);
24383 }
24384 impl ::std::convert::From<IMSCEPSetup> for ::windows::runtime::IUnknown {
from(value: IMSCEPSetup) -> Self24385     fn from(value: IMSCEPSetup) -> Self {
24386         unsafe { ::std::mem::transmute(value) }
24387     }
24388 }
24389 impl ::std::convert::From<&IMSCEPSetup> for ::windows::runtime::IUnknown {
from(value: &IMSCEPSetup) -> Self24390     fn from(value: &IMSCEPSetup) -> Self {
24391         ::std::convert::From::from(::std::clone::Clone::clone(value))
24392     }
24393 }
24394 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMSCEPSetup {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>24395     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
24396         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
24397     }
24398 }
24399 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMSCEPSetup {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>24400     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
24401         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
24402     }
24403 }
24404 #[cfg(feature = "Win32_System_Ole_Automation")]
24405 impl ::std::convert::From<IMSCEPSetup> for super::super::System::Ole::Automation::IDispatch {
from(value: IMSCEPSetup) -> Self24406     fn from(value: IMSCEPSetup) -> Self {
24407         unsafe { ::std::mem::transmute(value) }
24408     }
24409 }
24410 #[cfg(feature = "Win32_System_Ole_Automation")]
24411 impl ::std::convert::From<&IMSCEPSetup> for super::super::System::Ole::Automation::IDispatch {
from(value: &IMSCEPSetup) -> Self24412     fn from(value: &IMSCEPSetup) -> Self {
24413         ::std::convert::From::from(::std::clone::Clone::clone(value))
24414     }
24415 }
24416 #[cfg(feature = "Win32_System_Ole_Automation")]
24417 impl<'a> ::windows::runtime::IntoParam<'a, super::super::System::Ole::Automation::IDispatch> for IMSCEPSetup {
into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch>24418     fn into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch> {
24419         ::windows::runtime::Param::Owned(::std::convert::Into::<super::super::System::Ole::Automation::IDispatch>::into(self))
24420     }
24421 }
24422 #[cfg(feature = "Win32_System_Ole_Automation")]
24423 impl<'a> ::windows::runtime::IntoParam<'a, super::super::System::Ole::Automation::IDispatch> for &IMSCEPSetup {
into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch>24424     fn into_param(self) -> ::windows::runtime::Param<'a, super::super::System::Ole::Automation::IDispatch> {
24425         ::windows::runtime::Param::Owned(::std::convert::Into::<super::super::System::Ole::Automation::IDispatch>::into(::std::clone::Clone::clone(self)))
24426     }
24427 }
24428 #[repr(C)]
24429 #[doc(hidden)]
24430 pub struct IMSCEPSetup_abi(
24431     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
24432     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
24433     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
24434     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pctinfo: *mut u32) -> ::windows::runtime::HRESULT,
24435     #[cfg(feature = "Win32_System_Ole_Automation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
24436     #[cfg(not(feature = "Win32_System_Ole_Automation"))] usize,
24437     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::runtime::HRESULT,
24438     #[cfg(not(feature = "Win32_Foundation"))] usize,
24439     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))]
24440     pub  unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dispidmember: i32, riid: *const ::windows::runtime::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Ole::Automation::DISPPARAMS, pvarresult: *mut ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::std::mem::ManuallyDrop<super::super::System::Ole::Automation::EXCEPINFO>, puargerr: *mut u32) -> ::windows::runtime::HRESULT,
24441     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
24442     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pval: *mut i32) -> ::windows::runtime::HRESULT,
24443     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pval: *mut ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
24444     #[cfg(not(feature = "Win32_Foundation"))] usize,
24445     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
24446     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, propertyid: MSCEPSetupProperty, pval: *mut ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
24447     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
24448     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, propertyid: MSCEPSetupProperty, ppropertyvalue: *const ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
24449     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
24450     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bstrusername: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, bstrpassword: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
24451     #[cfg(not(feature = "Win32_Foundation"))] usize,
24452     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pbempty: *mut i16) -> ::windows::runtime::HRESULT,
24453     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bexchange: i16, pval: *mut ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
24454     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
24455     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bexchange: i16, bstrprovidername: ::std::mem::ManuallyDrop<super::super::Foundation::BSTR>, pval: *mut ::std::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::runtime::HRESULT,
24456     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole_Automation")))] usize,
24457     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
24458     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
24459     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
24460 );
24461 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
24462 #[repr(C)]
24463 #[cfg(feature = "Win32_Foundation")]
24464 pub struct INFORMATIONCARD_ASYMMETRIC_CRYPTO_PARAMETERS {
24465     pub keySize: i32,
24466     pub keyExchangeAlgorithm: super::super::Foundation::PWSTR,
24467     pub signatureAlgorithm: super::super::Foundation::PWSTR,
24468 }
24469 #[cfg(feature = "Win32_Foundation")]
24470 impl INFORMATIONCARD_ASYMMETRIC_CRYPTO_PARAMETERS {}
24471 #[cfg(feature = "Win32_Foundation")]
24472 impl ::std::default::Default for INFORMATIONCARD_ASYMMETRIC_CRYPTO_PARAMETERS {
default() -> Self24473     fn default() -> Self {
24474         unsafe { ::std::mem::zeroed() }
24475     }
24476 }
24477 #[cfg(feature = "Win32_Foundation")]
24478 impl ::std::fmt::Debug for INFORMATIONCARD_ASYMMETRIC_CRYPTO_PARAMETERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result24479     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
24480         fmt.debug_struct("INFORMATIONCARD_ASYMMETRIC_CRYPTO_PARAMETERS").field("keySize", &self.keySize).field("keyExchangeAlgorithm", &self.keyExchangeAlgorithm).field("signatureAlgorithm", &self.signatureAlgorithm).finish()
24481     }
24482 }
24483 #[cfg(feature = "Win32_Foundation")]
24484 impl ::std::cmp::PartialEq for INFORMATIONCARD_ASYMMETRIC_CRYPTO_PARAMETERS {
eq(&self, other: &Self) -> bool24485     fn eq(&self, other: &Self) -> bool {
24486         self.keySize == other.keySize && self.keyExchangeAlgorithm == other.keyExchangeAlgorithm && self.signatureAlgorithm == other.signatureAlgorithm
24487     }
24488 }
24489 #[cfg(feature = "Win32_Foundation")]
24490 impl ::std::cmp::Eq for INFORMATIONCARD_ASYMMETRIC_CRYPTO_PARAMETERS {}
24491 #[cfg(feature = "Win32_Foundation")]
24492 unsafe impl ::windows::runtime::Abi for INFORMATIONCARD_ASYMMETRIC_CRYPTO_PARAMETERS {
24493     type Abi = Self;
24494     type DefaultType = Self;
24495 }
24496 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
24497 #[repr(C)]
24498 pub struct INFORMATIONCARD_CRYPTO_HANDLE {
24499     pub r#type: HandleType,
24500     pub expiration: i64,
24501     pub cryptoParameters: *mut ::std::ffi::c_void,
24502 }
24503 impl INFORMATIONCARD_CRYPTO_HANDLE {}
24504 impl ::std::default::Default for INFORMATIONCARD_CRYPTO_HANDLE {
default() -> Self24505     fn default() -> Self {
24506         unsafe { ::std::mem::zeroed() }
24507     }
24508 }
24509 impl ::std::fmt::Debug for INFORMATIONCARD_CRYPTO_HANDLE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result24510     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
24511         fmt.debug_struct("INFORMATIONCARD_CRYPTO_HANDLE").field("r#type", &self.r#type).field("expiration", &self.expiration).field("cryptoParameters", &self.cryptoParameters).finish()
24512     }
24513 }
24514 impl ::std::cmp::PartialEq for INFORMATIONCARD_CRYPTO_HANDLE {
eq(&self, other: &Self) -> bool24515     fn eq(&self, other: &Self) -> bool {
24516         self.r#type == other.r#type && self.expiration == other.expiration && self.cryptoParameters == other.cryptoParameters
24517     }
24518 }
24519 impl ::std::cmp::Eq for INFORMATIONCARD_CRYPTO_HANDLE {}
24520 unsafe impl ::windows::runtime::Abi for INFORMATIONCARD_CRYPTO_HANDLE {
24521     type Abi = Self;
24522     type DefaultType = Self;
24523 }
24524 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
24525 #[repr(C)]
24526 #[cfg(feature = "Win32_Foundation")]
24527 pub struct INFORMATIONCARD_HASH_CRYPTO_PARAMETERS {
24528     pub hashSize: i32,
24529     pub transform: INFORMATIONCARD_TRANSFORM_CRYPTO_PARAMETERS,
24530 }
24531 #[cfg(feature = "Win32_Foundation")]
24532 impl INFORMATIONCARD_HASH_CRYPTO_PARAMETERS {}
24533 #[cfg(feature = "Win32_Foundation")]
24534 impl ::std::default::Default for INFORMATIONCARD_HASH_CRYPTO_PARAMETERS {
default() -> Self24535     fn default() -> Self {
24536         unsafe { ::std::mem::zeroed() }
24537     }
24538 }
24539 #[cfg(feature = "Win32_Foundation")]
24540 impl ::std::fmt::Debug for INFORMATIONCARD_HASH_CRYPTO_PARAMETERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result24541     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
24542         fmt.debug_struct("INFORMATIONCARD_HASH_CRYPTO_PARAMETERS").field("hashSize", &self.hashSize).field("transform", &self.transform).finish()
24543     }
24544 }
24545 #[cfg(feature = "Win32_Foundation")]
24546 impl ::std::cmp::PartialEq for INFORMATIONCARD_HASH_CRYPTO_PARAMETERS {
eq(&self, other: &Self) -> bool24547     fn eq(&self, other: &Self) -> bool {
24548         self.hashSize == other.hashSize && self.transform == other.transform
24549     }
24550 }
24551 #[cfg(feature = "Win32_Foundation")]
24552 impl ::std::cmp::Eq for INFORMATIONCARD_HASH_CRYPTO_PARAMETERS {}
24553 #[cfg(feature = "Win32_Foundation")]
24554 unsafe impl ::windows::runtime::Abi for INFORMATIONCARD_HASH_CRYPTO_PARAMETERS {
24555     type Abi = Self;
24556     type DefaultType = Self;
24557 }
24558 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
24559 #[repr(C)]
24560 pub struct INFORMATIONCARD_SYMMETRIC_CRYPTO_PARAMETERS {
24561     pub keySize: i32,
24562     pub blockSize: i32,
24563     pub feedbackSize: i32,
24564 }
24565 impl INFORMATIONCARD_SYMMETRIC_CRYPTO_PARAMETERS {}
24566 impl ::std::default::Default for INFORMATIONCARD_SYMMETRIC_CRYPTO_PARAMETERS {
default() -> Self24567     fn default() -> Self {
24568         unsafe { ::std::mem::zeroed() }
24569     }
24570 }
24571 impl ::std::fmt::Debug for INFORMATIONCARD_SYMMETRIC_CRYPTO_PARAMETERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result24572     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
24573         fmt.debug_struct("INFORMATIONCARD_SYMMETRIC_CRYPTO_PARAMETERS").field("keySize", &self.keySize).field("blockSize", &self.blockSize).field("feedbackSize", &self.feedbackSize).finish()
24574     }
24575 }
24576 impl ::std::cmp::PartialEq for INFORMATIONCARD_SYMMETRIC_CRYPTO_PARAMETERS {
eq(&self, other: &Self) -> bool24577     fn eq(&self, other: &Self) -> bool {
24578         self.keySize == other.keySize && self.blockSize == other.blockSize && self.feedbackSize == other.feedbackSize
24579     }
24580 }
24581 impl ::std::cmp::Eq for INFORMATIONCARD_SYMMETRIC_CRYPTO_PARAMETERS {}
24582 unsafe impl ::windows::runtime::Abi for INFORMATIONCARD_SYMMETRIC_CRYPTO_PARAMETERS {
24583     type Abi = Self;
24584     type DefaultType = Self;
24585 }
24586 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
24587 #[repr(C)]
24588 #[cfg(feature = "Win32_Foundation")]
24589 pub struct INFORMATIONCARD_TRANSFORM_CRYPTO_PARAMETERS {
24590     pub inputBlockSize: i32,
24591     pub outputBlockSize: i32,
24592     pub canTransformMultipleBlocks: super::super::Foundation::BOOL,
24593     pub canReuseTransform: super::super::Foundation::BOOL,
24594 }
24595 #[cfg(feature = "Win32_Foundation")]
24596 impl INFORMATIONCARD_TRANSFORM_CRYPTO_PARAMETERS {}
24597 #[cfg(feature = "Win32_Foundation")]
24598 impl ::std::default::Default for INFORMATIONCARD_TRANSFORM_CRYPTO_PARAMETERS {
default() -> Self24599     fn default() -> Self {
24600         unsafe { ::std::mem::zeroed() }
24601     }
24602 }
24603 #[cfg(feature = "Win32_Foundation")]
24604 impl ::std::fmt::Debug for INFORMATIONCARD_TRANSFORM_CRYPTO_PARAMETERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result24605     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
24606         fmt.debug_struct("INFORMATIONCARD_TRANSFORM_CRYPTO_PARAMETERS").field("inputBlockSize", &self.inputBlockSize).field("outputBlockSize", &self.outputBlockSize).field("canTransformMultipleBlocks", &self.canTransformMultipleBlocks).field("canReuseTransform", &self.canReuseTransform).finish()
24607     }
24608 }
24609 #[cfg(feature = "Win32_Foundation")]
24610 impl ::std::cmp::PartialEq for INFORMATIONCARD_TRANSFORM_CRYPTO_PARAMETERS {
eq(&self, other: &Self) -> bool24611     fn eq(&self, other: &Self) -> bool {
24612         self.inputBlockSize == other.inputBlockSize && self.outputBlockSize == other.outputBlockSize && self.canTransformMultipleBlocks == other.canTransformMultipleBlocks && self.canReuseTransform == other.canReuseTransform
24613     }
24614 }
24615 #[cfg(feature = "Win32_Foundation")]
24616 impl ::std::cmp::Eq for INFORMATIONCARD_TRANSFORM_CRYPTO_PARAMETERS {}
24617 #[cfg(feature = "Win32_Foundation")]
24618 unsafe impl ::windows::runtime::Abi for INFORMATIONCARD_TRANSFORM_CRYPTO_PARAMETERS {
24619     type Abi = Self;
24620     type DefaultType = Self;
24621 }
24622 pub const INTERNATIONAL_USAGE: u32 = 1u32;
24623 #[cfg(feature = "Win32_Foundation")]
24624 #[inline]
ImportInformationCard<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(filename: Param0) -> ::windows::runtime::Result<()>24625 pub unsafe fn ImportInformationCard<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(filename: Param0) -> ::windows::runtime::Result<()> {
24626     #[cfg(windows)]
24627     {
24628         #[link(name = "windows")]
24629         extern "system" {
24630             fn ImportInformationCard(filename: super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT;
24631         }
24632         ImportInformationCard(filename.into_param().abi()).ok()
24633     }
24634     #[cfg(not(windows))]
24635     unimplemented!("Unsupported target OS");
24636 }
24637 pub const KDF_ALGORITHMID: u32 = 8u32;
24638 pub const KDF_CONTEXT: u32 = 14u32;
24639 pub const KDF_GENERIC_PARAMETER: u32 = 17u32;
24640 pub const KDF_HASH_ALGORITHM: u32 = 0u32;
24641 pub const KDF_HKDF_INFO: u32 = 20u32;
24642 pub const KDF_HKDF_SALT: u32 = 19u32;
24643 pub const KDF_HMAC_KEY: u32 = 3u32;
24644 pub const KDF_ITERATION_COUNT: u32 = 16u32;
24645 pub const KDF_KEYBITLENGTH: u32 = 18u32;
24646 pub const KDF_LABEL: u32 = 13u32;
24647 pub const KDF_PARTYUINFO: u32 = 9u32;
24648 pub const KDF_PARTYVINFO: u32 = 10u32;
24649 pub const KDF_SALT: u32 = 15u32;
24650 pub const KDF_SECRET_APPEND: u32 = 2u32;
24651 pub const KDF_SECRET_HANDLE: u32 = 6u32;
24652 pub const KDF_SECRET_PREPEND: u32 = 1u32;
24653 pub const KDF_SUPPPRIVINFO: u32 = 12u32;
24654 pub const KDF_SUPPPUBINFO: u32 = 11u32;
24655 pub const KDF_TLS_PRF_LABEL: u32 = 4u32;
24656 pub const KDF_TLS_PRF_PROTOCOL: u32 = 7u32;
24657 pub const KDF_TLS_PRF_SEED: u32 = 5u32;
24658 pub const KDF_USE_SECRET_AS_HMAC_KEY_FLAG: u32 = 1u32;
24659 pub const KEYSTATEBLOB: u32 = 12u32;
24660 pub const KEY_LENGTH_MASK: u32 = 4294901760u32;
24661 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
24662 #[repr(C)]
24663 pub struct KEY_TYPE_SUBTYPE {
24664     pub dwKeySpec: u32,
24665     pub Type: ::windows::runtime::GUID,
24666     pub Subtype: ::windows::runtime::GUID,
24667 }
24668 impl KEY_TYPE_SUBTYPE {}
24669 impl ::std::default::Default for KEY_TYPE_SUBTYPE {
default() -> Self24670     fn default() -> Self {
24671         unsafe { ::std::mem::zeroed() }
24672     }
24673 }
24674 impl ::std::fmt::Debug for KEY_TYPE_SUBTYPE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result24675     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
24676         fmt.debug_struct("KEY_TYPE_SUBTYPE").field("dwKeySpec", &self.dwKeySpec).field("Type", &self.Type).field("Subtype", &self.Subtype).finish()
24677     }
24678 }
24679 impl ::std::cmp::PartialEq for KEY_TYPE_SUBTYPE {
eq(&self, other: &Self) -> bool24680     fn eq(&self, other: &Self) -> bool {
24681         self.dwKeySpec == other.dwKeySpec && self.Type == other.Type && self.Subtype == other.Subtype
24682     }
24683 }
24684 impl ::std::cmp::Eq for KEY_TYPE_SUBTYPE {}
24685 unsafe impl ::windows::runtime::Abi for KEY_TYPE_SUBTYPE {
24686     type Abi = Self;
24687     type DefaultType = Self;
24688 }
24689 pub const KP_ADMIN_PIN: u32 = 31u32;
24690 pub const KP_CLEAR_KEY: u32 = 27u32;
24691 pub const KP_CLIENT_RANDOM: u32 = 21u32;
24692 pub const KP_CMS_DH_KEY_INFO: u32 = 38u32;
24693 pub const KP_CMS_KEY_INFO: u32 = 37u32;
24694 pub const KP_EFFECTIVE_KEYLEN: u32 = 19u32;
24695 pub const KP_G: u32 = 12u32;
24696 pub const KP_HIGHEST_VERSION: u32 = 41u32;
24697 pub const KP_INFO: u32 = 18u32;
24698 pub const KP_IV: u32 = 1u32;
24699 pub const KP_KEYEXCHANGE_PIN: u32 = 32u32;
24700 pub const KP_KEYVAL: u32 = 30u32;
24701 pub const KP_MODE: u32 = 4u32;
24702 pub const KP_MODE_BITS: u32 = 5u32;
24703 pub const KP_OAEP_PARAMS: u32 = 36u32;
24704 pub const KP_P: u32 = 11u32;
24705 pub const KP_PADDING: u32 = 3u32;
24706 pub const KP_PIN_ID: u32 = 43u32;
24707 pub const KP_PIN_INFO: u32 = 44u32;
24708 pub const KP_PRECOMP_MD5: u32 = 24u32;
24709 pub const KP_PRECOMP_SHA: u32 = 25u32;
24710 pub const KP_PREHASH: u32 = 34u32;
24711 pub const KP_PUB_EX_LEN: u32 = 28u32;
24712 pub const KP_PUB_EX_VAL: u32 = 29u32;
24713 pub const KP_PUB_PARAMS: u32 = 39u32;
24714 pub const KP_Q: u32 = 13u32;
24715 pub const KP_RA: u32 = 16u32;
24716 pub const KP_RB: u32 = 17u32;
24717 pub const KP_ROUNDS: u32 = 35u32;
24718 pub const KP_RP: u32 = 23u32;
24719 pub const KP_SCHANNEL_ALG: u32 = 20u32;
24720 pub const KP_SERVER_RANDOM: u32 = 22u32;
24721 pub const KP_SIGNATURE_PIN: u32 = 33u32;
24722 pub const KP_VERIFY_PARAMS: u32 = 40u32;
24723 pub const KP_X: u32 = 14u32;
24724 pub const KP_Y: u32 = 15u32;
24725 pub const MAXUIDLEN: u32 = 64u32;
24726 pub const MICROSOFT_ROOT_CERT_CHAIN_POLICY_CHECK_APPLICATION_ROOT_FLAG: u32 = 131072u32;
24727 pub const MICROSOFT_ROOT_CERT_CHAIN_POLICY_DISABLE_FLIGHT_ROOT_FLAG: u32 = 262144u32;
24728 pub const MICROSOFT_ROOT_CERT_CHAIN_POLICY_ENABLE_TEST_ROOT_FLAG: u32 = 65536u32;
24729 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
24730 #[repr(transparent)]
24731 pub struct MSCEPSetupProperty(pub i32);
24732 pub const ENUM_CEPSETUPPROP_USELOCALSYSTEM: MSCEPSetupProperty = MSCEPSetupProperty(0i32);
24733 pub const ENUM_CEPSETUPPROP_USECHALLENGE: MSCEPSetupProperty = MSCEPSetupProperty(1i32);
24734 pub const ENUM_CEPSETUPPROP_RANAME_CN: MSCEPSetupProperty = MSCEPSetupProperty(2i32);
24735 pub const ENUM_CEPSETUPPROP_RANAME_EMAIL: MSCEPSetupProperty = MSCEPSetupProperty(3i32);
24736 pub const ENUM_CEPSETUPPROP_RANAME_COMPANY: MSCEPSetupProperty = MSCEPSetupProperty(4i32);
24737 pub const ENUM_CEPSETUPPROP_RANAME_DEPT: MSCEPSetupProperty = MSCEPSetupProperty(5i32);
24738 pub const ENUM_CEPSETUPPROP_RANAME_CITY: MSCEPSetupProperty = MSCEPSetupProperty(6i32);
24739 pub const ENUM_CEPSETUPPROP_RANAME_STATE: MSCEPSetupProperty = MSCEPSetupProperty(7i32);
24740 pub const ENUM_CEPSETUPPROP_RANAME_COUNTRY: MSCEPSetupProperty = MSCEPSetupProperty(8i32);
24741 pub const ENUM_CEPSETUPPROP_SIGNINGKEYINFORMATION: MSCEPSetupProperty = MSCEPSetupProperty(9i32);
24742 pub const ENUM_CEPSETUPPROP_EXCHANGEKEYINFORMATION: MSCEPSetupProperty = MSCEPSetupProperty(10i32);
24743 pub const ENUM_CEPSETUPPROP_CAINFORMATION: MSCEPSetupProperty = MSCEPSetupProperty(11i32);
24744 pub const ENUM_CEPSETUPPROP_MSCEPURL: MSCEPSetupProperty = MSCEPSetupProperty(12i32);
24745 pub const ENUM_CEPSETUPPROP_CHALLENGEURL: MSCEPSetupProperty = MSCEPSetupProperty(13i32);
24746 impl ::std::convert::From<i32> for MSCEPSetupProperty {
from(value: i32) -> Self24747     fn from(value: i32) -> Self {
24748         Self(value)
24749     }
24750 }
24751 unsafe impl ::windows::runtime::Abi for MSCEPSetupProperty {
24752     type Abi = Self;
24753     type DefaultType = Self;
24754 }
24755 #[inline]
ManageCardSpace() -> ::windows::runtime::Result<()>24756 pub unsafe fn ManageCardSpace() -> ::windows::runtime::Result<()> {
24757     #[cfg(windows)]
24758     {
24759         #[link(name = "windows")]
24760         extern "system" {
24761             fn ManageCardSpace() -> ::windows::runtime::HRESULT;
24762         }
24763         ManageCardSpace().ok()
24764     }
24765     #[cfg(not(windows))]
24766     unimplemented!("Unsupported target OS");
24767 }
24768 pub const NCRYPTBUFFER_ATTESTATIONSTATEMENT_BLOB: u32 = 51u32;
24769 pub const NCRYPTBUFFER_ATTESTATION_CLAIM_CHALLENGE_REQUIRED: u32 = 53u32;
24770 pub const NCRYPTBUFFER_ATTESTATION_CLAIM_TYPE: u32 = 52u32;
24771 pub const NCRYPTBUFFER_CERT_BLOB: u32 = 47u32;
24772 pub const NCRYPTBUFFER_CLAIM_IDBINDING_NONCE: u32 = 48u32;
24773 pub const NCRYPTBUFFER_CLAIM_KEYATTESTATION_NONCE: u32 = 49u32;
24774 pub const NCRYPTBUFFER_DATA: u32 = 1u32;
24775 pub const NCRYPTBUFFER_ECC_CURVE_NAME: u32 = 60u32;
24776 pub const NCRYPTBUFFER_ECC_PARAMETERS: u32 = 61u32;
24777 pub const NCRYPTBUFFER_EMPTY: u32 = 0u32;
24778 pub const NCRYPTBUFFER_KEY_PROPERTY_FLAGS: u32 = 50u32;
24779 pub const NCRYPTBUFFER_PKCS_ALG_ID: u32 = 43u32;
24780 pub const NCRYPTBUFFER_PKCS_ALG_OID: u32 = 41u32;
24781 pub const NCRYPTBUFFER_PKCS_ALG_PARAM: u32 = 42u32;
24782 pub const NCRYPTBUFFER_PKCS_ATTRS: u32 = 44u32;
24783 pub const NCRYPTBUFFER_PKCS_KEY_NAME: u32 = 45u32;
24784 pub const NCRYPTBUFFER_PKCS_OID: u32 = 40u32;
24785 pub const NCRYPTBUFFER_PKCS_SECRET: u32 = 46u32;
24786 pub const NCRYPTBUFFER_PROTECTION_DESCRIPTOR_STRING: u32 = 3u32;
24787 pub const NCRYPTBUFFER_PROTECTION_FLAGS: u32 = 4u32;
24788 pub const NCRYPTBUFFER_SSL_CLEAR_KEY: u32 = 23u32;
24789 pub const NCRYPTBUFFER_SSL_CLIENT_RANDOM: u32 = 20u32;
24790 pub const NCRYPTBUFFER_SSL_HIGHEST_VERSION: u32 = 22u32;
24791 pub const NCRYPTBUFFER_SSL_KEY_ARG_DATA: u32 = 24u32;
24792 pub const NCRYPTBUFFER_SSL_SERVER_RANDOM: u32 = 21u32;
24793 pub const NCRYPTBUFFER_SSL_SESSION_HASH: u32 = 25u32;
24794 pub const NCRYPTBUFFER_TPM_PLATFORM_CLAIM_NONCE: u32 = 81u32;
24795 pub const NCRYPTBUFFER_TPM_PLATFORM_CLAIM_PCR_MASK: u32 = 80u32;
24796 pub const NCRYPTBUFFER_TPM_PLATFORM_CLAIM_STATIC_CREATE: u32 = 82u32;
24797 pub const NCRYPTBUFFER_TPM_SEAL_NO_DA_PROTECTION: u32 = 73u32;
24798 pub const NCRYPTBUFFER_TPM_SEAL_PASSWORD: u32 = 70u32;
24799 pub const NCRYPTBUFFER_TPM_SEAL_POLICYINFO: u32 = 71u32;
24800 pub const NCRYPTBUFFER_TPM_SEAL_TICKET: u32 = 72u32;
24801 pub const NCRYPTBUFFER_VERSION: u32 = 0u32;
24802 pub const NCRYPTBUFFER_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS: u32 = 54u32;
24803 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
24804 #[repr(transparent)]
24805 pub struct NCRYPT_ALGORITHM_NAME_CLASS(pub u32);
24806 pub const NCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE: NCRYPT_ALGORITHM_NAME_CLASS = NCRYPT_ALGORITHM_NAME_CLASS(3u32);
24807 pub const NCRYPT_SECRET_AGREEMENT_INTERFACE: NCRYPT_ALGORITHM_NAME_CLASS = NCRYPT_ALGORITHM_NAME_CLASS(4u32);
24808 pub const NCRYPT_SIGNATURE_INTERFACE: NCRYPT_ALGORITHM_NAME_CLASS = NCRYPT_ALGORITHM_NAME_CLASS(5u32);
24809 impl ::std::convert::From<u32> for NCRYPT_ALGORITHM_NAME_CLASS {
from(value: u32) -> Self24810     fn from(value: u32) -> Self {
24811         Self(value)
24812     }
24813 }
24814 unsafe impl ::windows::runtime::Abi for NCRYPT_ALGORITHM_NAME_CLASS {
24815     type Abi = Self;
24816     type DefaultType = Self;
24817 }
24818 impl ::std::ops::BitOr for NCRYPT_ALGORITHM_NAME_CLASS {
24819     type Output = Self;
bitor(self, rhs: Self) -> Self24820     fn bitor(self, rhs: Self) -> Self {
24821         Self(self.0 | rhs.0)
24822     }
24823 }
24824 impl ::std::ops::BitAnd for NCRYPT_ALGORITHM_NAME_CLASS {
24825     type Output = Self;
bitand(self, rhs: Self) -> Self24826     fn bitand(self, rhs: Self) -> Self {
24827         Self(self.0 & rhs.0)
24828     }
24829 }
24830 impl ::std::ops::BitOrAssign for NCRYPT_ALGORITHM_NAME_CLASS {
bitor_assign(&mut self, rhs: Self)24831     fn bitor_assign(&mut self, rhs: Self) {
24832         self.0.bitor_assign(rhs.0)
24833     }
24834 }
24835 impl ::std::ops::BitAndAssign for NCRYPT_ALGORITHM_NAME_CLASS {
bitand_assign(&mut self, rhs: Self)24836     fn bitand_assign(&mut self, rhs: Self) {
24837         self.0.bitand_assign(rhs.0)
24838     }
24839 }
24840 impl ::std::ops::Not for NCRYPT_ALGORITHM_NAME_CLASS {
24841     type Output = Self;
not(self) -> Self24842     fn not(self) -> Self {
24843         Self(self.0.not())
24844     }
24845 }
24846 #[derive(:: std :: clone :: Clone)]
24847 #[repr(C)]
24848 pub struct NCRYPT_ALLOC_PARA {
24849     pub cbSize: u32,
24850     pub pfnAlloc: ::std::option::Option<PFN_NCRYPT_ALLOC>,
24851     pub pfnFree: ::std::option::Option<PFN_NCRYPT_FREE>,
24852 }
24853 impl NCRYPT_ALLOC_PARA {}
24854 impl ::std::default::Default for NCRYPT_ALLOC_PARA {
default() -> Self24855     fn default() -> Self {
24856         unsafe { ::std::mem::zeroed() }
24857     }
24858 }
24859 impl ::std::fmt::Debug for NCRYPT_ALLOC_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result24860     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
24861         fmt.debug_struct("NCRYPT_ALLOC_PARA").field("cbSize", &self.cbSize).finish()
24862     }
24863 }
24864 impl ::std::cmp::PartialEq for NCRYPT_ALLOC_PARA {
eq(&self, other: &Self) -> bool24865     fn eq(&self, other: &Self) -> bool {
24866         self.cbSize == other.cbSize && self.pfnAlloc.map(|f| f as usize) == other.pfnAlloc.map(|f| f as usize) && self.pfnFree.map(|f| f as usize) == other.pfnFree.map(|f| f as usize)
24867     }
24868 }
24869 impl ::std::cmp::Eq for NCRYPT_ALLOC_PARA {}
24870 unsafe impl ::windows::runtime::Abi for NCRYPT_ALLOC_PARA {
24871     type Abi = ::std::mem::ManuallyDrop<Self>;
24872     type DefaultType = Self;
24873 }
24874 pub const NCRYPT_ALLOW_ALL_USAGES: u32 = 16777215u32;
24875 pub const NCRYPT_ALLOW_ARCHIVING_FLAG: u32 = 4u32;
24876 pub const NCRYPT_ALLOW_DECRYPT_FLAG: u32 = 1u32;
24877 pub const NCRYPT_ALLOW_EXPORT_FLAG: u32 = 1u32;
24878 pub const NCRYPT_ALLOW_KEY_AGREEMENT_FLAG: u32 = 4u32;
24879 pub const NCRYPT_ALLOW_KEY_IMPORT_FLAG: u32 = 8u32;
24880 pub const NCRYPT_ALLOW_PLAINTEXT_ARCHIVING_FLAG: u32 = 8u32;
24881 pub const NCRYPT_ALLOW_PLAINTEXT_EXPORT_FLAG: u32 = 2u32;
24882 pub const NCRYPT_ALLOW_SIGNING_FLAG: u32 = 2u32;
24883 pub const NCRYPT_ALLOW_SILENT_KEY_ACCESS: u32 = 1u32;
24884 pub const NCRYPT_ATTESTATION_FLAG: u32 = 32u32;
24885 pub const NCRYPT_AUTHORITY_KEY_FLAG: u32 = 256u32;
24886 pub const NCRYPT_CIPHER_BLOCK_PADDING_FLAG: u32 = 1u32;
24887 pub const NCRYPT_CIPHER_KEY_BLOB_MAGIC: u32 = 1380470851u32;
24888 pub const NCRYPT_CIPHER_NO_PADDING_FLAG: u32 = 0u32;
24889 pub const NCRYPT_CIPHER_OTHER_PADDING_FLAG: u32 = 2u32;
24890 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
24891 #[repr(C)]
24892 pub struct NCRYPT_CIPHER_PADDING_INFO {
24893     pub cbSize: u32,
24894     pub dwFlags: u32,
24895     pub pbIV: *mut u8,
24896     pub cbIV: u32,
24897     pub pbOtherInfo: *mut u8,
24898     pub cbOtherInfo: u32,
24899 }
24900 impl NCRYPT_CIPHER_PADDING_INFO {}
24901 impl ::std::default::Default for NCRYPT_CIPHER_PADDING_INFO {
default() -> Self24902     fn default() -> Self {
24903         unsafe { ::std::mem::zeroed() }
24904     }
24905 }
24906 impl ::std::fmt::Debug for NCRYPT_CIPHER_PADDING_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result24907     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
24908         fmt.debug_struct("NCRYPT_CIPHER_PADDING_INFO").field("cbSize", &self.cbSize).field("dwFlags", &self.dwFlags).field("pbIV", &self.pbIV).field("cbIV", &self.cbIV).field("pbOtherInfo", &self.pbOtherInfo).field("cbOtherInfo", &self.cbOtherInfo).finish()
24909     }
24910 }
24911 impl ::std::cmp::PartialEq for NCRYPT_CIPHER_PADDING_INFO {
eq(&self, other: &Self) -> bool24912     fn eq(&self, other: &Self) -> bool {
24913         self.cbSize == other.cbSize && self.dwFlags == other.dwFlags && self.pbIV == other.pbIV && self.cbIV == other.cbIV && self.pbOtherInfo == other.pbOtherInfo && self.cbOtherInfo == other.cbOtherInfo
24914     }
24915 }
24916 impl ::std::cmp::Eq for NCRYPT_CIPHER_PADDING_INFO {}
24917 unsafe impl ::windows::runtime::Abi for NCRYPT_CIPHER_PADDING_INFO {
24918     type Abi = Self;
24919     type DefaultType = Self;
24920 }
24921 pub const NCRYPT_CLAIM_AUTHORITY_AND_SUBJECT: u32 = 3u32;
24922 pub const NCRYPT_CLAIM_AUTHORITY_ONLY: u32 = 1u32;
24923 pub const NCRYPT_CLAIM_PLATFORM: u32 = 65536u32;
24924 pub const NCRYPT_CLAIM_SUBJECT_ONLY: u32 = 2u32;
24925 pub const NCRYPT_CLAIM_UNKNOWN: u32 = 4096u32;
24926 pub const NCRYPT_CLAIM_VSM_KEY_ATTESTATION_STATEMENT: u32 = 4u32;
24927 pub const NCRYPT_CLAIM_WEB_AUTH_SUBJECT_ONLY: u32 = 258u32;
24928 pub const NCRYPT_DO_NOT_FINALIZE_FLAG: u32 = 1024u32;
24929 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
24930 #[repr(C)]
24931 pub struct NCRYPT_EXPORTED_ISOLATED_KEY_ENVELOPE {
24932     pub Header: NCRYPT_EXPORTED_ISOLATED_KEY_HEADER,
24933 }
24934 impl NCRYPT_EXPORTED_ISOLATED_KEY_ENVELOPE {}
24935 impl ::std::default::Default for NCRYPT_EXPORTED_ISOLATED_KEY_ENVELOPE {
default() -> Self24936     fn default() -> Self {
24937         unsafe { ::std::mem::zeroed() }
24938     }
24939 }
24940 impl ::std::fmt::Debug for NCRYPT_EXPORTED_ISOLATED_KEY_ENVELOPE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result24941     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
24942         fmt.debug_struct("NCRYPT_EXPORTED_ISOLATED_KEY_ENVELOPE").field("Header", &self.Header).finish()
24943     }
24944 }
24945 impl ::std::cmp::PartialEq for NCRYPT_EXPORTED_ISOLATED_KEY_ENVELOPE {
eq(&self, other: &Self) -> bool24946     fn eq(&self, other: &Self) -> bool {
24947         self.Header == other.Header
24948     }
24949 }
24950 impl ::std::cmp::Eq for NCRYPT_EXPORTED_ISOLATED_KEY_ENVELOPE {}
24951 unsafe impl ::windows::runtime::Abi for NCRYPT_EXPORTED_ISOLATED_KEY_ENVELOPE {
24952     type Abi = Self;
24953     type DefaultType = Self;
24954 }
24955 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
24956 #[repr(C)]
24957 pub struct NCRYPT_EXPORTED_ISOLATED_KEY_HEADER {
24958     pub Version: u32,
24959     pub KeyUsage: u32,
24960     pub _bitfield: u32,
24961     pub cbAlgName: u32,
24962     pub cbNonce: u32,
24963     pub cbAuthTag: u32,
24964     pub cbWrappingKey: u32,
24965     pub cbIsolatedKey: u32,
24966 }
24967 impl NCRYPT_EXPORTED_ISOLATED_KEY_HEADER {}
24968 impl ::std::default::Default for NCRYPT_EXPORTED_ISOLATED_KEY_HEADER {
default() -> Self24969     fn default() -> Self {
24970         unsafe { ::std::mem::zeroed() }
24971     }
24972 }
24973 impl ::std::fmt::Debug for NCRYPT_EXPORTED_ISOLATED_KEY_HEADER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result24974     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
24975         fmt.debug_struct("NCRYPT_EXPORTED_ISOLATED_KEY_HEADER")
24976             .field("Version", &self.Version)
24977             .field("KeyUsage", &self.KeyUsage)
24978             .field("_bitfield", &self._bitfield)
24979             .field("cbAlgName", &self.cbAlgName)
24980             .field("cbNonce", &self.cbNonce)
24981             .field("cbAuthTag", &self.cbAuthTag)
24982             .field("cbWrappingKey", &self.cbWrappingKey)
24983             .field("cbIsolatedKey", &self.cbIsolatedKey)
24984             .finish()
24985     }
24986 }
24987 impl ::std::cmp::PartialEq for NCRYPT_EXPORTED_ISOLATED_KEY_HEADER {
eq(&self, other: &Self) -> bool24988     fn eq(&self, other: &Self) -> bool {
24989         self.Version == other.Version && self.KeyUsage == other.KeyUsage && self._bitfield == other._bitfield && self.cbAlgName == other.cbAlgName && self.cbNonce == other.cbNonce && self.cbAuthTag == other.cbAuthTag && self.cbWrappingKey == other.cbWrappingKey && self.cbIsolatedKey == other.cbIsolatedKey
24990     }
24991 }
24992 impl ::std::cmp::Eq for NCRYPT_EXPORTED_ISOLATED_KEY_HEADER {}
24993 unsafe impl ::windows::runtime::Abi for NCRYPT_EXPORTED_ISOLATED_KEY_HEADER {
24994     type Abi = Self;
24995     type DefaultType = Self;
24996 }
24997 pub const NCRYPT_EXPORTED_ISOLATED_KEY_HEADER_CURRENT_VERSION: u32 = 0u32;
24998 pub const NCRYPT_EXPORTED_ISOLATED_KEY_HEADER_V0: u32 = 0u32;
24999 pub const NCRYPT_EXPORT_LEGACY_FLAG: u32 = 2048u32;
25000 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
25001 #[repr(transparent)]
25002 pub struct NCRYPT_FLAGS(pub u32);
25003 pub const BCRYPT_PAD_NONE: NCRYPT_FLAGS = NCRYPT_FLAGS(1u32);
25004 pub const BCRYPT_PAD_OAEP: NCRYPT_FLAGS = NCRYPT_FLAGS(4u32);
25005 pub const BCRYPT_PAD_PKCS1: NCRYPT_FLAGS = NCRYPT_FLAGS(2u32);
25006 pub const BCRYPT_PAD_PSS: NCRYPT_FLAGS = NCRYPT_FLAGS(8u32);
25007 pub const NCRYPT_SILENT_FLAG: NCRYPT_FLAGS = NCRYPT_FLAGS(64u32);
25008 pub const NCRYPT_NO_PADDING_FLAG: NCRYPT_FLAGS = NCRYPT_FLAGS(1u32);
25009 pub const NCRYPT_PAD_OAEP_FLAG: NCRYPT_FLAGS = NCRYPT_FLAGS(4u32);
25010 pub const NCRYPT_PAD_PKCS1_FLAG: NCRYPT_FLAGS = NCRYPT_FLAGS(2u32);
25011 pub const NCRYPT_REGISTER_NOTIFY_FLAG: NCRYPT_FLAGS = NCRYPT_FLAGS(1u32);
25012 pub const NCRYPT_UNREGISTER_NOTIFY_FLAG: NCRYPT_FLAGS = NCRYPT_FLAGS(2u32);
25013 pub const NCRYPT_MACHINE_KEY_FLAG: NCRYPT_FLAGS = NCRYPT_FLAGS(32u32);
25014 pub const NCRYPT_UNPROTECT_NO_DECRYPT: NCRYPT_FLAGS = NCRYPT_FLAGS(1u32);
25015 pub const NCRYPT_OVERWRITE_KEY_FLAG: NCRYPT_FLAGS = NCRYPT_FLAGS(128u32);
25016 pub const NCRYPT_NO_KEY_VALIDATION: NCRYPT_FLAGS = NCRYPT_FLAGS(8u32);
25017 pub const NCRYPT_WRITE_KEY_TO_LEGACY_STORE_FLAG: NCRYPT_FLAGS = NCRYPT_FLAGS(512u32);
25018 pub const NCRYPT_PAD_PSS_FLAG: NCRYPT_FLAGS = NCRYPT_FLAGS(8u32);
25019 pub const NCRYPT_PERSIST_FLAG: NCRYPT_FLAGS = NCRYPT_FLAGS(2147483648u32);
25020 pub const NCRYPT_PERSIST_ONLY_FLAG: NCRYPT_FLAGS = NCRYPT_FLAGS(1073741824u32);
25021 impl ::std::convert::From<u32> for NCRYPT_FLAGS {
from(value: u32) -> Self25022     fn from(value: u32) -> Self {
25023         Self(value)
25024     }
25025 }
25026 unsafe impl ::windows::runtime::Abi for NCRYPT_FLAGS {
25027     type Abi = Self;
25028     type DefaultType = Self;
25029 }
25030 impl ::std::ops::BitOr for NCRYPT_FLAGS {
25031     type Output = Self;
bitor(self, rhs: Self) -> Self25032     fn bitor(self, rhs: Self) -> Self {
25033         Self(self.0 | rhs.0)
25034     }
25035 }
25036 impl ::std::ops::BitAnd for NCRYPT_FLAGS {
25037     type Output = Self;
bitand(self, rhs: Self) -> Self25038     fn bitand(self, rhs: Self) -> Self {
25039         Self(self.0 & rhs.0)
25040     }
25041 }
25042 impl ::std::ops::BitOrAssign for NCRYPT_FLAGS {
bitor_assign(&mut self, rhs: Self)25043     fn bitor_assign(&mut self, rhs: Self) {
25044         self.0.bitor_assign(rhs.0)
25045     }
25046 }
25047 impl ::std::ops::BitAndAssign for NCRYPT_FLAGS {
bitand_assign(&mut self, rhs: Self)25048     fn bitand_assign(&mut self, rhs: Self) {
25049         self.0.bitand_assign(rhs.0)
25050     }
25051 }
25052 impl ::std::ops::Not for NCRYPT_FLAGS {
25053     type Output = Self;
not(self) -> Self25054     fn not(self) -> Self {
25055         Self(self.0.not())
25056     }
25057 }
25058 pub const NCRYPT_IGNORE_DEVICE_STATE_FLAG: u32 = 4096u32;
25059 pub const NCRYPT_IMPL_HARDWARE_FLAG: u32 = 1u32;
25060 pub const NCRYPT_IMPL_HARDWARE_RNG_FLAG: u32 = 16u32;
25061 pub const NCRYPT_IMPL_REMOVABLE_FLAG: u32 = 8u32;
25062 pub const NCRYPT_IMPL_SOFTWARE_FLAG: u32 = 2u32;
25063 pub const NCRYPT_IMPL_VIRTUAL_ISOLATION_FLAG: u32 = 32u32;
25064 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
25065 #[repr(C)]
25066 pub struct NCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES {
25067     pub Version: u32,
25068     pub Flags: u32,
25069     pub cbPublicKeyBlob: u32,
25070 }
25071 impl NCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES {}
25072 impl ::std::default::Default for NCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES {
default() -> Self25073     fn default() -> Self {
25074         unsafe { ::std::mem::zeroed() }
25075     }
25076 }
25077 impl ::std::fmt::Debug for NCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result25078     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
25079         fmt.debug_struct("NCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES").field("Version", &self.Version).field("Flags", &self.Flags).field("cbPublicKeyBlob", &self.cbPublicKeyBlob).finish()
25080     }
25081 }
25082 impl ::std::cmp::PartialEq for NCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES {
eq(&self, other: &Self) -> bool25083     fn eq(&self, other: &Self) -> bool {
25084         self.Version == other.Version && self.Flags == other.Flags && self.cbPublicKeyBlob == other.cbPublicKeyBlob
25085     }
25086 }
25087 impl ::std::cmp::Eq for NCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES {}
25088 unsafe impl ::windows::runtime::Abi for NCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES {
25089     type Abi = Self;
25090     type DefaultType = Self;
25091 }
25092 pub const NCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES_CURRENT_VERSION: u32 = 0u32;
25093 pub const NCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES_V0: u32 = 0u32;
25094 pub const NCRYPT_ISOLATED_KEY_FLAG_CREATED_IN_ISOLATION: u32 = 1u32;
25095 pub const NCRYPT_ISOLATED_KEY_FLAG_IMPORT_ONLY: u32 = 2u32;
25096 pub const NCRYPT_KDF_KEY_BLOB_MAGIC: u32 = 826688587u32;
25097 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
25098 #[repr(C)]
25099 pub struct NCRYPT_KEY_ACCESS_POLICY_BLOB {
25100     pub dwVersion: u32,
25101     pub dwPolicyFlags: u32,
25102     pub cbUserSid: u32,
25103     pub cbApplicationSid: u32,
25104 }
25105 impl NCRYPT_KEY_ACCESS_POLICY_BLOB {}
25106 impl ::std::default::Default for NCRYPT_KEY_ACCESS_POLICY_BLOB {
default() -> Self25107     fn default() -> Self {
25108         unsafe { ::std::mem::zeroed() }
25109     }
25110 }
25111 impl ::std::fmt::Debug for NCRYPT_KEY_ACCESS_POLICY_BLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result25112     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
25113         fmt.debug_struct("NCRYPT_KEY_ACCESS_POLICY_BLOB").field("dwVersion", &self.dwVersion).field("dwPolicyFlags", &self.dwPolicyFlags).field("cbUserSid", &self.cbUserSid).field("cbApplicationSid", &self.cbApplicationSid).finish()
25114     }
25115 }
25116 impl ::std::cmp::PartialEq for NCRYPT_KEY_ACCESS_POLICY_BLOB {
eq(&self, other: &Self) -> bool25117     fn eq(&self, other: &Self) -> bool {
25118         self.dwVersion == other.dwVersion && self.dwPolicyFlags == other.dwPolicyFlags && self.cbUserSid == other.cbUserSid && self.cbApplicationSid == other.cbApplicationSid
25119     }
25120 }
25121 impl ::std::cmp::Eq for NCRYPT_KEY_ACCESS_POLICY_BLOB {}
25122 unsafe impl ::windows::runtime::Abi for NCRYPT_KEY_ACCESS_POLICY_BLOB {
25123     type Abi = Self;
25124     type DefaultType = Self;
25125 }
25126 pub const NCRYPT_KEY_ACCESS_POLICY_VERSION: u32 = 1u32;
25127 pub const NCRYPT_KEY_ATTEST_MAGIC: u32 = 1146110283u32;
25128 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
25129 #[repr(C)]
25130 pub struct NCRYPT_KEY_ATTEST_PADDING_INFO {
25131     pub magic: u32,
25132     pub pbKeyBlob: *mut u8,
25133     pub cbKeyBlob: u32,
25134     pub pbKeyAuth: *mut u8,
25135     pub cbKeyAuth: u32,
25136 }
25137 impl NCRYPT_KEY_ATTEST_PADDING_INFO {}
25138 impl ::std::default::Default for NCRYPT_KEY_ATTEST_PADDING_INFO {
default() -> Self25139     fn default() -> Self {
25140         unsafe { ::std::mem::zeroed() }
25141     }
25142 }
25143 impl ::std::fmt::Debug for NCRYPT_KEY_ATTEST_PADDING_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result25144     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
25145         fmt.debug_struct("NCRYPT_KEY_ATTEST_PADDING_INFO").field("magic", &self.magic).field("pbKeyBlob", &self.pbKeyBlob).field("cbKeyBlob", &self.cbKeyBlob).field("pbKeyAuth", &self.pbKeyAuth).field("cbKeyAuth", &self.cbKeyAuth).finish()
25146     }
25147 }
25148 impl ::std::cmp::PartialEq for NCRYPT_KEY_ATTEST_PADDING_INFO {
eq(&self, other: &Self) -> bool25149     fn eq(&self, other: &Self) -> bool {
25150         self.magic == other.magic && self.pbKeyBlob == other.pbKeyBlob && self.cbKeyBlob == other.cbKeyBlob && self.pbKeyAuth == other.pbKeyAuth && self.cbKeyAuth == other.cbKeyAuth
25151     }
25152 }
25153 impl ::std::cmp::Eq for NCRYPT_KEY_ATTEST_PADDING_INFO {}
25154 unsafe impl ::windows::runtime::Abi for NCRYPT_KEY_ATTEST_PADDING_INFO {
25155     type Abi = Self;
25156     type DefaultType = Self;
25157 }
25158 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
25159 #[repr(C)]
25160 pub struct NCRYPT_KEY_BLOB_HEADER {
25161     pub cbSize: u32,
25162     pub dwMagic: u32,
25163     pub cbAlgName: u32,
25164     pub cbKeyData: u32,
25165 }
25166 impl NCRYPT_KEY_BLOB_HEADER {}
25167 impl ::std::default::Default for NCRYPT_KEY_BLOB_HEADER {
default() -> Self25168     fn default() -> Self {
25169         unsafe { ::std::mem::zeroed() }
25170     }
25171 }
25172 impl ::std::fmt::Debug for NCRYPT_KEY_BLOB_HEADER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result25173     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
25174         fmt.debug_struct("NCRYPT_KEY_BLOB_HEADER").field("cbSize", &self.cbSize).field("dwMagic", &self.dwMagic).field("cbAlgName", &self.cbAlgName).field("cbKeyData", &self.cbKeyData).finish()
25175     }
25176 }
25177 impl ::std::cmp::PartialEq for NCRYPT_KEY_BLOB_HEADER {
eq(&self, other: &Self) -> bool25178     fn eq(&self, other: &Self) -> bool {
25179         self.cbSize == other.cbSize && self.dwMagic == other.dwMagic && self.cbAlgName == other.cbAlgName && self.cbKeyData == other.cbKeyData
25180     }
25181 }
25182 impl ::std::cmp::Eq for NCRYPT_KEY_BLOB_HEADER {}
25183 unsafe impl ::windows::runtime::Abi for NCRYPT_KEY_BLOB_HEADER {
25184     type Abi = Self;
25185     type DefaultType = Self;
25186 }
25187 pub const NCRYPT_KEY_DERIVATION_INTERFACE: u32 = 7u32;
25188 pub const NCRYPT_KEY_DERIVATION_OPERATION: u32 = 64u32;
25189 pub const NCRYPT_KEY_PROTECTION_INTERFACE: u32 = 65540u32;
25190 pub const NCRYPT_MAX_ALG_ID_LENGTH: u32 = 512u32;
25191 pub const NCRYPT_MAX_KEY_NAME_LENGTH: u32 = 512u32;
25192 pub const NCRYPT_MAX_PROPERTY_DATA: u32 = 1048576u32;
25193 pub const NCRYPT_MAX_PROPERTY_NAME: u32 = 64u32;
25194 pub const NCRYPT_NAMED_DESCRIPTOR_FLAG: u32 = 1u32;
25195 pub const NCRYPT_NO_CACHED_PASSWORD: u32 = 16384u32;
25196 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
25197 #[repr(transparent)]
25198 pub struct NCRYPT_OPERATION(pub u32);
25199 pub const NCRYPT_CIPHER_OPERATION: NCRYPT_OPERATION = NCRYPT_OPERATION(1u32);
25200 pub const NCRYPT_HASH_OPERATION: NCRYPT_OPERATION = NCRYPT_OPERATION(2u32);
25201 pub const NCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION: NCRYPT_OPERATION = NCRYPT_OPERATION(4u32);
25202 pub const NCRYPT_SECRET_AGREEMENT_OPERATION: NCRYPT_OPERATION = NCRYPT_OPERATION(8u32);
25203 pub const NCRYPT_SIGNATURE_OPERATION: NCRYPT_OPERATION = NCRYPT_OPERATION(16u32);
25204 impl ::std::convert::From<u32> for NCRYPT_OPERATION {
from(value: u32) -> Self25205     fn from(value: u32) -> Self {
25206         Self(value)
25207     }
25208 }
25209 unsafe impl ::windows::runtime::Abi for NCRYPT_OPERATION {
25210     type Abi = Self;
25211     type DefaultType = Self;
25212 }
25213 impl ::std::ops::BitOr for NCRYPT_OPERATION {
25214     type Output = Self;
bitor(self, rhs: Self) -> Self25215     fn bitor(self, rhs: Self) -> Self {
25216         Self(self.0 | rhs.0)
25217     }
25218 }
25219 impl ::std::ops::BitAnd for NCRYPT_OPERATION {
25220     type Output = Self;
bitand(self, rhs: Self) -> Self25221     fn bitand(self, rhs: Self) -> Self {
25222         Self(self.0 & rhs.0)
25223     }
25224 }
25225 impl ::std::ops::BitOrAssign for NCRYPT_OPERATION {
bitor_assign(&mut self, rhs: Self)25226     fn bitor_assign(&mut self, rhs: Self) {
25227         self.0.bitor_assign(rhs.0)
25228     }
25229 }
25230 impl ::std::ops::BitAndAssign for NCRYPT_OPERATION {
bitand_assign(&mut self, rhs: Self)25231     fn bitand_assign(&mut self, rhs: Self) {
25232         self.0.bitand_assign(rhs.0)
25233     }
25234 }
25235 impl ::std::ops::Not for NCRYPT_OPERATION {
25236     type Output = Self;
not(self) -> Self25237     fn not(self) -> Self {
25238         Self(self.0.not())
25239     }
25240 }
25241 pub const NCRYPT_PAD_CIPHER_FLAG: u32 = 16u32;
25242 pub const NCRYPT_PCP_ENCRYPTION_KEY: u32 = 2u32;
25243 pub const NCRYPT_PCP_HMACVERIFICATION_KEY: u32 = 16u32;
25244 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
25245 #[repr(C)]
25246 pub struct NCRYPT_PCP_HMAC_AUTH_SIGNATURE_INFO {
25247     pub dwVersion: u32,
25248     pub iExpiration: i32,
25249     pub pabNonce: [u8; 32],
25250     pub pabPolicyRef: [u8; 32],
25251     pub pabHMAC: [u8; 32],
25252 }
25253 impl NCRYPT_PCP_HMAC_AUTH_SIGNATURE_INFO {}
25254 impl ::std::default::Default for NCRYPT_PCP_HMAC_AUTH_SIGNATURE_INFO {
default() -> Self25255     fn default() -> Self {
25256         unsafe { ::std::mem::zeroed() }
25257     }
25258 }
25259 impl ::std::fmt::Debug for NCRYPT_PCP_HMAC_AUTH_SIGNATURE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result25260     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
25261         fmt.debug_struct("NCRYPT_PCP_HMAC_AUTH_SIGNATURE_INFO").field("dwVersion", &self.dwVersion).field("iExpiration", &self.iExpiration).field("pabNonce", &self.pabNonce).field("pabPolicyRef", &self.pabPolicyRef).field("pabHMAC", &self.pabHMAC).finish()
25262     }
25263 }
25264 impl ::std::cmp::PartialEq for NCRYPT_PCP_HMAC_AUTH_SIGNATURE_INFO {
eq(&self, other: &Self) -> bool25265     fn eq(&self, other: &Self) -> bool {
25266         self.dwVersion == other.dwVersion && self.iExpiration == other.iExpiration && self.pabNonce == other.pabNonce && self.pabPolicyRef == other.pabPolicyRef && self.pabHMAC == other.pabHMAC
25267     }
25268 }
25269 impl ::std::cmp::Eq for NCRYPT_PCP_HMAC_AUTH_SIGNATURE_INFO {}
25270 unsafe impl ::windows::runtime::Abi for NCRYPT_PCP_HMAC_AUTH_SIGNATURE_INFO {
25271     type Abi = Self;
25272     type DefaultType = Self;
25273 }
25274 pub const NCRYPT_PCP_IDENTITY_KEY: u32 = 8u32;
25275 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
25276 #[repr(C)]
25277 pub struct NCRYPT_PCP_RAW_POLICYDIGEST {
25278     pub dwVersion: u32,
25279     pub cbDigest: u32,
25280 }
25281 impl NCRYPT_PCP_RAW_POLICYDIGEST {}
25282 impl ::std::default::Default for NCRYPT_PCP_RAW_POLICYDIGEST {
default() -> Self25283     fn default() -> Self {
25284         unsafe { ::std::mem::zeroed() }
25285     }
25286 }
25287 impl ::std::fmt::Debug for NCRYPT_PCP_RAW_POLICYDIGEST {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result25288     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
25289         fmt.debug_struct("NCRYPT_PCP_RAW_POLICYDIGEST").field("dwVersion", &self.dwVersion).field("cbDigest", &self.cbDigest).finish()
25290     }
25291 }
25292 impl ::std::cmp::PartialEq for NCRYPT_PCP_RAW_POLICYDIGEST {
eq(&self, other: &Self) -> bool25293     fn eq(&self, other: &Self) -> bool {
25294         self.dwVersion == other.dwVersion && self.cbDigest == other.cbDigest
25295     }
25296 }
25297 impl ::std::cmp::Eq for NCRYPT_PCP_RAW_POLICYDIGEST {}
25298 unsafe impl ::windows::runtime::Abi for NCRYPT_PCP_RAW_POLICYDIGEST {
25299     type Abi = Self;
25300     type DefaultType = Self;
25301 }
25302 pub const NCRYPT_PCP_SIGNATURE_KEY: u32 = 1u32;
25303 pub const NCRYPT_PCP_STORAGE_KEY: u32 = 4u32;
25304 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
25305 #[repr(C)]
25306 pub struct NCRYPT_PCP_TPM_FW_VERSION_INFO {
25307     pub major1: u16,
25308     pub major2: u16,
25309     pub minor1: u16,
25310     pub minor2: u16,
25311 }
25312 impl NCRYPT_PCP_TPM_FW_VERSION_INFO {}
25313 impl ::std::default::Default for NCRYPT_PCP_TPM_FW_VERSION_INFO {
default() -> Self25314     fn default() -> Self {
25315         unsafe { ::std::mem::zeroed() }
25316     }
25317 }
25318 impl ::std::fmt::Debug for NCRYPT_PCP_TPM_FW_VERSION_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result25319     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
25320         fmt.debug_struct("NCRYPT_PCP_TPM_FW_VERSION_INFO").field("major1", &self.major1).field("major2", &self.major2).field("minor1", &self.minor1).field("minor2", &self.minor2).finish()
25321     }
25322 }
25323 impl ::std::cmp::PartialEq for NCRYPT_PCP_TPM_FW_VERSION_INFO {
eq(&self, other: &Self) -> bool25324     fn eq(&self, other: &Self) -> bool {
25325         self.major1 == other.major1 && self.major2 == other.major2 && self.minor1 == other.minor1 && self.minor2 == other.minor2
25326     }
25327 }
25328 impl ::std::cmp::Eq for NCRYPT_PCP_TPM_FW_VERSION_INFO {}
25329 unsafe impl ::windows::runtime::Abi for NCRYPT_PCP_TPM_FW_VERSION_INFO {
25330     type Abi = Self;
25331     type DefaultType = Self;
25332 }
25333 pub const NCRYPT_PIN_CACHE_APPLICATION_TICKET_BYTE_LENGTH: u32 = 90u32;
25334 pub const NCRYPT_PIN_CACHE_CLEAR_FOR_CALLING_PROCESS_OPTION: u32 = 1u32;
25335 pub const NCRYPT_PIN_CACHE_DISABLE_DPL_FLAG: u32 = 1u32;
25336 pub const NCRYPT_PIN_CACHE_REQUIRE_GESTURE_FLAG: u32 = 1u32;
25337 pub const NCRYPT_PLATFORM_ATTEST_MAGIC: u32 = 1146110288u32;
25338 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
25339 #[repr(C)]
25340 pub struct NCRYPT_PLATFORM_ATTEST_PADDING_INFO {
25341     pub magic: u32,
25342     pub pcrMask: u32,
25343 }
25344 impl NCRYPT_PLATFORM_ATTEST_PADDING_INFO {}
25345 impl ::std::default::Default for NCRYPT_PLATFORM_ATTEST_PADDING_INFO {
default() -> Self25346     fn default() -> Self {
25347         unsafe { ::std::mem::zeroed() }
25348     }
25349 }
25350 impl ::std::fmt::Debug for NCRYPT_PLATFORM_ATTEST_PADDING_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result25351     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
25352         fmt.debug_struct("NCRYPT_PLATFORM_ATTEST_PADDING_INFO").field("magic", &self.magic).field("pcrMask", &self.pcrMask).finish()
25353     }
25354 }
25355 impl ::std::cmp::PartialEq for NCRYPT_PLATFORM_ATTEST_PADDING_INFO {
eq(&self, other: &Self) -> bool25356     fn eq(&self, other: &Self) -> bool {
25357         self.magic == other.magic && self.pcrMask == other.pcrMask
25358     }
25359 }
25360 impl ::std::cmp::Eq for NCRYPT_PLATFORM_ATTEST_PADDING_INFO {}
25361 unsafe impl ::windows::runtime::Abi for NCRYPT_PLATFORM_ATTEST_PADDING_INFO {
25362     type Abi = Self;
25363     type DefaultType = Self;
25364 }
25365 pub const NCRYPT_PREFER_VIRTUAL_ISOLATION_FLAG: u32 = 65536u32;
25366 pub const NCRYPT_PROTECTED_KEY_BLOB_MAGIC: u32 = 1263817296u32;
25367 pub const NCRYPT_PROTECTION_INFO_TYPE_DESCRIPTOR_STRING: u32 = 1u32;
25368 #[derive(:: std :: clone :: Clone)]
25369 #[repr(C)]
25370 #[cfg(feature = "Win32_Foundation")]
25371 pub struct NCRYPT_PROTECT_STREAM_INFO {
25372     pub pfnStreamOutput: ::std::option::Option<PFNCryptStreamOutputCallback>,
25373     pub pvCallbackCtxt: *mut ::std::ffi::c_void,
25374 }
25375 #[cfg(feature = "Win32_Foundation")]
25376 impl NCRYPT_PROTECT_STREAM_INFO {}
25377 #[cfg(feature = "Win32_Foundation")]
25378 impl ::std::default::Default for NCRYPT_PROTECT_STREAM_INFO {
default() -> Self25379     fn default() -> Self {
25380         unsafe { ::std::mem::zeroed() }
25381     }
25382 }
25383 #[cfg(feature = "Win32_Foundation")]
25384 impl ::std::fmt::Debug for NCRYPT_PROTECT_STREAM_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result25385     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
25386         fmt.debug_struct("NCRYPT_PROTECT_STREAM_INFO").field("pvCallbackCtxt", &self.pvCallbackCtxt).finish()
25387     }
25388 }
25389 #[cfg(feature = "Win32_Foundation")]
25390 impl ::std::cmp::PartialEq for NCRYPT_PROTECT_STREAM_INFO {
eq(&self, other: &Self) -> bool25391     fn eq(&self, other: &Self) -> bool {
25392         self.pfnStreamOutput.map(|f| f as usize) == other.pfnStreamOutput.map(|f| f as usize) && self.pvCallbackCtxt == other.pvCallbackCtxt
25393     }
25394 }
25395 #[cfg(feature = "Win32_Foundation")]
25396 impl ::std::cmp::Eq for NCRYPT_PROTECT_STREAM_INFO {}
25397 #[cfg(feature = "Win32_Foundation")]
25398 unsafe impl ::windows::runtime::Abi for NCRYPT_PROTECT_STREAM_INFO {
25399     type Abi = ::std::mem::ManuallyDrop<Self>;
25400     type DefaultType = Self;
25401 }
25402 #[derive(:: std :: clone :: Clone)]
25403 #[repr(C)]
25404 #[cfg(feature = "Win32_Foundation")]
25405 pub struct NCRYPT_PROTECT_STREAM_INFO_EX {
25406     pub pfnStreamOutput: ::std::option::Option<PFNCryptStreamOutputCallbackEx>,
25407     pub pvCallbackCtxt: *mut ::std::ffi::c_void,
25408 }
25409 #[cfg(feature = "Win32_Foundation")]
25410 impl NCRYPT_PROTECT_STREAM_INFO_EX {}
25411 #[cfg(feature = "Win32_Foundation")]
25412 impl ::std::default::Default for NCRYPT_PROTECT_STREAM_INFO_EX {
default() -> Self25413     fn default() -> Self {
25414         unsafe { ::std::mem::zeroed() }
25415     }
25416 }
25417 #[cfg(feature = "Win32_Foundation")]
25418 impl ::std::fmt::Debug for NCRYPT_PROTECT_STREAM_INFO_EX {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result25419     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
25420         fmt.debug_struct("NCRYPT_PROTECT_STREAM_INFO_EX").field("pvCallbackCtxt", &self.pvCallbackCtxt).finish()
25421     }
25422 }
25423 #[cfg(feature = "Win32_Foundation")]
25424 impl ::std::cmp::PartialEq for NCRYPT_PROTECT_STREAM_INFO_EX {
eq(&self, other: &Self) -> bool25425     fn eq(&self, other: &Self) -> bool {
25426         self.pfnStreamOutput.map(|f| f as usize) == other.pfnStreamOutput.map(|f| f as usize) && self.pvCallbackCtxt == other.pvCallbackCtxt
25427     }
25428 }
25429 #[cfg(feature = "Win32_Foundation")]
25430 impl ::std::cmp::Eq for NCRYPT_PROTECT_STREAM_INFO_EX {}
25431 #[cfg(feature = "Win32_Foundation")]
25432 unsafe impl ::windows::runtime::Abi for NCRYPT_PROTECT_STREAM_INFO_EX {
25433     type Abi = ::std::mem::ManuallyDrop<Self>;
25434     type DefaultType = Self;
25435 }
25436 pub const NCRYPT_PROTECT_TO_LOCAL_SYSTEM: u32 = 32768u32;
25437 pub const NCRYPT_SEALING_FLAG: u32 = 256u32;
25438 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
25439 #[repr(C)]
25440 pub struct NCRYPT_SUPPORTED_LENGTHS {
25441     pub dwMinLength: u32,
25442     pub dwMaxLength: u32,
25443     pub dwIncrement: u32,
25444     pub dwDefaultLength: u32,
25445 }
25446 impl NCRYPT_SUPPORTED_LENGTHS {}
25447 impl ::std::default::Default for NCRYPT_SUPPORTED_LENGTHS {
default() -> Self25448     fn default() -> Self {
25449         unsafe { ::std::mem::zeroed() }
25450     }
25451 }
25452 impl ::std::fmt::Debug for NCRYPT_SUPPORTED_LENGTHS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result25453     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
25454         fmt.debug_struct("NCRYPT_SUPPORTED_LENGTHS").field("dwMinLength", &self.dwMinLength).field("dwMaxLength", &self.dwMaxLength).field("dwIncrement", &self.dwIncrement).field("dwDefaultLength", &self.dwDefaultLength).finish()
25455     }
25456 }
25457 impl ::std::cmp::PartialEq for NCRYPT_SUPPORTED_LENGTHS {
eq(&self, other: &Self) -> bool25458     fn eq(&self, other: &Self) -> bool {
25459         self.dwMinLength == other.dwMinLength && self.dwMaxLength == other.dwMaxLength && self.dwIncrement == other.dwIncrement && self.dwDefaultLength == other.dwDefaultLength
25460     }
25461 }
25462 impl ::std::cmp::Eq for NCRYPT_SUPPORTED_LENGTHS {}
25463 unsafe impl ::windows::runtime::Abi for NCRYPT_SUPPORTED_LENGTHS {
25464     type Abi = Self;
25465     type DefaultType = Self;
25466 }
25467 pub const NCRYPT_TPM12_PROVIDER: u32 = 65536u32;
25468 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
25469 #[repr(C)]
25470 pub struct NCRYPT_TPM_LOADABLE_KEY_BLOB_HEADER {
25471     pub magic: u32,
25472     pub cbHeader: u32,
25473     pub cbPublic: u32,
25474     pub cbPrivate: u32,
25475     pub cbName: u32,
25476 }
25477 impl NCRYPT_TPM_LOADABLE_KEY_BLOB_HEADER {}
25478 impl ::std::default::Default for NCRYPT_TPM_LOADABLE_KEY_BLOB_HEADER {
default() -> Self25479     fn default() -> Self {
25480         unsafe { ::std::mem::zeroed() }
25481     }
25482 }
25483 impl ::std::fmt::Debug for NCRYPT_TPM_LOADABLE_KEY_BLOB_HEADER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result25484     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
25485         fmt.debug_struct("NCRYPT_TPM_LOADABLE_KEY_BLOB_HEADER").field("magic", &self.magic).field("cbHeader", &self.cbHeader).field("cbPublic", &self.cbPublic).field("cbPrivate", &self.cbPrivate).field("cbName", &self.cbName).finish()
25486     }
25487 }
25488 impl ::std::cmp::PartialEq for NCRYPT_TPM_LOADABLE_KEY_BLOB_HEADER {
eq(&self, other: &Self) -> bool25489     fn eq(&self, other: &Self) -> bool {
25490         self.magic == other.magic && self.cbHeader == other.cbHeader && self.cbPublic == other.cbPublic && self.cbPrivate == other.cbPrivate && self.cbName == other.cbName
25491     }
25492 }
25493 impl ::std::cmp::Eq for NCRYPT_TPM_LOADABLE_KEY_BLOB_HEADER {}
25494 unsafe impl ::windows::runtime::Abi for NCRYPT_TPM_LOADABLE_KEY_BLOB_HEADER {
25495     type Abi = Self;
25496     type DefaultType = Self;
25497 }
25498 pub const NCRYPT_TPM_LOADABLE_KEY_BLOB_MAGIC: u32 = 1297371211u32;
25499 pub const NCRYPT_TPM_PAD_PSS_IGNORE_SALT: u32 = 32u32;
25500 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
25501 #[repr(C)]
25502 pub struct NCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT {
25503     pub Magic: u32,
25504     pub Version: u32,
25505     pub pcrAlg: u32,
25506     pub cbSignature: u32,
25507     pub cbQuote: u32,
25508     pub cbPcrs: u32,
25509 }
25510 impl NCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT {}
25511 impl ::std::default::Default for NCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT {
default() -> Self25512     fn default() -> Self {
25513         unsafe { ::std::mem::zeroed() }
25514     }
25515 }
25516 impl ::std::fmt::Debug for NCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result25517     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
25518         fmt.debug_struct("NCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT").field("Magic", &self.Magic).field("Version", &self.Version).field("pcrAlg", &self.pcrAlg).field("cbSignature", &self.cbSignature).field("cbQuote", &self.cbQuote).field("cbPcrs", &self.cbPcrs).finish()
25519     }
25520 }
25521 impl ::std::cmp::PartialEq for NCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT {
eq(&self, other: &Self) -> bool25522     fn eq(&self, other: &Self) -> bool {
25523         self.Magic == other.Magic && self.Version == other.Version && self.pcrAlg == other.pcrAlg && self.cbSignature == other.cbSignature && self.cbQuote == other.cbQuote && self.cbPcrs == other.cbPcrs
25524     }
25525 }
25526 impl ::std::cmp::Eq for NCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT {}
25527 unsafe impl ::windows::runtime::Abi for NCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT {
25528     type Abi = Self;
25529     type DefaultType = Self;
25530 }
25531 pub const NCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT_CURRENT_VERSION: u32 = 0u32;
25532 pub const NCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT_V0: u32 = 0u32;
25533 pub const NCRYPT_TPM_PSS_SALT_SIZE_HASHSIZE: u32 = 2u32;
25534 pub const NCRYPT_TPM_PSS_SALT_SIZE_MAXIMUM: u32 = 1u32;
25535 pub const NCRYPT_TPM_PSS_SALT_SIZE_UNKNOWN: u32 = 0u32;
25536 pub const NCRYPT_TREAT_NIST_AS_GENERIC_ECC_FLAG: u32 = 8192u32;
25537 pub const NCRYPT_UI_APPCONTAINER_ACCESS_MEDIUM_FLAG: u32 = 8u32;
25538 pub const NCRYPT_UI_FINGERPRINT_PROTECTION_FLAG: u32 = 4u32;
25539 pub const NCRYPT_UI_FORCE_HIGH_PROTECTION_FLAG: u32 = 2u32;
25540 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
25541 #[repr(C)]
25542 #[cfg(feature = "Win32_Foundation")]
25543 pub struct NCRYPT_UI_POLICY {
25544     pub dwVersion: u32,
25545     pub dwFlags: u32,
25546     pub pszCreationTitle: super::super::Foundation::PWSTR,
25547     pub pszFriendlyName: super::super::Foundation::PWSTR,
25548     pub pszDescription: super::super::Foundation::PWSTR,
25549 }
25550 #[cfg(feature = "Win32_Foundation")]
25551 impl NCRYPT_UI_POLICY {}
25552 #[cfg(feature = "Win32_Foundation")]
25553 impl ::std::default::Default for NCRYPT_UI_POLICY {
default() -> Self25554     fn default() -> Self {
25555         unsafe { ::std::mem::zeroed() }
25556     }
25557 }
25558 #[cfg(feature = "Win32_Foundation")]
25559 impl ::std::fmt::Debug for NCRYPT_UI_POLICY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result25560     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
25561         fmt.debug_struct("NCRYPT_UI_POLICY").field("dwVersion", &self.dwVersion).field("dwFlags", &self.dwFlags).field("pszCreationTitle", &self.pszCreationTitle).field("pszFriendlyName", &self.pszFriendlyName).field("pszDescription", &self.pszDescription).finish()
25562     }
25563 }
25564 #[cfg(feature = "Win32_Foundation")]
25565 impl ::std::cmp::PartialEq for NCRYPT_UI_POLICY {
eq(&self, other: &Self) -> bool25566     fn eq(&self, other: &Self) -> bool {
25567         self.dwVersion == other.dwVersion && self.dwFlags == other.dwFlags && self.pszCreationTitle == other.pszCreationTitle && self.pszFriendlyName == other.pszFriendlyName && self.pszDescription == other.pszDescription
25568     }
25569 }
25570 #[cfg(feature = "Win32_Foundation")]
25571 impl ::std::cmp::Eq for NCRYPT_UI_POLICY {}
25572 #[cfg(feature = "Win32_Foundation")]
25573 unsafe impl ::windows::runtime::Abi for NCRYPT_UI_POLICY {
25574     type Abi = Self;
25575     type DefaultType = Self;
25576 }
25577 pub const NCRYPT_UI_PROTECT_KEY_FLAG: u32 = 1u32;
25578 pub const NCRYPT_USE_PER_BOOT_KEY_FLAG: u32 = 262144u32;
25579 pub const NCRYPT_USE_VIRTUAL_ISOLATION_FLAG: u32 = 131072u32;
25580 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
25581 #[repr(C)]
25582 pub struct NCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS {
25583     pub Version: u32,
25584     pub TrustletId: u64,
25585     pub MinSvn: u32,
25586     pub FlagsMask: u32,
25587     pub FlagsExpected: u32,
25588     pub _bitfield: u32,
25589 }
25590 impl NCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS {}
25591 impl ::std::default::Default for NCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS {
default() -> Self25592     fn default() -> Self {
25593         unsafe { ::std::mem::zeroed() }
25594     }
25595 }
25596 impl ::std::fmt::Debug for NCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result25597     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
25598         fmt.debug_struct("NCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS").field("Version", &self.Version).field("TrustletId", &self.TrustletId).field("MinSvn", &self.MinSvn).field("FlagsMask", &self.FlagsMask).field("FlagsExpected", &self.FlagsExpected).field("_bitfield", &self._bitfield).finish()
25599     }
25600 }
25601 impl ::std::cmp::PartialEq for NCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS {
eq(&self, other: &Self) -> bool25602     fn eq(&self, other: &Self) -> bool {
25603         self.Version == other.Version && self.TrustletId == other.TrustletId && self.MinSvn == other.MinSvn && self.FlagsMask == other.FlagsMask && self.FlagsExpected == other.FlagsExpected && self._bitfield == other._bitfield
25604     }
25605 }
25606 impl ::std::cmp::Eq for NCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS {}
25607 unsafe impl ::windows::runtime::Abi for NCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS {
25608     type Abi = Self;
25609     type DefaultType = Self;
25610 }
25611 pub const NCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS_CURRENT_VERSION: u32 = 0u32;
25612 pub const NCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS_V0: u32 = 0u32;
25613 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
25614 #[repr(C)]
25615 pub struct NCRYPT_VSM_KEY_ATTESTATION_STATEMENT {
25616     pub Magic: u32,
25617     pub Version: u32,
25618     pub cbSignature: u32,
25619     pub cbReport: u32,
25620     pub cbAttributes: u32,
25621 }
25622 impl NCRYPT_VSM_KEY_ATTESTATION_STATEMENT {}
25623 impl ::std::default::Default for NCRYPT_VSM_KEY_ATTESTATION_STATEMENT {
default() -> Self25624     fn default() -> Self {
25625         unsafe { ::std::mem::zeroed() }
25626     }
25627 }
25628 impl ::std::fmt::Debug for NCRYPT_VSM_KEY_ATTESTATION_STATEMENT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result25629     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
25630         fmt.debug_struct("NCRYPT_VSM_KEY_ATTESTATION_STATEMENT").field("Magic", &self.Magic).field("Version", &self.Version).field("cbSignature", &self.cbSignature).field("cbReport", &self.cbReport).field("cbAttributes", &self.cbAttributes).finish()
25631     }
25632 }
25633 impl ::std::cmp::PartialEq for NCRYPT_VSM_KEY_ATTESTATION_STATEMENT {
eq(&self, other: &Self) -> bool25634     fn eq(&self, other: &Self) -> bool {
25635         self.Magic == other.Magic && self.Version == other.Version && self.cbSignature == other.cbSignature && self.cbReport == other.cbReport && self.cbAttributes == other.cbAttributes
25636     }
25637 }
25638 impl ::std::cmp::Eq for NCRYPT_VSM_KEY_ATTESTATION_STATEMENT {}
25639 unsafe impl ::windows::runtime::Abi for NCRYPT_VSM_KEY_ATTESTATION_STATEMENT {
25640     type Abi = Self;
25641     type DefaultType = Self;
25642 }
25643 pub const NCRYPT_VSM_KEY_ATTESTATION_STATEMENT_CURRENT_VERSION: u32 = 0u32;
25644 pub const NCRYPT_VSM_KEY_ATTESTATION_STATEMENT_V0: u32 = 0u32;
25645 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
25646 #[repr(C)]
25647 #[cfg(feature = "Win32_Foundation")]
25648 pub struct NCryptAlgorithmName {
25649     pub pszName: super::super::Foundation::PWSTR,
25650     pub dwClass: NCRYPT_ALGORITHM_NAME_CLASS,
25651     pub dwAlgOperations: NCRYPT_OPERATION,
25652     pub dwFlags: u32,
25653 }
25654 #[cfg(feature = "Win32_Foundation")]
25655 impl NCryptAlgorithmName {}
25656 #[cfg(feature = "Win32_Foundation")]
25657 impl ::std::default::Default for NCryptAlgorithmName {
default() -> Self25658     fn default() -> Self {
25659         unsafe { ::std::mem::zeroed() }
25660     }
25661 }
25662 #[cfg(feature = "Win32_Foundation")]
25663 impl ::std::fmt::Debug for NCryptAlgorithmName {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result25664     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
25665         fmt.debug_struct("NCryptAlgorithmName").field("pszName", &self.pszName).field("dwClass", &self.dwClass).field("dwAlgOperations", &self.dwAlgOperations).field("dwFlags", &self.dwFlags).finish()
25666     }
25667 }
25668 #[cfg(feature = "Win32_Foundation")]
25669 impl ::std::cmp::PartialEq for NCryptAlgorithmName {
eq(&self, other: &Self) -> bool25670     fn eq(&self, other: &Self) -> bool {
25671         self.pszName == other.pszName && self.dwClass == other.dwClass && self.dwAlgOperations == other.dwAlgOperations && self.dwFlags == other.dwFlags
25672     }
25673 }
25674 #[cfg(feature = "Win32_Foundation")]
25675 impl ::std::cmp::Eq for NCryptAlgorithmName {}
25676 #[cfg(feature = "Win32_Foundation")]
25677 unsafe impl ::windows::runtime::Abi for NCryptAlgorithmName {
25678     type Abi = Self;
25679     type DefaultType = Self;
25680 }
25681 #[inline]
NCryptCloseProtectionDescriptor<'a, Param0: ::windows::runtime::IntoParam<'a, super::NCRYPT_DESCRIPTOR_HANDLE>>(hdescriptor: Param0) -> i3225682 pub unsafe fn NCryptCloseProtectionDescriptor<'a, Param0: ::windows::runtime::IntoParam<'a, super::NCRYPT_DESCRIPTOR_HANDLE>>(hdescriptor: Param0) -> i32 {
25683     #[cfg(windows)]
25684     {
25685         #[link(name = "windows")]
25686         extern "system" {
25687             fn NCryptCloseProtectionDescriptor(hdescriptor: super::NCRYPT_DESCRIPTOR_HANDLE) -> i32;
25688         }
25689         ::std::mem::transmute(NCryptCloseProtectionDescriptor(hdescriptor.into_param().abi()))
25690     }
25691     #[cfg(not(windows))]
25692     unimplemented!("Unsupported target OS");
25693 }
25694 #[inline]
NCryptCreateClaim(hsubjectkey: usize, hauthoritykey: usize, dwclaimtype: u32, pparameterlist: *const BCryptBufferDesc, pbclaimblob: *mut u8, cbclaimblob: u32, pcbresult: *mut u32, dwflags: u32) -> i3225695 pub unsafe fn NCryptCreateClaim(hsubjectkey: usize, hauthoritykey: usize, dwclaimtype: u32, pparameterlist: *const BCryptBufferDesc, pbclaimblob: *mut u8, cbclaimblob: u32, pcbresult: *mut u32, dwflags: u32) -> i32 {
25696     #[cfg(windows)]
25697     {
25698         #[link(name = "windows")]
25699         extern "system" {
25700             fn NCryptCreateClaim(hsubjectkey: usize, hauthoritykey: usize, dwclaimtype: u32, pparameterlist: *const BCryptBufferDesc, pbclaimblob: *mut u8, cbclaimblob: u32, pcbresult: *mut u32, dwflags: u32) -> i32;
25701         }
25702         ::std::mem::transmute(NCryptCreateClaim(
25703             ::std::mem::transmute(hsubjectkey),
25704             ::std::mem::transmute(hauthoritykey),
25705             ::std::mem::transmute(dwclaimtype),
25706             ::std::mem::transmute(pparameterlist),
25707             ::std::mem::transmute(pbclaimblob),
25708             ::std::mem::transmute(cbclaimblob),
25709             ::std::mem::transmute(pcbresult),
25710             ::std::mem::transmute(dwflags),
25711         ))
25712     }
25713     #[cfg(not(windows))]
25714     unimplemented!("Unsupported target OS");
25715 }
25716 #[cfg(feature = "Win32_Foundation")]
25717 #[inline]
NCryptCreatePersistedKey<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hprovider: usize, phkey: *mut usize, pszalgid: Param2, pszkeyname: Param3, dwlegacykeyspec: CERT_KEY_SPEC, dwflags: NCRYPT_FLAGS) -> i3225718 pub unsafe fn NCryptCreatePersistedKey<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hprovider: usize, phkey: *mut usize, pszalgid: Param2, pszkeyname: Param3, dwlegacykeyspec: CERT_KEY_SPEC, dwflags: NCRYPT_FLAGS) -> i32 {
25719     #[cfg(windows)]
25720     {
25721         #[link(name = "windows")]
25722         extern "system" {
25723             fn NCryptCreatePersistedKey(hprovider: usize, phkey: *mut usize, pszalgid: super::super::Foundation::PWSTR, pszkeyname: super::super::Foundation::PWSTR, dwlegacykeyspec: CERT_KEY_SPEC, dwflags: NCRYPT_FLAGS) -> i32;
25724         }
25725         ::std::mem::transmute(NCryptCreatePersistedKey(::std::mem::transmute(hprovider), ::std::mem::transmute(phkey), pszalgid.into_param().abi(), pszkeyname.into_param().abi(), ::std::mem::transmute(dwlegacykeyspec), ::std::mem::transmute(dwflags)))
25726     }
25727     #[cfg(not(windows))]
25728     unimplemented!("Unsupported target OS");
25729 }
25730 #[cfg(feature = "Win32_Foundation")]
25731 #[inline]
NCryptCreateProtectionDescriptor<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pwszdescriptorstring: Param0, dwflags: u32, phdescriptor: *mut super::NCRYPT_DESCRIPTOR_HANDLE) -> i3225732 pub unsafe fn NCryptCreateProtectionDescriptor<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pwszdescriptorstring: Param0, dwflags: u32, phdescriptor: *mut super::NCRYPT_DESCRIPTOR_HANDLE) -> i32 {
25733     #[cfg(windows)]
25734     {
25735         #[link(name = "windows")]
25736         extern "system" {
25737             fn NCryptCreateProtectionDescriptor(pwszdescriptorstring: super::super::Foundation::PWSTR, dwflags: u32, phdescriptor: *mut super::NCRYPT_DESCRIPTOR_HANDLE) -> i32;
25738         }
25739         ::std::mem::transmute(NCryptCreateProtectionDescriptor(pwszdescriptorstring.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(phdescriptor)))
25740     }
25741     #[cfg(not(windows))]
25742     unimplemented!("Unsupported target OS");
25743 }
25744 #[inline]
NCryptDecrypt(hkey: usize, pbinput: *const u8, cbinput: u32, ppaddinginfo: *const ::std::ffi::c_void, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> i3225745 pub unsafe fn NCryptDecrypt(hkey: usize, pbinput: *const u8, cbinput: u32, ppaddinginfo: *const ::std::ffi::c_void, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> i32 {
25746     #[cfg(windows)]
25747     {
25748         #[link(name = "windows")]
25749         extern "system" {
25750             fn NCryptDecrypt(hkey: usize, pbinput: *const u8, cbinput: u32, ppaddinginfo: *const ::std::ffi::c_void, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> i32;
25751         }
25752         ::std::mem::transmute(NCryptDecrypt(::std::mem::transmute(hkey), ::std::mem::transmute(pbinput), ::std::mem::transmute(cbinput), ::std::mem::transmute(ppaddinginfo), ::std::mem::transmute(pboutput), ::std::mem::transmute(cboutput), ::std::mem::transmute(pcbresult), ::std::mem::transmute(dwflags)))
25753     }
25754     #[cfg(not(windows))]
25755     unimplemented!("Unsupported target OS");
25756 }
25757 #[inline]
NCryptDeleteKey(hkey: usize, dwflags: u32) -> i3225758 pub unsafe fn NCryptDeleteKey(hkey: usize, dwflags: u32) -> i32 {
25759     #[cfg(windows)]
25760     {
25761         #[link(name = "windows")]
25762         extern "system" {
25763             fn NCryptDeleteKey(hkey: usize, dwflags: u32) -> i32;
25764         }
25765         ::std::mem::transmute(NCryptDeleteKey(::std::mem::transmute(hkey), ::std::mem::transmute(dwflags)))
25766     }
25767     #[cfg(not(windows))]
25768     unimplemented!("Unsupported target OS");
25769 }
25770 #[cfg(feature = "Win32_Foundation")]
25771 #[inline]
NCryptDeriveKey<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hsharedsecret: usize, pwszkdf: Param1, pparameterlist: *const BCryptBufferDesc, pbderivedkey: *mut u8, cbderivedkey: u32, pcbresult: *mut u32, dwflags: u32) -> i3225772 pub unsafe fn NCryptDeriveKey<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hsharedsecret: usize, pwszkdf: Param1, pparameterlist: *const BCryptBufferDesc, pbderivedkey: *mut u8, cbderivedkey: u32, pcbresult: *mut u32, dwflags: u32) -> i32 {
25773     #[cfg(windows)]
25774     {
25775         #[link(name = "windows")]
25776         extern "system" {
25777             fn NCryptDeriveKey(hsharedsecret: usize, pwszkdf: super::super::Foundation::PWSTR, pparameterlist: *const BCryptBufferDesc, pbderivedkey: *mut u8, cbderivedkey: u32, pcbresult: *mut u32, dwflags: u32) -> i32;
25778         }
25779         ::std::mem::transmute(NCryptDeriveKey(::std::mem::transmute(hsharedsecret), pwszkdf.into_param().abi(), ::std::mem::transmute(pparameterlist), ::std::mem::transmute(pbderivedkey), ::std::mem::transmute(cbderivedkey), ::std::mem::transmute(pcbresult), ::std::mem::transmute(dwflags)))
25780     }
25781     #[cfg(not(windows))]
25782     unimplemented!("Unsupported target OS");
25783 }
25784 #[inline]
NCryptEncrypt(hkey: usize, pbinput: *const u8, cbinput: u32, ppaddinginfo: *const ::std::ffi::c_void, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> i3225785 pub unsafe fn NCryptEncrypt(hkey: usize, pbinput: *const u8, cbinput: u32, ppaddinginfo: *const ::std::ffi::c_void, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> i32 {
25786     #[cfg(windows)]
25787     {
25788         #[link(name = "windows")]
25789         extern "system" {
25790             fn NCryptEncrypt(hkey: usize, pbinput: *const u8, cbinput: u32, ppaddinginfo: *const ::std::ffi::c_void, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> i32;
25791         }
25792         ::std::mem::transmute(NCryptEncrypt(::std::mem::transmute(hkey), ::std::mem::transmute(pbinput), ::std::mem::transmute(cbinput), ::std::mem::transmute(ppaddinginfo), ::std::mem::transmute(pboutput), ::std::mem::transmute(cboutput), ::std::mem::transmute(pcbresult), ::std::mem::transmute(dwflags)))
25793     }
25794     #[cfg(not(windows))]
25795     unimplemented!("Unsupported target OS");
25796 }
25797 #[cfg(feature = "Win32_Foundation")]
25798 #[inline]
NCryptEnumAlgorithms(hprovider: usize, dwalgoperations: NCRYPT_OPERATION, pdwalgcount: *mut u32, ppalglist: *mut *mut NCryptAlgorithmName, dwflags: u32) -> i3225799 pub unsafe fn NCryptEnumAlgorithms(hprovider: usize, dwalgoperations: NCRYPT_OPERATION, pdwalgcount: *mut u32, ppalglist: *mut *mut NCryptAlgorithmName, dwflags: u32) -> i32 {
25800     #[cfg(windows)]
25801     {
25802         #[link(name = "windows")]
25803         extern "system" {
25804             fn NCryptEnumAlgorithms(hprovider: usize, dwalgoperations: NCRYPT_OPERATION, pdwalgcount: *mut u32, ppalglist: *mut *mut NCryptAlgorithmName, dwflags: u32) -> i32;
25805         }
25806         ::std::mem::transmute(NCryptEnumAlgorithms(::std::mem::transmute(hprovider), ::std::mem::transmute(dwalgoperations), ::std::mem::transmute(pdwalgcount), ::std::mem::transmute(ppalglist), ::std::mem::transmute(dwflags)))
25807     }
25808     #[cfg(not(windows))]
25809     unimplemented!("Unsupported target OS");
25810 }
25811 #[cfg(feature = "Win32_Foundation")]
25812 #[inline]
NCryptEnumKeys<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hprovider: usize, pszscope: Param1, ppkeyname: *mut *mut NCryptKeyName, ppenumstate: *mut *mut ::std::ffi::c_void, dwflags: NCRYPT_FLAGS) -> i3225813 pub unsafe fn NCryptEnumKeys<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hprovider: usize, pszscope: Param1, ppkeyname: *mut *mut NCryptKeyName, ppenumstate: *mut *mut ::std::ffi::c_void, dwflags: NCRYPT_FLAGS) -> i32 {
25814     #[cfg(windows)]
25815     {
25816         #[link(name = "windows")]
25817         extern "system" {
25818             fn NCryptEnumKeys(hprovider: usize, pszscope: super::super::Foundation::PWSTR, ppkeyname: *mut *mut NCryptKeyName, ppenumstate: *mut *mut ::std::ffi::c_void, dwflags: NCRYPT_FLAGS) -> i32;
25819         }
25820         ::std::mem::transmute(NCryptEnumKeys(::std::mem::transmute(hprovider), pszscope.into_param().abi(), ::std::mem::transmute(ppkeyname), ::std::mem::transmute(ppenumstate), ::std::mem::transmute(dwflags)))
25821     }
25822     #[cfg(not(windows))]
25823     unimplemented!("Unsupported target OS");
25824 }
25825 #[cfg(feature = "Win32_Foundation")]
25826 #[inline]
NCryptEnumStorageProviders(pdwprovidercount: *mut u32, ppproviderlist: *mut *mut NCryptProviderName, dwflags: u32) -> i3225827 pub unsafe fn NCryptEnumStorageProviders(pdwprovidercount: *mut u32, ppproviderlist: *mut *mut NCryptProviderName, dwflags: u32) -> i32 {
25828     #[cfg(windows)]
25829     {
25830         #[link(name = "windows")]
25831         extern "system" {
25832             fn NCryptEnumStorageProviders(pdwprovidercount: *mut u32, ppproviderlist: *mut *mut NCryptProviderName, dwflags: u32) -> i32;
25833         }
25834         ::std::mem::transmute(NCryptEnumStorageProviders(::std::mem::transmute(pdwprovidercount), ::std::mem::transmute(ppproviderlist), ::std::mem::transmute(dwflags)))
25835     }
25836     #[cfg(not(windows))]
25837     unimplemented!("Unsupported target OS");
25838 }
25839 #[cfg(feature = "Win32_Foundation")]
25840 #[inline]
NCryptExportKey<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hkey: usize, hexportkey: usize, pszblobtype: Param2, pparameterlist: *const BCryptBufferDesc, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> i3225841 pub unsafe fn NCryptExportKey<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hkey: usize, hexportkey: usize, pszblobtype: Param2, pparameterlist: *const BCryptBufferDesc, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> i32 {
25842     #[cfg(windows)]
25843     {
25844         #[link(name = "windows")]
25845         extern "system" {
25846             fn NCryptExportKey(hkey: usize, hexportkey: usize, pszblobtype: super::super::Foundation::PWSTR, pparameterlist: *const BCryptBufferDesc, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> i32;
25847         }
25848         ::std::mem::transmute(NCryptExportKey(::std::mem::transmute(hkey), ::std::mem::transmute(hexportkey), pszblobtype.into_param().abi(), ::std::mem::transmute(pparameterlist), ::std::mem::transmute(pboutput), ::std::mem::transmute(cboutput), ::std::mem::transmute(pcbresult), ::std::mem::transmute(dwflags)))
25849     }
25850     #[cfg(not(windows))]
25851     unimplemented!("Unsupported target OS");
25852 }
25853 #[inline]
NCryptFinalizeKey(hkey: usize, dwflags: NCRYPT_FLAGS) -> i3225854 pub unsafe fn NCryptFinalizeKey(hkey: usize, dwflags: NCRYPT_FLAGS) -> i32 {
25855     #[cfg(windows)]
25856     {
25857         #[link(name = "windows")]
25858         extern "system" {
25859             fn NCryptFinalizeKey(hkey: usize, dwflags: NCRYPT_FLAGS) -> i32;
25860         }
25861         ::std::mem::transmute(NCryptFinalizeKey(::std::mem::transmute(hkey), ::std::mem::transmute(dwflags)))
25862     }
25863     #[cfg(not(windows))]
25864     unimplemented!("Unsupported target OS");
25865 }
25866 #[inline]
NCryptFreeBuffer(pvinput: *mut ::std::ffi::c_void) -> i3225867 pub unsafe fn NCryptFreeBuffer(pvinput: *mut ::std::ffi::c_void) -> i32 {
25868     #[cfg(windows)]
25869     {
25870         #[link(name = "windows")]
25871         extern "system" {
25872             fn NCryptFreeBuffer(pvinput: *mut ::std::ffi::c_void) -> i32;
25873         }
25874         ::std::mem::transmute(NCryptFreeBuffer(::std::mem::transmute(pvinput)))
25875     }
25876     #[cfg(not(windows))]
25877     unimplemented!("Unsupported target OS");
25878 }
25879 #[inline]
NCryptFreeObject(hobject: usize) -> i3225880 pub unsafe fn NCryptFreeObject(hobject: usize) -> i32 {
25881     #[cfg(windows)]
25882     {
25883         #[link(name = "windows")]
25884         extern "system" {
25885             fn NCryptFreeObject(hobject: usize) -> i32;
25886         }
25887         ::std::mem::transmute(NCryptFreeObject(::std::mem::transmute(hobject)))
25888     }
25889     #[cfg(not(windows))]
25890     unimplemented!("Unsupported target OS");
25891 }
25892 #[cfg(feature = "Win32_Foundation")]
25893 #[inline]
NCryptGetProperty<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hobject: usize, pszproperty: Param1, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: super::OBJECT_SECURITY_INFORMATION) -> i3225894 pub unsafe fn NCryptGetProperty<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hobject: usize, pszproperty: Param1, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: super::OBJECT_SECURITY_INFORMATION) -> i32 {
25895     #[cfg(windows)]
25896     {
25897         #[link(name = "windows")]
25898         extern "system" {
25899             fn NCryptGetProperty(hobject: usize, pszproperty: super::super::Foundation::PWSTR, pboutput: *mut u8, cboutput: u32, pcbresult: *mut u32, dwflags: super::OBJECT_SECURITY_INFORMATION) -> i32;
25900         }
25901         ::std::mem::transmute(NCryptGetProperty(::std::mem::transmute(hobject), pszproperty.into_param().abi(), ::std::mem::transmute(pboutput), ::std::mem::transmute(cboutput), ::std::mem::transmute(pcbresult), ::std::mem::transmute(dwflags)))
25902     }
25903     #[cfg(not(windows))]
25904     unimplemented!("Unsupported target OS");
25905 }
25906 #[inline]
NCryptGetProtectionDescriptorInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::NCRYPT_DESCRIPTOR_HANDLE>>(hdescriptor: Param0, pmempara: *const NCRYPT_ALLOC_PARA, dwinfotype: u32, ppvinfo: *mut *mut ::std::ffi::c_void) -> i3225907 pub unsafe fn NCryptGetProtectionDescriptorInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::NCRYPT_DESCRIPTOR_HANDLE>>(hdescriptor: Param0, pmempara: *const NCRYPT_ALLOC_PARA, dwinfotype: u32, ppvinfo: *mut *mut ::std::ffi::c_void) -> i32 {
25908     #[cfg(windows)]
25909     {
25910         #[link(name = "windows")]
25911         extern "system" {
25912             fn NCryptGetProtectionDescriptorInfo(hdescriptor: super::NCRYPT_DESCRIPTOR_HANDLE, pmempara: *const ::std::mem::ManuallyDrop<NCRYPT_ALLOC_PARA>, dwinfotype: u32, ppvinfo: *mut *mut ::std::ffi::c_void) -> i32;
25913         }
25914         ::std::mem::transmute(NCryptGetProtectionDescriptorInfo(hdescriptor.into_param().abi(), ::std::mem::transmute(pmempara), ::std::mem::transmute(dwinfotype), ::std::mem::transmute(ppvinfo)))
25915     }
25916     #[cfg(not(windows))]
25917     unimplemented!("Unsupported target OS");
25918 }
25919 #[cfg(feature = "Win32_Foundation")]
25920 #[inline]
NCryptImportKey<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hprovider: usize, himportkey: usize, pszblobtype: Param2, pparameterlist: *const BCryptBufferDesc, phkey: *mut usize, pbdata: *const u8, cbdata: u32, dwflags: NCRYPT_FLAGS) -> i3225921 pub unsafe fn NCryptImportKey<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hprovider: usize, himportkey: usize, pszblobtype: Param2, pparameterlist: *const BCryptBufferDesc, phkey: *mut usize, pbdata: *const u8, cbdata: u32, dwflags: NCRYPT_FLAGS) -> i32 {
25922     #[cfg(windows)]
25923     {
25924         #[link(name = "windows")]
25925         extern "system" {
25926             fn NCryptImportKey(hprovider: usize, himportkey: usize, pszblobtype: super::super::Foundation::PWSTR, pparameterlist: *const BCryptBufferDesc, phkey: *mut usize, pbdata: *const u8, cbdata: u32, dwflags: NCRYPT_FLAGS) -> i32;
25927         }
25928         ::std::mem::transmute(NCryptImportKey(::std::mem::transmute(hprovider), ::std::mem::transmute(himportkey), pszblobtype.into_param().abi(), ::std::mem::transmute(pparameterlist), ::std::mem::transmute(phkey), ::std::mem::transmute(pbdata), ::std::mem::transmute(cbdata), ::std::mem::transmute(dwflags)))
25929     }
25930     #[cfg(not(windows))]
25931     unimplemented!("Unsupported target OS");
25932 }
25933 #[cfg(feature = "Win32_Foundation")]
25934 #[inline]
NCryptIsAlgSupported<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hprovider: usize, pszalgid: Param1, dwflags: u32) -> i3225935 pub unsafe fn NCryptIsAlgSupported<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hprovider: usize, pszalgid: Param1, dwflags: u32) -> i32 {
25936     #[cfg(windows)]
25937     {
25938         #[link(name = "windows")]
25939         extern "system" {
25940             fn NCryptIsAlgSupported(hprovider: usize, pszalgid: super::super::Foundation::PWSTR, dwflags: u32) -> i32;
25941         }
25942         ::std::mem::transmute(NCryptIsAlgSupported(::std::mem::transmute(hprovider), pszalgid.into_param().abi(), ::std::mem::transmute(dwflags)))
25943     }
25944     #[cfg(not(windows))]
25945     unimplemented!("Unsupported target OS");
25946 }
25947 #[cfg(feature = "Win32_Foundation")]
25948 #[inline]
NCryptIsKeyHandle(hkey: usize) -> super::super::Foundation::BOOL25949 pub unsafe fn NCryptIsKeyHandle(hkey: usize) -> super::super::Foundation::BOOL {
25950     #[cfg(windows)]
25951     {
25952         #[link(name = "windows")]
25953         extern "system" {
25954             fn NCryptIsKeyHandle(hkey: usize) -> super::super::Foundation::BOOL;
25955         }
25956         ::std::mem::transmute(NCryptIsKeyHandle(::std::mem::transmute(hkey)))
25957     }
25958     #[cfg(not(windows))]
25959     unimplemented!("Unsupported target OS");
25960 }
25961 #[inline]
NCryptKeyDerivation(hkey: usize, pparameterlist: *const BCryptBufferDesc, pbderivedkey: *mut u8, cbderivedkey: u32, pcbresult: *mut u32, dwflags: u32) -> i3225962 pub unsafe fn NCryptKeyDerivation(hkey: usize, pparameterlist: *const BCryptBufferDesc, pbderivedkey: *mut u8, cbderivedkey: u32, pcbresult: *mut u32, dwflags: u32) -> i32 {
25963     #[cfg(windows)]
25964     {
25965         #[link(name = "windows")]
25966         extern "system" {
25967             fn NCryptKeyDerivation(hkey: usize, pparameterlist: *const BCryptBufferDesc, pbderivedkey: *mut u8, cbderivedkey: u32, pcbresult: *mut u32, dwflags: u32) -> i32;
25968         }
25969         ::std::mem::transmute(NCryptKeyDerivation(::std::mem::transmute(hkey), ::std::mem::transmute(pparameterlist), ::std::mem::transmute(pbderivedkey), ::std::mem::transmute(cbderivedkey), ::std::mem::transmute(pcbresult), ::std::mem::transmute(dwflags)))
25970     }
25971     #[cfg(not(windows))]
25972     unimplemented!("Unsupported target OS");
25973 }
25974 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
25975 #[repr(C)]
25976 #[cfg(feature = "Win32_Foundation")]
25977 pub struct NCryptKeyName {
25978     pub pszName: super::super::Foundation::PWSTR,
25979     pub pszAlgid: super::super::Foundation::PWSTR,
25980     pub dwLegacyKeySpec: CERT_KEY_SPEC,
25981     pub dwFlags: u32,
25982 }
25983 #[cfg(feature = "Win32_Foundation")]
25984 impl NCryptKeyName {}
25985 #[cfg(feature = "Win32_Foundation")]
25986 impl ::std::default::Default for NCryptKeyName {
default() -> Self25987     fn default() -> Self {
25988         unsafe { ::std::mem::zeroed() }
25989     }
25990 }
25991 #[cfg(feature = "Win32_Foundation")]
25992 impl ::std::fmt::Debug for NCryptKeyName {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result25993     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
25994         fmt.debug_struct("NCryptKeyName").field("pszName", &self.pszName).field("pszAlgid", &self.pszAlgid).field("dwLegacyKeySpec", &self.dwLegacyKeySpec).field("dwFlags", &self.dwFlags).finish()
25995     }
25996 }
25997 #[cfg(feature = "Win32_Foundation")]
25998 impl ::std::cmp::PartialEq for NCryptKeyName {
eq(&self, other: &Self) -> bool25999     fn eq(&self, other: &Self) -> bool {
26000         self.pszName == other.pszName && self.pszAlgid == other.pszAlgid && self.dwLegacyKeySpec == other.dwLegacyKeySpec && self.dwFlags == other.dwFlags
26001     }
26002 }
26003 #[cfg(feature = "Win32_Foundation")]
26004 impl ::std::cmp::Eq for NCryptKeyName {}
26005 #[cfg(feature = "Win32_Foundation")]
26006 unsafe impl ::windows::runtime::Abi for NCryptKeyName {
26007     type Abi = Self;
26008     type DefaultType = Self;
26009 }
26010 #[cfg(feature = "Win32_Foundation")]
26011 #[inline]
NCryptNotifyChangeKey(hprovider: usize, phevent: *mut super::super::Foundation::HANDLE, dwflags: NCRYPT_FLAGS) -> i3226012 pub unsafe fn NCryptNotifyChangeKey(hprovider: usize, phevent: *mut super::super::Foundation::HANDLE, dwflags: NCRYPT_FLAGS) -> i32 {
26013     #[cfg(windows)]
26014     {
26015         #[link(name = "windows")]
26016         extern "system" {
26017             fn NCryptNotifyChangeKey(hprovider: usize, phevent: *mut super::super::Foundation::HANDLE, dwflags: NCRYPT_FLAGS) -> i32;
26018         }
26019         ::std::mem::transmute(NCryptNotifyChangeKey(::std::mem::transmute(hprovider), ::std::mem::transmute(phevent), ::std::mem::transmute(dwflags)))
26020     }
26021     #[cfg(not(windows))]
26022     unimplemented!("Unsupported target OS");
26023 }
26024 #[cfg(feature = "Win32_Foundation")]
26025 #[inline]
NCryptOpenKey<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hprovider: usize, phkey: *mut usize, pszkeyname: Param2, dwlegacykeyspec: CERT_KEY_SPEC, dwflags: NCRYPT_FLAGS) -> i3226026 pub unsafe fn NCryptOpenKey<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hprovider: usize, phkey: *mut usize, pszkeyname: Param2, dwlegacykeyspec: CERT_KEY_SPEC, dwflags: NCRYPT_FLAGS) -> i32 {
26027     #[cfg(windows)]
26028     {
26029         #[link(name = "windows")]
26030         extern "system" {
26031             fn NCryptOpenKey(hprovider: usize, phkey: *mut usize, pszkeyname: super::super::Foundation::PWSTR, dwlegacykeyspec: CERT_KEY_SPEC, dwflags: NCRYPT_FLAGS) -> i32;
26032         }
26033         ::std::mem::transmute(NCryptOpenKey(::std::mem::transmute(hprovider), ::std::mem::transmute(phkey), pszkeyname.into_param().abi(), ::std::mem::transmute(dwlegacykeyspec), ::std::mem::transmute(dwflags)))
26034     }
26035     #[cfg(not(windows))]
26036     unimplemented!("Unsupported target OS");
26037 }
26038 #[cfg(feature = "Win32_Foundation")]
26039 #[inline]
NCryptOpenStorageProvider<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(phprovider: *mut usize, pszprovidername: Param1, dwflags: u32) -> i3226040 pub unsafe fn NCryptOpenStorageProvider<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(phprovider: *mut usize, pszprovidername: Param1, dwflags: u32) -> i32 {
26041     #[cfg(windows)]
26042     {
26043         #[link(name = "windows")]
26044         extern "system" {
26045             fn NCryptOpenStorageProvider(phprovider: *mut usize, pszprovidername: super::super::Foundation::PWSTR, dwflags: u32) -> i32;
26046         }
26047         ::std::mem::transmute(NCryptOpenStorageProvider(::std::mem::transmute(phprovider), pszprovidername.into_param().abi(), ::std::mem::transmute(dwflags)))
26048     }
26049     #[cfg(not(windows))]
26050     unimplemented!("Unsupported target OS");
26051 }
26052 #[cfg(feature = "Win32_Foundation")]
26053 #[inline]
NCryptProtectSecret<'a, Param0: ::windows::runtime::IntoParam<'a, super::NCRYPT_DESCRIPTOR_HANDLE>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hdescriptor: Param0, dwflags: u32, pbdata: *const u8, cbdata: u32, pmempara: *const NCRYPT_ALLOC_PARA, hwnd: Param5, ppbprotectedblob: *mut *mut u8, pcbprotectedblob: *mut u32) -> i3226054 pub unsafe fn NCryptProtectSecret<'a, Param0: ::windows::runtime::IntoParam<'a, super::NCRYPT_DESCRIPTOR_HANDLE>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hdescriptor: Param0, dwflags: u32, pbdata: *const u8, cbdata: u32, pmempara: *const NCRYPT_ALLOC_PARA, hwnd: Param5, ppbprotectedblob: *mut *mut u8, pcbprotectedblob: *mut u32) -> i32 {
26055     #[cfg(windows)]
26056     {
26057         #[link(name = "windows")]
26058         extern "system" {
26059             fn NCryptProtectSecret(hdescriptor: super::NCRYPT_DESCRIPTOR_HANDLE, dwflags: u32, pbdata: *const u8, cbdata: u32, pmempara: *const ::std::mem::ManuallyDrop<NCRYPT_ALLOC_PARA>, hwnd: super::super::Foundation::HWND, ppbprotectedblob: *mut *mut u8, pcbprotectedblob: *mut u32) -> i32;
26060         }
26061         ::std::mem::transmute(NCryptProtectSecret(hdescriptor.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(pbdata), ::std::mem::transmute(cbdata), ::std::mem::transmute(pmempara), hwnd.into_param().abi(), ::std::mem::transmute(ppbprotectedblob), ::std::mem::transmute(pcbprotectedblob)))
26062     }
26063     #[cfg(not(windows))]
26064     unimplemented!("Unsupported target OS");
26065 }
26066 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
26067 #[repr(C)]
26068 #[cfg(feature = "Win32_Foundation")]
26069 pub struct NCryptProviderName {
26070     pub pszName: super::super::Foundation::PWSTR,
26071     pub pszComment: super::super::Foundation::PWSTR,
26072 }
26073 #[cfg(feature = "Win32_Foundation")]
26074 impl NCryptProviderName {}
26075 #[cfg(feature = "Win32_Foundation")]
26076 impl ::std::default::Default for NCryptProviderName {
default() -> Self26077     fn default() -> Self {
26078         unsafe { ::std::mem::zeroed() }
26079     }
26080 }
26081 #[cfg(feature = "Win32_Foundation")]
26082 impl ::std::fmt::Debug for NCryptProviderName {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result26083     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
26084         fmt.debug_struct("NCryptProviderName").field("pszName", &self.pszName).field("pszComment", &self.pszComment).finish()
26085     }
26086 }
26087 #[cfg(feature = "Win32_Foundation")]
26088 impl ::std::cmp::PartialEq for NCryptProviderName {
eq(&self, other: &Self) -> bool26089     fn eq(&self, other: &Self) -> bool {
26090         self.pszName == other.pszName && self.pszComment == other.pszComment
26091     }
26092 }
26093 #[cfg(feature = "Win32_Foundation")]
26094 impl ::std::cmp::Eq for NCryptProviderName {}
26095 #[cfg(feature = "Win32_Foundation")]
26096 unsafe impl ::windows::runtime::Abi for NCryptProviderName {
26097     type Abi = Self;
26098     type DefaultType = Self;
26099 }
26100 #[cfg(feature = "Win32_Foundation")]
26101 #[inline]
NCryptQueryProtectionDescriptorName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pwszname: Param0, pwszdescriptorstring: super::super::Foundation::PWSTR, pcdescriptorstring: *mut usize, dwflags: u32) -> i3226102 pub unsafe fn NCryptQueryProtectionDescriptorName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pwszname: Param0, pwszdescriptorstring: super::super::Foundation::PWSTR, pcdescriptorstring: *mut usize, dwflags: u32) -> i32 {
26103     #[cfg(windows)]
26104     {
26105         #[link(name = "windows")]
26106         extern "system" {
26107             fn NCryptQueryProtectionDescriptorName(pwszname: super::super::Foundation::PWSTR, pwszdescriptorstring: super::super::Foundation::PWSTR, pcdescriptorstring: *mut usize, dwflags: u32) -> i32;
26108         }
26109         ::std::mem::transmute(NCryptQueryProtectionDescriptorName(pwszname.into_param().abi(), ::std::mem::transmute(pwszdescriptorstring), ::std::mem::transmute(pcdescriptorstring), ::std::mem::transmute(dwflags)))
26110     }
26111     #[cfg(not(windows))]
26112     unimplemented!("Unsupported target OS");
26113 }
26114 #[cfg(feature = "Win32_Foundation")]
26115 #[inline]
NCryptRegisterProtectionDescriptorName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pwszname: Param0, pwszdescriptorstring: Param1, dwflags: u32) -> i3226116 pub unsafe fn NCryptRegisterProtectionDescriptorName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pwszname: Param0, pwszdescriptorstring: Param1, dwflags: u32) -> i32 {
26117     #[cfg(windows)]
26118     {
26119         #[link(name = "windows")]
26120         extern "system" {
26121             fn NCryptRegisterProtectionDescriptorName(pwszname: super::super::Foundation::PWSTR, pwszdescriptorstring: super::super::Foundation::PWSTR, dwflags: u32) -> i32;
26122         }
26123         ::std::mem::transmute(NCryptRegisterProtectionDescriptorName(pwszname.into_param().abi(), pwszdescriptorstring.into_param().abi(), ::std::mem::transmute(dwflags)))
26124     }
26125     #[cfg(not(windows))]
26126     unimplemented!("Unsupported target OS");
26127 }
26128 #[inline]
NCryptSecretAgreement(hprivkey: usize, hpubkey: usize, phagreedsecret: *mut usize, dwflags: NCRYPT_FLAGS) -> i3226129 pub unsafe fn NCryptSecretAgreement(hprivkey: usize, hpubkey: usize, phagreedsecret: *mut usize, dwflags: NCRYPT_FLAGS) -> i32 {
26130     #[cfg(windows)]
26131     {
26132         #[link(name = "windows")]
26133         extern "system" {
26134             fn NCryptSecretAgreement(hprivkey: usize, hpubkey: usize, phagreedsecret: *mut usize, dwflags: NCRYPT_FLAGS) -> i32;
26135         }
26136         ::std::mem::transmute(NCryptSecretAgreement(::std::mem::transmute(hprivkey), ::std::mem::transmute(hpubkey), ::std::mem::transmute(phagreedsecret), ::std::mem::transmute(dwflags)))
26137     }
26138     #[cfg(not(windows))]
26139     unimplemented!("Unsupported target OS");
26140 }
26141 #[cfg(feature = "Win32_Foundation")]
26142 #[inline]
NCryptSetProperty<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hobject: usize, pszproperty: Param1, pbinput: *const u8, cbinput: u32, dwflags: NCRYPT_FLAGS) -> i3226143 pub unsafe fn NCryptSetProperty<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hobject: usize, pszproperty: Param1, pbinput: *const u8, cbinput: u32, dwflags: NCRYPT_FLAGS) -> i32 {
26144     #[cfg(windows)]
26145     {
26146         #[link(name = "windows")]
26147         extern "system" {
26148             fn NCryptSetProperty(hobject: usize, pszproperty: super::super::Foundation::PWSTR, pbinput: *const u8, cbinput: u32, dwflags: NCRYPT_FLAGS) -> i32;
26149         }
26150         ::std::mem::transmute(NCryptSetProperty(::std::mem::transmute(hobject), pszproperty.into_param().abi(), ::std::mem::transmute(pbinput), ::std::mem::transmute(cbinput), ::std::mem::transmute(dwflags)))
26151     }
26152     #[cfg(not(windows))]
26153     unimplemented!("Unsupported target OS");
26154 }
26155 #[inline]
NCryptSignHash(hkey: usize, ppaddinginfo: *const ::std::ffi::c_void, pbhashvalue: *const u8, cbhashvalue: u32, pbsignature: *mut u8, cbsignature: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> i3226156 pub unsafe fn NCryptSignHash(hkey: usize, ppaddinginfo: *const ::std::ffi::c_void, pbhashvalue: *const u8, cbhashvalue: u32, pbsignature: *mut u8, cbsignature: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> i32 {
26157     #[cfg(windows)]
26158     {
26159         #[link(name = "windows")]
26160         extern "system" {
26161             fn NCryptSignHash(hkey: usize, ppaddinginfo: *const ::std::ffi::c_void, pbhashvalue: *const u8, cbhashvalue: u32, pbsignature: *mut u8, cbsignature: u32, pcbresult: *mut u32, dwflags: NCRYPT_FLAGS) -> i32;
26162         }
26163         ::std::mem::transmute(NCryptSignHash(::std::mem::transmute(hkey), ::std::mem::transmute(ppaddinginfo), ::std::mem::transmute(pbhashvalue), ::std::mem::transmute(cbhashvalue), ::std::mem::transmute(pbsignature), ::std::mem::transmute(cbsignature), ::std::mem::transmute(pcbresult), ::std::mem::transmute(dwflags)))
26164     }
26165     #[cfg(not(windows))]
26166     unimplemented!("Unsupported target OS");
26167 }
26168 #[inline]
NCryptStreamClose<'a, Param0: ::windows::runtime::IntoParam<'a, super::NCRYPT_STREAM_HANDLE>>(hstream: Param0) -> i3226169 pub unsafe fn NCryptStreamClose<'a, Param0: ::windows::runtime::IntoParam<'a, super::NCRYPT_STREAM_HANDLE>>(hstream: Param0) -> i32 {
26170     #[cfg(windows)]
26171     {
26172         #[link(name = "windows")]
26173         extern "system" {
26174             fn NCryptStreamClose(hstream: super::NCRYPT_STREAM_HANDLE) -> i32;
26175         }
26176         ::std::mem::transmute(NCryptStreamClose(hstream.into_param().abi()))
26177     }
26178     #[cfg(not(windows))]
26179     unimplemented!("Unsupported target OS");
26180 }
26181 #[cfg(feature = "Win32_Foundation")]
26182 #[inline]
NCryptStreamOpenToProtect<'a, Param0: ::windows::runtime::IntoParam<'a, super::NCRYPT_DESCRIPTOR_HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hdescriptor: Param0, dwflags: u32, hwnd: Param2, pstreaminfo: *const NCRYPT_PROTECT_STREAM_INFO, phstream: *mut super::NCRYPT_STREAM_HANDLE) -> i3226183 pub unsafe fn NCryptStreamOpenToProtect<'a, Param0: ::windows::runtime::IntoParam<'a, super::NCRYPT_DESCRIPTOR_HANDLE>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hdescriptor: Param0, dwflags: u32, hwnd: Param2, pstreaminfo: *const NCRYPT_PROTECT_STREAM_INFO, phstream: *mut super::NCRYPT_STREAM_HANDLE) -> i32 {
26184     #[cfg(windows)]
26185     {
26186         #[link(name = "windows")]
26187         extern "system" {
26188             fn NCryptStreamOpenToProtect(hdescriptor: super::NCRYPT_DESCRIPTOR_HANDLE, dwflags: u32, hwnd: super::super::Foundation::HWND, pstreaminfo: *const ::std::mem::ManuallyDrop<NCRYPT_PROTECT_STREAM_INFO>, phstream: *mut super::NCRYPT_STREAM_HANDLE) -> i32;
26189         }
26190         ::std::mem::transmute(NCryptStreamOpenToProtect(hdescriptor.into_param().abi(), ::std::mem::transmute(dwflags), hwnd.into_param().abi(), ::std::mem::transmute(pstreaminfo), ::std::mem::transmute(phstream)))
26191     }
26192     #[cfg(not(windows))]
26193     unimplemented!("Unsupported target OS");
26194 }
26195 #[cfg(feature = "Win32_Foundation")]
26196 #[inline]
NCryptStreamOpenToUnprotect<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(pstreaminfo: *const NCRYPT_PROTECT_STREAM_INFO, dwflags: u32, hwnd: Param2, phstream: *mut super::NCRYPT_STREAM_HANDLE) -> i3226197 pub unsafe fn NCryptStreamOpenToUnprotect<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(pstreaminfo: *const NCRYPT_PROTECT_STREAM_INFO, dwflags: u32, hwnd: Param2, phstream: *mut super::NCRYPT_STREAM_HANDLE) -> i32 {
26198     #[cfg(windows)]
26199     {
26200         #[link(name = "windows")]
26201         extern "system" {
26202             fn NCryptStreamOpenToUnprotect(pstreaminfo: *const ::std::mem::ManuallyDrop<NCRYPT_PROTECT_STREAM_INFO>, dwflags: u32, hwnd: super::super::Foundation::HWND, phstream: *mut super::NCRYPT_STREAM_HANDLE) -> i32;
26203         }
26204         ::std::mem::transmute(NCryptStreamOpenToUnprotect(::std::mem::transmute(pstreaminfo), ::std::mem::transmute(dwflags), hwnd.into_param().abi(), ::std::mem::transmute(phstream)))
26205     }
26206     #[cfg(not(windows))]
26207     unimplemented!("Unsupported target OS");
26208 }
26209 #[cfg(feature = "Win32_Foundation")]
26210 #[inline]
NCryptStreamOpenToUnprotectEx<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(pstreaminfo: *const NCRYPT_PROTECT_STREAM_INFO_EX, dwflags: u32, hwnd: Param2, phstream: *mut super::NCRYPT_STREAM_HANDLE) -> i3226211 pub unsafe fn NCryptStreamOpenToUnprotectEx<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(pstreaminfo: *const NCRYPT_PROTECT_STREAM_INFO_EX, dwflags: u32, hwnd: Param2, phstream: *mut super::NCRYPT_STREAM_HANDLE) -> i32 {
26212     #[cfg(windows)]
26213     {
26214         #[link(name = "windows")]
26215         extern "system" {
26216             fn NCryptStreamOpenToUnprotectEx(pstreaminfo: *const ::std::mem::ManuallyDrop<NCRYPT_PROTECT_STREAM_INFO_EX>, dwflags: u32, hwnd: super::super::Foundation::HWND, phstream: *mut super::NCRYPT_STREAM_HANDLE) -> i32;
26217         }
26218         ::std::mem::transmute(NCryptStreamOpenToUnprotectEx(::std::mem::transmute(pstreaminfo), ::std::mem::transmute(dwflags), hwnd.into_param().abi(), ::std::mem::transmute(phstream)))
26219     }
26220     #[cfg(not(windows))]
26221     unimplemented!("Unsupported target OS");
26222 }
26223 #[cfg(feature = "Win32_Foundation")]
26224 #[inline]
NCryptStreamUpdate<'a, Param0: ::windows::runtime::IntoParam<'a, super::NCRYPT_STREAM_HANDLE>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hstream: Param0, pbdata: *const u8, cbdata: usize, ffinal: Param3) -> i3226225 pub unsafe fn NCryptStreamUpdate<'a, Param0: ::windows::runtime::IntoParam<'a, super::NCRYPT_STREAM_HANDLE>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(hstream: Param0, pbdata: *const u8, cbdata: usize, ffinal: Param3) -> i32 {
26226     #[cfg(windows)]
26227     {
26228         #[link(name = "windows")]
26229         extern "system" {
26230             fn NCryptStreamUpdate(hstream: super::NCRYPT_STREAM_HANDLE, pbdata: *const u8, cbdata: usize, ffinal: super::super::Foundation::BOOL) -> i32;
26231         }
26232         ::std::mem::transmute(NCryptStreamUpdate(hstream.into_param().abi(), ::std::mem::transmute(pbdata), ::std::mem::transmute(cbdata), ffinal.into_param().abi()))
26233     }
26234     #[cfg(not(windows))]
26235     unimplemented!("Unsupported target OS");
26236 }
26237 #[inline]
NCryptTranslateHandle(phprovider: *mut usize, phkey: *mut usize, hlegacyprov: usize, hlegacykey: usize, dwlegacykeyspec: CERT_KEY_SPEC, dwflags: u32) -> i3226238 pub unsafe fn NCryptTranslateHandle(phprovider: *mut usize, phkey: *mut usize, hlegacyprov: usize, hlegacykey: usize, dwlegacykeyspec: CERT_KEY_SPEC, dwflags: u32) -> i32 {
26239     #[cfg(windows)]
26240     {
26241         #[link(name = "windows")]
26242         extern "system" {
26243             fn NCryptTranslateHandle(phprovider: *mut usize, phkey: *mut usize, hlegacyprov: usize, hlegacykey: usize, dwlegacykeyspec: CERT_KEY_SPEC, dwflags: u32) -> i32;
26244         }
26245         ::std::mem::transmute(NCryptTranslateHandle(::std::mem::transmute(phprovider), ::std::mem::transmute(phkey), ::std::mem::transmute(hlegacyprov), ::std::mem::transmute(hlegacykey), ::std::mem::transmute(dwlegacykeyspec), ::std::mem::transmute(dwflags)))
26246     }
26247     #[cfg(not(windows))]
26248     unimplemented!("Unsupported target OS");
26249 }
26250 #[cfg(feature = "Win32_Foundation")]
26251 #[inline]
NCryptUnprotectSecret<'a, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(phdescriptor: *mut super::NCRYPT_DESCRIPTOR_HANDLE, dwflags: NCRYPT_FLAGS, pbprotectedblob: *const u8, cbprotectedblob: u32, pmempara: *const NCRYPT_ALLOC_PARA, hwnd: Param5, ppbdata: *mut *mut u8, pcbdata: *mut u32) -> i3226252 pub unsafe fn NCryptUnprotectSecret<'a, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(phdescriptor: *mut super::NCRYPT_DESCRIPTOR_HANDLE, dwflags: NCRYPT_FLAGS, pbprotectedblob: *const u8, cbprotectedblob: u32, pmempara: *const NCRYPT_ALLOC_PARA, hwnd: Param5, ppbdata: *mut *mut u8, pcbdata: *mut u32) -> i32 {
26253     #[cfg(windows)]
26254     {
26255         #[link(name = "windows")]
26256         extern "system" {
26257             fn NCryptUnprotectSecret(phdescriptor: *mut super::NCRYPT_DESCRIPTOR_HANDLE, dwflags: NCRYPT_FLAGS, pbprotectedblob: *const u8, cbprotectedblob: u32, pmempara: *const ::std::mem::ManuallyDrop<NCRYPT_ALLOC_PARA>, hwnd: super::super::Foundation::HWND, ppbdata: *mut *mut u8, pcbdata: *mut u32) -> i32;
26258         }
26259         ::std::mem::transmute(NCryptUnprotectSecret(::std::mem::transmute(phdescriptor), ::std::mem::transmute(dwflags), ::std::mem::transmute(pbprotectedblob), ::std::mem::transmute(cbprotectedblob), ::std::mem::transmute(pmempara), hwnd.into_param().abi(), ::std::mem::transmute(ppbdata), ::std::mem::transmute(pcbdata)))
26260     }
26261     #[cfg(not(windows))]
26262     unimplemented!("Unsupported target OS");
26263 }
26264 #[inline]
NCryptVerifyClaim(hsubjectkey: usize, hauthoritykey: usize, dwclaimtype: u32, pparameterlist: *const BCryptBufferDesc, pbclaimblob: *const u8, cbclaimblob: u32, poutput: *mut BCryptBufferDesc, dwflags: u32) -> i3226265 pub unsafe fn NCryptVerifyClaim(hsubjectkey: usize, hauthoritykey: usize, dwclaimtype: u32, pparameterlist: *const BCryptBufferDesc, pbclaimblob: *const u8, cbclaimblob: u32, poutput: *mut BCryptBufferDesc, dwflags: u32) -> i32 {
26266     #[cfg(windows)]
26267     {
26268         #[link(name = "windows")]
26269         extern "system" {
26270             fn NCryptVerifyClaim(hsubjectkey: usize, hauthoritykey: usize, dwclaimtype: u32, pparameterlist: *const BCryptBufferDesc, pbclaimblob: *const u8, cbclaimblob: u32, poutput: *mut BCryptBufferDesc, dwflags: u32) -> i32;
26271         }
26272         ::std::mem::transmute(NCryptVerifyClaim(
26273             ::std::mem::transmute(hsubjectkey),
26274             ::std::mem::transmute(hauthoritykey),
26275             ::std::mem::transmute(dwclaimtype),
26276             ::std::mem::transmute(pparameterlist),
26277             ::std::mem::transmute(pbclaimblob),
26278             ::std::mem::transmute(cbclaimblob),
26279             ::std::mem::transmute(poutput),
26280             ::std::mem::transmute(dwflags),
26281         ))
26282     }
26283     #[cfg(not(windows))]
26284     unimplemented!("Unsupported target OS");
26285 }
26286 #[inline]
NCryptVerifySignature(hkey: usize, ppaddinginfo: *const ::std::ffi::c_void, pbhashvalue: *const u8, cbhashvalue: u32, pbsignature: *const u8, cbsignature: u32, dwflags: NCRYPT_FLAGS) -> i3226287 pub unsafe fn NCryptVerifySignature(hkey: usize, ppaddinginfo: *const ::std::ffi::c_void, pbhashvalue: *const u8, cbhashvalue: u32, pbsignature: *const u8, cbsignature: u32, dwflags: NCRYPT_FLAGS) -> i32 {
26288     #[cfg(windows)]
26289     {
26290         #[link(name = "windows")]
26291         extern "system" {
26292             fn NCryptVerifySignature(hkey: usize, ppaddinginfo: *const ::std::ffi::c_void, pbhashvalue: *const u8, cbhashvalue: u32, pbsignature: *const u8, cbsignature: u32, dwflags: NCRYPT_FLAGS) -> i32;
26293         }
26294         ::std::mem::transmute(NCryptVerifySignature(::std::mem::transmute(hkey), ::std::mem::transmute(ppaddinginfo), ::std::mem::transmute(pbhashvalue), ::std::mem::transmute(cbhashvalue), ::std::mem::transmute(pbsignature), ::std::mem::transmute(cbsignature), ::std::mem::transmute(dwflags)))
26295     }
26296     #[cfg(not(windows))]
26297     unimplemented!("Unsupported target OS");
26298 }
26299 pub const NETSCAPE_SIGN_CA_CERT_TYPE: u32 = 1u32;
26300 pub const NETSCAPE_SIGN_CERT_TYPE: u32 = 16u32;
26301 pub const NETSCAPE_SMIME_CA_CERT_TYPE: u32 = 2u32;
26302 pub const NETSCAPE_SMIME_CERT_TYPE: u32 = 32u32;
26303 pub const NETSCAPE_SSL_CA_CERT_TYPE: u32 = 4u32;
26304 pub const NETSCAPE_SSL_CLIENT_AUTH_CERT_TYPE: u32 = 128u32;
26305 pub const NETSCAPE_SSL_SERVER_AUTH_CERT_TYPE: u32 = 64u32;
26306 pub const OCSP_BASIC_BY_KEY_RESPONDER_ID: u32 = 2u32;
26307 pub const OCSP_BASIC_BY_NAME_RESPONDER_ID: u32 = 1u32;
26308 pub const OCSP_BASIC_GOOD_CERT_STATUS: u32 = 0u32;
26309 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
26310 #[repr(C)]
26311 #[cfg(feature = "Win32_Foundation")]
26312 pub struct OCSP_BASIC_RESPONSE_ENTRY {
26313     pub CertId: OCSP_CERT_ID,
26314     pub dwCertStatus: u32,
26315     pub Anonymous: OCSP_BASIC_RESPONSE_ENTRY_0,
26316     pub ThisUpdate: super::super::Foundation::FILETIME,
26317     pub NextUpdate: super::super::Foundation::FILETIME,
26318     pub cExtension: u32,
26319     pub rgExtension: *mut CERT_EXTENSION,
26320 }
26321 #[cfg(feature = "Win32_Foundation")]
26322 impl OCSP_BASIC_RESPONSE_ENTRY {}
26323 #[cfg(feature = "Win32_Foundation")]
26324 impl ::std::default::Default for OCSP_BASIC_RESPONSE_ENTRY {
default() -> Self26325     fn default() -> Self {
26326         unsafe { ::std::mem::zeroed() }
26327     }
26328 }
26329 #[cfg(feature = "Win32_Foundation")]
26330 impl ::std::cmp::PartialEq for OCSP_BASIC_RESPONSE_ENTRY {
eq(&self, _other: &Self) -> bool26331     fn eq(&self, _other: &Self) -> bool {
26332         unimplemented!()
26333     }
26334 }
26335 #[cfg(feature = "Win32_Foundation")]
26336 impl ::std::cmp::Eq for OCSP_BASIC_RESPONSE_ENTRY {}
26337 #[cfg(feature = "Win32_Foundation")]
26338 unsafe impl ::windows::runtime::Abi for OCSP_BASIC_RESPONSE_ENTRY {
26339     type Abi = Self;
26340     type DefaultType = Self;
26341 }
26342 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
26343 #[repr(C)]
26344 #[cfg(feature = "Win32_Foundation")]
26345 pub union OCSP_BASIC_RESPONSE_ENTRY_0 {
26346     pub pRevokedInfo: *mut OCSP_BASIC_REVOKED_INFO,
26347 }
26348 #[cfg(feature = "Win32_Foundation")]
26349 impl OCSP_BASIC_RESPONSE_ENTRY_0 {}
26350 #[cfg(feature = "Win32_Foundation")]
26351 impl ::std::default::Default for OCSP_BASIC_RESPONSE_ENTRY_0 {
default() -> Self26352     fn default() -> Self {
26353         unsafe { ::std::mem::zeroed() }
26354     }
26355 }
26356 #[cfg(feature = "Win32_Foundation")]
26357 impl ::std::cmp::PartialEq for OCSP_BASIC_RESPONSE_ENTRY_0 {
eq(&self, _other: &Self) -> bool26358     fn eq(&self, _other: &Self) -> bool {
26359         unimplemented!()
26360     }
26361 }
26362 #[cfg(feature = "Win32_Foundation")]
26363 impl ::std::cmp::Eq for OCSP_BASIC_RESPONSE_ENTRY_0 {}
26364 #[cfg(feature = "Win32_Foundation")]
26365 unsafe impl ::windows::runtime::Abi for OCSP_BASIC_RESPONSE_ENTRY_0 {
26366     type Abi = Self;
26367     type DefaultType = Self;
26368 }
26369 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
26370 #[repr(C)]
26371 #[cfg(feature = "Win32_Foundation")]
26372 pub struct OCSP_BASIC_RESPONSE_INFO {
26373     pub dwVersion: u32,
26374     pub dwResponderIdChoice: u32,
26375     pub Anonymous: OCSP_BASIC_RESPONSE_INFO_0,
26376     pub ProducedAt: super::super::Foundation::FILETIME,
26377     pub cResponseEntry: u32,
26378     pub rgResponseEntry: *mut OCSP_BASIC_RESPONSE_ENTRY,
26379     pub cExtension: u32,
26380     pub rgExtension: *mut CERT_EXTENSION,
26381 }
26382 #[cfg(feature = "Win32_Foundation")]
26383 impl OCSP_BASIC_RESPONSE_INFO {}
26384 #[cfg(feature = "Win32_Foundation")]
26385 impl ::std::default::Default for OCSP_BASIC_RESPONSE_INFO {
default() -> Self26386     fn default() -> Self {
26387         unsafe { ::std::mem::zeroed() }
26388     }
26389 }
26390 #[cfg(feature = "Win32_Foundation")]
26391 impl ::std::cmp::PartialEq for OCSP_BASIC_RESPONSE_INFO {
eq(&self, _other: &Self) -> bool26392     fn eq(&self, _other: &Self) -> bool {
26393         unimplemented!()
26394     }
26395 }
26396 #[cfg(feature = "Win32_Foundation")]
26397 impl ::std::cmp::Eq for OCSP_BASIC_RESPONSE_INFO {}
26398 #[cfg(feature = "Win32_Foundation")]
26399 unsafe impl ::windows::runtime::Abi for OCSP_BASIC_RESPONSE_INFO {
26400     type Abi = Self;
26401     type DefaultType = Self;
26402 }
26403 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
26404 #[repr(C)]
26405 pub union OCSP_BASIC_RESPONSE_INFO_0 {
26406     pub ByNameResponderId: CRYPTOAPI_BLOB,
26407     pub ByKeyResponderId: CRYPTOAPI_BLOB,
26408 }
26409 impl OCSP_BASIC_RESPONSE_INFO_0 {}
26410 impl ::std::default::Default for OCSP_BASIC_RESPONSE_INFO_0 {
default() -> Self26411     fn default() -> Self {
26412         unsafe { ::std::mem::zeroed() }
26413     }
26414 }
26415 impl ::std::cmp::PartialEq for OCSP_BASIC_RESPONSE_INFO_0 {
eq(&self, _other: &Self) -> bool26416     fn eq(&self, _other: &Self) -> bool {
26417         unimplemented!()
26418     }
26419 }
26420 impl ::std::cmp::Eq for OCSP_BASIC_RESPONSE_INFO_0 {}
26421 unsafe impl ::windows::runtime::Abi for OCSP_BASIC_RESPONSE_INFO_0 {
26422     type Abi = Self;
26423     type DefaultType = Self;
26424 }
26425 pub const OCSP_BASIC_RESPONSE_V1: u32 = 0u32;
26426 pub const OCSP_BASIC_REVOKED_CERT_STATUS: u32 = 1u32;
26427 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
26428 #[repr(C)]
26429 #[cfg(feature = "Win32_Foundation")]
26430 pub struct OCSP_BASIC_REVOKED_INFO {
26431     pub RevocationDate: super::super::Foundation::FILETIME,
26432     pub dwCrlReasonCode: CERT_REVOCATION_STATUS_REASON,
26433 }
26434 #[cfg(feature = "Win32_Foundation")]
26435 impl OCSP_BASIC_REVOKED_INFO {}
26436 #[cfg(feature = "Win32_Foundation")]
26437 impl ::std::default::Default for OCSP_BASIC_REVOKED_INFO {
default() -> Self26438     fn default() -> Self {
26439         unsafe { ::std::mem::zeroed() }
26440     }
26441 }
26442 #[cfg(feature = "Win32_Foundation")]
26443 impl ::std::fmt::Debug for OCSP_BASIC_REVOKED_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result26444     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
26445         fmt.debug_struct("OCSP_BASIC_REVOKED_INFO").field("RevocationDate", &self.RevocationDate).field("dwCrlReasonCode", &self.dwCrlReasonCode).finish()
26446     }
26447 }
26448 #[cfg(feature = "Win32_Foundation")]
26449 impl ::std::cmp::PartialEq for OCSP_BASIC_REVOKED_INFO {
eq(&self, other: &Self) -> bool26450     fn eq(&self, other: &Self) -> bool {
26451         self.RevocationDate == other.RevocationDate && self.dwCrlReasonCode == other.dwCrlReasonCode
26452     }
26453 }
26454 #[cfg(feature = "Win32_Foundation")]
26455 impl ::std::cmp::Eq for OCSP_BASIC_REVOKED_INFO {}
26456 #[cfg(feature = "Win32_Foundation")]
26457 unsafe impl ::windows::runtime::Abi for OCSP_BASIC_REVOKED_INFO {
26458     type Abi = Self;
26459     type DefaultType = Self;
26460 }
26461 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
26462 #[repr(C)]
26463 #[cfg(feature = "Win32_Foundation")]
26464 pub struct OCSP_BASIC_SIGNED_RESPONSE_INFO {
26465     pub ToBeSigned: CRYPTOAPI_BLOB,
26466     pub SignatureInfo: OCSP_SIGNATURE_INFO,
26467 }
26468 #[cfg(feature = "Win32_Foundation")]
26469 impl OCSP_BASIC_SIGNED_RESPONSE_INFO {}
26470 #[cfg(feature = "Win32_Foundation")]
26471 impl ::std::default::Default for OCSP_BASIC_SIGNED_RESPONSE_INFO {
default() -> Self26472     fn default() -> Self {
26473         unsafe { ::std::mem::zeroed() }
26474     }
26475 }
26476 #[cfg(feature = "Win32_Foundation")]
26477 impl ::std::fmt::Debug for OCSP_BASIC_SIGNED_RESPONSE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result26478     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
26479         fmt.debug_struct("OCSP_BASIC_SIGNED_RESPONSE_INFO").field("ToBeSigned", &self.ToBeSigned).field("SignatureInfo", &self.SignatureInfo).finish()
26480     }
26481 }
26482 #[cfg(feature = "Win32_Foundation")]
26483 impl ::std::cmp::PartialEq for OCSP_BASIC_SIGNED_RESPONSE_INFO {
eq(&self, other: &Self) -> bool26484     fn eq(&self, other: &Self) -> bool {
26485         self.ToBeSigned == other.ToBeSigned && self.SignatureInfo == other.SignatureInfo
26486     }
26487 }
26488 #[cfg(feature = "Win32_Foundation")]
26489 impl ::std::cmp::Eq for OCSP_BASIC_SIGNED_RESPONSE_INFO {}
26490 #[cfg(feature = "Win32_Foundation")]
26491 unsafe impl ::windows::runtime::Abi for OCSP_BASIC_SIGNED_RESPONSE_INFO {
26492     type Abi = Self;
26493     type DefaultType = Self;
26494 }
26495 pub const OCSP_BASIC_UNKNOWN_CERT_STATUS: u32 = 2u32;
26496 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
26497 #[repr(C)]
26498 #[cfg(feature = "Win32_Foundation")]
26499 pub struct OCSP_CERT_ID {
26500     pub HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
26501     pub IssuerNameHash: CRYPTOAPI_BLOB,
26502     pub IssuerKeyHash: CRYPTOAPI_BLOB,
26503     pub SerialNumber: CRYPTOAPI_BLOB,
26504 }
26505 #[cfg(feature = "Win32_Foundation")]
26506 impl OCSP_CERT_ID {}
26507 #[cfg(feature = "Win32_Foundation")]
26508 impl ::std::default::Default for OCSP_CERT_ID {
default() -> Self26509     fn default() -> Self {
26510         unsafe { ::std::mem::zeroed() }
26511     }
26512 }
26513 #[cfg(feature = "Win32_Foundation")]
26514 impl ::std::fmt::Debug for OCSP_CERT_ID {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result26515     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
26516         fmt.debug_struct("OCSP_CERT_ID").field("HashAlgorithm", &self.HashAlgorithm).field("IssuerNameHash", &self.IssuerNameHash).field("IssuerKeyHash", &self.IssuerKeyHash).field("SerialNumber", &self.SerialNumber).finish()
26517     }
26518 }
26519 #[cfg(feature = "Win32_Foundation")]
26520 impl ::std::cmp::PartialEq for OCSP_CERT_ID {
eq(&self, other: &Self) -> bool26521     fn eq(&self, other: &Self) -> bool {
26522         self.HashAlgorithm == other.HashAlgorithm && self.IssuerNameHash == other.IssuerNameHash && self.IssuerKeyHash == other.IssuerKeyHash && self.SerialNumber == other.SerialNumber
26523     }
26524 }
26525 #[cfg(feature = "Win32_Foundation")]
26526 impl ::std::cmp::Eq for OCSP_CERT_ID {}
26527 #[cfg(feature = "Win32_Foundation")]
26528 unsafe impl ::windows::runtime::Abi for OCSP_CERT_ID {
26529     type Abi = Self;
26530     type DefaultType = Self;
26531 }
26532 pub const OCSP_INTERNAL_ERROR_RESPONSE: u32 = 2u32;
26533 pub const OCSP_MALFORMED_REQUEST_RESPONSE: u32 = 1u32;
26534 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
26535 #[repr(C)]
26536 #[cfg(feature = "Win32_Foundation")]
26537 pub struct OCSP_REQUEST_ENTRY {
26538     pub CertId: OCSP_CERT_ID,
26539     pub cExtension: u32,
26540     pub rgExtension: *mut CERT_EXTENSION,
26541 }
26542 #[cfg(feature = "Win32_Foundation")]
26543 impl OCSP_REQUEST_ENTRY {}
26544 #[cfg(feature = "Win32_Foundation")]
26545 impl ::std::default::Default for OCSP_REQUEST_ENTRY {
default() -> Self26546     fn default() -> Self {
26547         unsafe { ::std::mem::zeroed() }
26548     }
26549 }
26550 #[cfg(feature = "Win32_Foundation")]
26551 impl ::std::fmt::Debug for OCSP_REQUEST_ENTRY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result26552     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
26553         fmt.debug_struct("OCSP_REQUEST_ENTRY").field("CertId", &self.CertId).field("cExtension", &self.cExtension).field("rgExtension", &self.rgExtension).finish()
26554     }
26555 }
26556 #[cfg(feature = "Win32_Foundation")]
26557 impl ::std::cmp::PartialEq for OCSP_REQUEST_ENTRY {
eq(&self, other: &Self) -> bool26558     fn eq(&self, other: &Self) -> bool {
26559         self.CertId == other.CertId && self.cExtension == other.cExtension && self.rgExtension == other.rgExtension
26560     }
26561 }
26562 #[cfg(feature = "Win32_Foundation")]
26563 impl ::std::cmp::Eq for OCSP_REQUEST_ENTRY {}
26564 #[cfg(feature = "Win32_Foundation")]
26565 unsafe impl ::windows::runtime::Abi for OCSP_REQUEST_ENTRY {
26566     type Abi = Self;
26567     type DefaultType = Self;
26568 }
26569 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
26570 #[repr(C)]
26571 #[cfg(feature = "Win32_Foundation")]
26572 pub struct OCSP_REQUEST_INFO {
26573     pub dwVersion: u32,
26574     pub pRequestorName: *mut CERT_ALT_NAME_ENTRY,
26575     pub cRequestEntry: u32,
26576     pub rgRequestEntry: *mut OCSP_REQUEST_ENTRY,
26577     pub cExtension: u32,
26578     pub rgExtension: *mut CERT_EXTENSION,
26579 }
26580 #[cfg(feature = "Win32_Foundation")]
26581 impl OCSP_REQUEST_INFO {}
26582 #[cfg(feature = "Win32_Foundation")]
26583 impl ::std::default::Default for OCSP_REQUEST_INFO {
default() -> Self26584     fn default() -> Self {
26585         unsafe { ::std::mem::zeroed() }
26586     }
26587 }
26588 #[cfg(feature = "Win32_Foundation")]
26589 impl ::std::fmt::Debug for OCSP_REQUEST_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result26590     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
26591         fmt.debug_struct("OCSP_REQUEST_INFO").field("dwVersion", &self.dwVersion).field("pRequestorName", &self.pRequestorName).field("cRequestEntry", &self.cRequestEntry).field("rgRequestEntry", &self.rgRequestEntry).field("cExtension", &self.cExtension).field("rgExtension", &self.rgExtension).finish()
26592     }
26593 }
26594 #[cfg(feature = "Win32_Foundation")]
26595 impl ::std::cmp::PartialEq for OCSP_REQUEST_INFO {
eq(&self, other: &Self) -> bool26596     fn eq(&self, other: &Self) -> bool {
26597         self.dwVersion == other.dwVersion && self.pRequestorName == other.pRequestorName && self.cRequestEntry == other.cRequestEntry && self.rgRequestEntry == other.rgRequestEntry && self.cExtension == other.cExtension && self.rgExtension == other.rgExtension
26598     }
26599 }
26600 #[cfg(feature = "Win32_Foundation")]
26601 impl ::std::cmp::Eq for OCSP_REQUEST_INFO {}
26602 #[cfg(feature = "Win32_Foundation")]
26603 unsafe impl ::windows::runtime::Abi for OCSP_REQUEST_INFO {
26604     type Abi = Self;
26605     type DefaultType = Self;
26606 }
26607 pub const OCSP_REQUEST_V1: u32 = 0u32;
26608 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
26609 #[repr(C)]
26610 #[cfg(feature = "Win32_Foundation")]
26611 pub struct OCSP_RESPONSE_INFO {
26612     pub dwStatus: u32,
26613     pub pszObjId: super::super::Foundation::PSTR,
26614     pub Value: CRYPTOAPI_BLOB,
26615 }
26616 #[cfg(feature = "Win32_Foundation")]
26617 impl OCSP_RESPONSE_INFO {}
26618 #[cfg(feature = "Win32_Foundation")]
26619 impl ::std::default::Default for OCSP_RESPONSE_INFO {
default() -> Self26620     fn default() -> Self {
26621         unsafe { ::std::mem::zeroed() }
26622     }
26623 }
26624 #[cfg(feature = "Win32_Foundation")]
26625 impl ::std::fmt::Debug for OCSP_RESPONSE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result26626     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
26627         fmt.debug_struct("OCSP_RESPONSE_INFO").field("dwStatus", &self.dwStatus).field("pszObjId", &self.pszObjId).field("Value", &self.Value).finish()
26628     }
26629 }
26630 #[cfg(feature = "Win32_Foundation")]
26631 impl ::std::cmp::PartialEq for OCSP_RESPONSE_INFO {
eq(&self, other: &Self) -> bool26632     fn eq(&self, other: &Self) -> bool {
26633         self.dwStatus == other.dwStatus && self.pszObjId == other.pszObjId && self.Value == other.Value
26634     }
26635 }
26636 #[cfg(feature = "Win32_Foundation")]
26637 impl ::std::cmp::Eq for OCSP_RESPONSE_INFO {}
26638 #[cfg(feature = "Win32_Foundation")]
26639 unsafe impl ::windows::runtime::Abi for OCSP_RESPONSE_INFO {
26640     type Abi = Self;
26641     type DefaultType = Self;
26642 }
26643 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
26644 #[repr(C)]
26645 #[cfg(feature = "Win32_Foundation")]
26646 pub struct OCSP_SIGNATURE_INFO {
26647     pub SignatureAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
26648     pub Signature: CRYPT_BIT_BLOB,
26649     pub cCertEncoded: u32,
26650     pub rgCertEncoded: *mut CRYPTOAPI_BLOB,
26651 }
26652 #[cfg(feature = "Win32_Foundation")]
26653 impl OCSP_SIGNATURE_INFO {}
26654 #[cfg(feature = "Win32_Foundation")]
26655 impl ::std::default::Default for OCSP_SIGNATURE_INFO {
default() -> Self26656     fn default() -> Self {
26657         unsafe { ::std::mem::zeroed() }
26658     }
26659 }
26660 #[cfg(feature = "Win32_Foundation")]
26661 impl ::std::fmt::Debug for OCSP_SIGNATURE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result26662     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
26663         fmt.debug_struct("OCSP_SIGNATURE_INFO").field("SignatureAlgorithm", &self.SignatureAlgorithm).field("Signature", &self.Signature).field("cCertEncoded", &self.cCertEncoded).field("rgCertEncoded", &self.rgCertEncoded).finish()
26664     }
26665 }
26666 #[cfg(feature = "Win32_Foundation")]
26667 impl ::std::cmp::PartialEq for OCSP_SIGNATURE_INFO {
eq(&self, other: &Self) -> bool26668     fn eq(&self, other: &Self) -> bool {
26669         self.SignatureAlgorithm == other.SignatureAlgorithm && self.Signature == other.Signature && self.cCertEncoded == other.cCertEncoded && self.rgCertEncoded == other.rgCertEncoded
26670     }
26671 }
26672 #[cfg(feature = "Win32_Foundation")]
26673 impl ::std::cmp::Eq for OCSP_SIGNATURE_INFO {}
26674 #[cfg(feature = "Win32_Foundation")]
26675 unsafe impl ::windows::runtime::Abi for OCSP_SIGNATURE_INFO {
26676     type Abi = Self;
26677     type DefaultType = Self;
26678 }
26679 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
26680 #[repr(C)]
26681 #[cfg(feature = "Win32_Foundation")]
26682 pub struct OCSP_SIGNED_REQUEST_INFO {
26683     pub ToBeSigned: CRYPTOAPI_BLOB,
26684     pub pOptionalSignatureInfo: *mut OCSP_SIGNATURE_INFO,
26685 }
26686 #[cfg(feature = "Win32_Foundation")]
26687 impl OCSP_SIGNED_REQUEST_INFO {}
26688 #[cfg(feature = "Win32_Foundation")]
26689 impl ::std::default::Default for OCSP_SIGNED_REQUEST_INFO {
default() -> Self26690     fn default() -> Self {
26691         unsafe { ::std::mem::zeroed() }
26692     }
26693 }
26694 #[cfg(feature = "Win32_Foundation")]
26695 impl ::std::fmt::Debug for OCSP_SIGNED_REQUEST_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result26696     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
26697         fmt.debug_struct("OCSP_SIGNED_REQUEST_INFO").field("ToBeSigned", &self.ToBeSigned).field("pOptionalSignatureInfo", &self.pOptionalSignatureInfo).finish()
26698     }
26699 }
26700 #[cfg(feature = "Win32_Foundation")]
26701 impl ::std::cmp::PartialEq for OCSP_SIGNED_REQUEST_INFO {
eq(&self, other: &Self) -> bool26702     fn eq(&self, other: &Self) -> bool {
26703         self.ToBeSigned == other.ToBeSigned && self.pOptionalSignatureInfo == other.pOptionalSignatureInfo
26704     }
26705 }
26706 #[cfg(feature = "Win32_Foundation")]
26707 impl ::std::cmp::Eq for OCSP_SIGNED_REQUEST_INFO {}
26708 #[cfg(feature = "Win32_Foundation")]
26709 unsafe impl ::windows::runtime::Abi for OCSP_SIGNED_REQUEST_INFO {
26710     type Abi = Self;
26711     type DefaultType = Self;
26712 }
26713 pub const OCSP_SIG_REQUIRED_RESPONSE: u32 = 5u32;
26714 pub const OCSP_SUCCESSFUL_RESPONSE: u32 = 0u32;
26715 pub const OCSP_TRY_LATER_RESPONSE: u32 = 3u32;
26716 pub const OCSP_UNAUTHORIZED_RESPONSE: u32 = 6u32;
26717 pub const OPAQUEKEYBLOB: u32 = 9u32;
26718 #[cfg(feature = "Win32_Foundation")]
26719 pub type PCRYPT_DECRYPT_PRIVATE_KEY_FUNC = unsafe extern "system" fn(algorithm: CRYPT_ALGORITHM_IDENTIFIER, encryptedprivatekey: CRYPTOAPI_BLOB, pbcleartextkey: *mut u8, pcbcleartextkey: *mut u32, pvoiddecryptfunc: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26720 #[cfg(feature = "Win32_Foundation")]
26721 pub type PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC = unsafe extern "system" fn(palgorithm: *mut CRYPT_ALGORITHM_IDENTIFIER, pcleartextprivatekey: *const CRYPTOAPI_BLOB, pbencryptedkey: *mut u8, pcbencryptedkey: *mut u32, pvoidencryptfunc: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26722 #[cfg(feature = "Win32_Foundation")]
26723 pub type PCRYPT_RESOLVE_HCRYPTPROV_FUNC = unsafe extern "system" fn(pprivatekeyinfo: *mut CRYPT_PRIVATE_KEY_INFO, phcryptprov: *mut usize, pvoidresolvefunc: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26724 #[cfg(feature = "Win32_Foundation")]
26725 pub type PFNCFILTERPROC = unsafe extern "system" fn(pcertcontext: *const CERT_CONTEXT, pfinitialselectedcert: *mut super::super::Foundation::BOOL, pvcallbackdata: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26726 #[cfg(feature = "Win32_Foundation")]
26727 pub type PFNCMFILTERPROC = unsafe extern "system" fn(pcertcontext: *const CERT_CONTEXT, param1: super::super::Foundation::LPARAM, param2: u32, param3: u32) -> super::super::Foundation::BOOL;
26728 #[cfg(feature = "Win32_Foundation")]
26729 pub type PFNCMHOOKPROC = unsafe extern "system" fn(hwnddialog: super::super::Foundation::HWND, message: u32, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> u32;
26730 #[cfg(feature = "Win32_Foundation")]
26731 pub type PFNCryptStreamOutputCallback = unsafe extern "system" fn(pvcallbackctxt: *const ::std::ffi::c_void, pbdata: *const u8, cbdata: usize, ffinal: super::super::Foundation::BOOL) -> i32;
26732 #[cfg(feature = "Win32_Foundation")]
26733 pub type PFNCryptStreamOutputCallbackEx = unsafe extern "system" fn(pvcallbackctxt: *const ::std::ffi::c_void, pbdata: *const u8, cbdata: usize, hdescriptor: super::NCRYPT_DESCRIPTOR_HANDLE, ffinal: super::super::Foundation::BOOL) -> i32;
26734 #[cfg(feature = "Win32_Foundation")]
26735 pub type PFNTRUSTHELPER = unsafe extern "system" fn(pcertcontext: *const CERT_CONTEXT, lcustdata: super::super::Foundation::LPARAM, fleafcertificate: super::super::Foundation::BOOL, pbtrustblob: *mut u8) -> ::windows::runtime::HRESULT;
26736 #[cfg(feature = "Win32_Foundation")]
26737 pub type PFN_CANCEL_ASYNC_RETRIEVAL_FUNC = unsafe extern "system" fn(hasyncretrieve: HCRYPTASYNC) -> super::super::Foundation::BOOL;
26738 #[cfg(feature = "Win32_Foundation")]
26739 pub type PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK = unsafe extern "system" fn(pcert: *const CERT_CONTEXT, pvfindarg: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26740 #[cfg(feature = "Win32_Foundation")]
26741 pub type PFN_CERT_CREATE_CONTEXT_SORT_FUNC = unsafe extern "system" fn(cbtotalencoded: u32, cbremainencoded: u32, centry: u32, pvsort: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26742 #[cfg(feature = "Win32_Foundation")]
26743 pub type PFN_CERT_DLL_OPEN_STORE_PROV_FUNC = unsafe extern "system" fn(lpszstoreprovider: super::super::Foundation::PSTR, dwencodingtype: CERT_QUERY_ENCODING_TYPE, hcryptprov: usize, dwflags: CERT_OPEN_STORE_FLAGS, pvpara: *const ::std::ffi::c_void, hcertstore: *const ::std::ffi::c_void, pstoreprovinfo: *mut CERT_STORE_PROV_INFO) -> super::super::Foundation::BOOL;
26744 #[cfg(feature = "Win32_Foundation")]
26745 pub type PFN_CERT_ENUM_PHYSICAL_STORE = unsafe extern "system" fn(pvsystemstore: *const ::std::ffi::c_void, dwflags: u32, pwszstorename: super::super::Foundation::PWSTR, pstoreinfo: *const CERT_PHYSICAL_STORE_INFO, pvreserved: *mut ::std::ffi::c_void, pvarg: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26746 #[cfg(feature = "Win32_Foundation")]
26747 pub type PFN_CERT_ENUM_SYSTEM_STORE = unsafe extern "system" fn(pvsystemstore: *const ::std::ffi::c_void, dwflags: CERT_SYSTEM_STORE_FLAGS, pstoreinfo: *const CERT_SYSTEM_STORE_INFO, pvreserved: *mut ::std::ffi::c_void, pvarg: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26748 #[cfg(feature = "Win32_Foundation")]
26749 pub type PFN_CERT_ENUM_SYSTEM_STORE_LOCATION = unsafe extern "system" fn(pwszstorelocation: super::super::Foundation::PWSTR, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, pvarg: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26750 #[cfg(feature = "Win32_Foundation")]
26751 pub type PFN_CERT_IS_WEAK_HASH = unsafe extern "system" fn(dwhashusetype: u32, pwszcnghashalgid: super::super::Foundation::PWSTR, dwchainflags: u32, psignerchaincontext: *const CERT_CHAIN_CONTEXT, ptimestamp: *const super::super::Foundation::FILETIME, pwszfilename: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
26752 #[cfg(feature = "Win32_Foundation")]
26753 pub type PFN_CERT_SERVER_OCSP_RESPONSE_UPDATE_CALLBACK = unsafe extern "system" fn(pchaincontext: *const CERT_CHAIN_CONTEXT, pserverocspresponsecontext: *const CERT_SERVER_OCSP_RESPONSE_CONTEXT, pnewcrlcontext: *const CRL_CONTEXT, pprevcrlcontext: *const CRL_CONTEXT, pvarg: *mut ::std::ffi::c_void, dwwriteocspfileerror: u32);
26754 pub type PFN_CERT_STORE_PROV_CLOSE = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, dwflags: u32);
26755 #[cfg(feature = "Win32_Foundation")]
26756 pub type PFN_CERT_STORE_PROV_CONTROL = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, dwflags: u32, dwctrltype: u32, pvctrlpara: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26757 #[cfg(feature = "Win32_Foundation")]
26758 pub type PFN_CERT_STORE_PROV_DELETE_CERT = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pcertcontext: *const CERT_CONTEXT, dwflags: u32) -> super::super::Foundation::BOOL;
26759 #[cfg(feature = "Win32_Foundation")]
26760 pub type PFN_CERT_STORE_PROV_DELETE_CRL = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pcrlcontext: *const CRL_CONTEXT, dwflags: u32) -> super::super::Foundation::BOOL;
26761 #[cfg(feature = "Win32_Foundation")]
26762 pub type PFN_CERT_STORE_PROV_DELETE_CTL = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pctlcontext: *const CTL_CONTEXT, dwflags: u32) -> super::super::Foundation::BOOL;
26763 #[cfg(feature = "Win32_Foundation")]
26764 pub type PFN_CERT_STORE_PROV_FIND_CERT = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pfindinfo: *const CERT_STORE_PROV_FIND_INFO, pprevcertcontext: *const CERT_CONTEXT, dwflags: u32, ppvstoreprovfindinfo: *mut *mut ::std::ffi::c_void, ppprovcertcontext: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL;
26765 #[cfg(feature = "Win32_Foundation")]
26766 pub type PFN_CERT_STORE_PROV_FIND_CRL = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pfindinfo: *const CERT_STORE_PROV_FIND_INFO, pprevcrlcontext: *const CRL_CONTEXT, dwflags: u32, ppvstoreprovfindinfo: *mut *mut ::std::ffi::c_void, ppprovcrlcontext: *mut *mut CRL_CONTEXT) -> super::super::Foundation::BOOL;
26767 #[cfg(feature = "Win32_Foundation")]
26768 pub type PFN_CERT_STORE_PROV_FIND_CTL = unsafe extern "system" fn(hstoreprov: *const ::std::ffi::c_void, pfindinfo: *const CERT_STORE_PROV_FIND_INFO, pprevctlcontext: *const CTL_CONTEXT, dwflags: u32, ppvstoreprovfindinfo: *mut *mut ::std::ffi::c_void, ppprovctlcontext: *mut *mut CTL_CONTEXT) -> super::super::Foundation::BOOL;
26769 #[cfg(feature = "Win32_Foundation")]
26770 pub type PFN_CERT_STORE_PROV_FREE_FIND_CERT = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pcertcontext: *const CERT_CONTEXT, pvstoreprovfindinfo: *const ::std::ffi::c_void, dwflags: u32) -> super::super::Foundation::BOOL;
26771 #[cfg(feature = "Win32_Foundation")]
26772 pub type PFN_CERT_STORE_PROV_FREE_FIND_CRL = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pcrlcontext: *const CRL_CONTEXT, pvstoreprovfindinfo: *const ::std::ffi::c_void, dwflags: u32) -> super::super::Foundation::BOOL;
26773 #[cfg(feature = "Win32_Foundation")]
26774 pub type PFN_CERT_STORE_PROV_FREE_FIND_CTL = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pctlcontext: *const CTL_CONTEXT, pvstoreprovfindinfo: *const ::std::ffi::c_void, dwflags: u32) -> super::super::Foundation::BOOL;
26775 #[cfg(feature = "Win32_Foundation")]
26776 pub type PFN_CERT_STORE_PROV_GET_CERT_PROPERTY = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pcertcontext: *const CERT_CONTEXT, dwpropid: u32, dwflags: u32, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL;
26777 #[cfg(feature = "Win32_Foundation")]
26778 pub type PFN_CERT_STORE_PROV_GET_CRL_PROPERTY = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pcrlcontext: *const CRL_CONTEXT, dwpropid: u32, dwflags: u32, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL;
26779 #[cfg(feature = "Win32_Foundation")]
26780 pub type PFN_CERT_STORE_PROV_GET_CTL_PROPERTY = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pctlcontext: *const CTL_CONTEXT, dwpropid: u32, dwflags: u32, pvdata: *mut ::std::ffi::c_void, pcbdata: *mut u32) -> super::super::Foundation::BOOL;
26781 #[cfg(feature = "Win32_Foundation")]
26782 pub type PFN_CERT_STORE_PROV_READ_CERT = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pstorecertcontext: *const CERT_CONTEXT, dwflags: u32, ppprovcertcontext: *mut *mut CERT_CONTEXT) -> super::super::Foundation::BOOL;
26783 #[cfg(feature = "Win32_Foundation")]
26784 pub type PFN_CERT_STORE_PROV_READ_CRL = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pstorecrlcontext: *const CRL_CONTEXT, dwflags: u32, ppprovcrlcontext: *mut *mut CRL_CONTEXT) -> super::super::Foundation::BOOL;
26785 #[cfg(feature = "Win32_Foundation")]
26786 pub type PFN_CERT_STORE_PROV_READ_CTL = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pstorectlcontext: *const CTL_CONTEXT, dwflags: u32, ppprovctlcontext: *mut *mut CTL_CONTEXT) -> super::super::Foundation::BOOL;
26787 #[cfg(feature = "Win32_Foundation")]
26788 pub type PFN_CERT_STORE_PROV_SET_CERT_PROPERTY = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pcertcontext: *const CERT_CONTEXT, dwpropid: u32, dwflags: u32, pvdata: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26789 #[cfg(feature = "Win32_Foundation")]
26790 pub type PFN_CERT_STORE_PROV_SET_CRL_PROPERTY = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pcrlcontext: *const CRL_CONTEXT, dwpropid: u32, dwflags: u32, pvdata: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26791 #[cfg(feature = "Win32_Foundation")]
26792 pub type PFN_CERT_STORE_PROV_SET_CTL_PROPERTY = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pctlcontext: *const CTL_CONTEXT, dwpropid: u32, dwflags: u32, pvdata: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26793 #[cfg(feature = "Win32_Foundation")]
26794 pub type PFN_CERT_STORE_PROV_WRITE_CERT = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pcertcontext: *const CERT_CONTEXT, dwflags: u32) -> super::super::Foundation::BOOL;
26795 #[cfg(feature = "Win32_Foundation")]
26796 pub type PFN_CERT_STORE_PROV_WRITE_CRL = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pcrlcontext: *const CRL_CONTEXT, dwflags: u32) -> super::super::Foundation::BOOL;
26797 #[cfg(feature = "Win32_Foundation")]
26798 pub type PFN_CERT_STORE_PROV_WRITE_CTL = unsafe extern "system" fn(hstoreprov: *mut ::std::ffi::c_void, pctlcontext: *const CTL_CONTEXT, dwflags: u32) -> super::super::Foundation::BOOL;
26799 pub type PFN_CMSG_ALLOC = unsafe extern "system" fn(cb: usize) -> *mut ::std::ffi::c_void;
26800 #[cfg(feature = "Win32_Foundation")]
26801 pub type PFN_CMSG_CNG_IMPORT_CONTENT_ENCRYPT_KEY = unsafe extern "system" fn(pcngcontentdecryptinfo: *mut ::std::mem::ManuallyDrop<CMSG_CNG_CONTENT_DECRYPT_INFO>, dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26802 #[cfg(feature = "Win32_Foundation")]
26803 pub type PFN_CMSG_CNG_IMPORT_KEY_AGREE = unsafe extern "system" fn(pcngcontentdecryptinfo: *mut ::std::mem::ManuallyDrop<CMSG_CNG_CONTENT_DECRYPT_INFO>, pkeyagreedecryptpara: *const CMSG_CTRL_KEY_AGREE_DECRYPT_PARA, dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26804 #[cfg(feature = "Win32_Foundation")]
26805 pub type PFN_CMSG_CNG_IMPORT_KEY_TRANS = unsafe extern "system" fn(pcngcontentdecryptinfo: *mut ::std::mem::ManuallyDrop<CMSG_CNG_CONTENT_DECRYPT_INFO>, pkeytransdecryptpara: *const CMSG_CTRL_KEY_TRANS_DECRYPT_PARA, dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26806 #[cfg(feature = "Win32_Foundation")]
26807 pub type PFN_CMSG_EXPORT_ENCRYPT_KEY = unsafe extern "system" fn(hcryptprov: usize, hencryptkey: usize, ppublickeyinfo: *const CERT_PUBLIC_KEY_INFO, pbdata: *mut u8, pcbdata: *mut u32) -> super::super::Foundation::BOOL;
26808 #[cfg(feature = "Win32_Foundation")]
26809 pub type PFN_CMSG_EXPORT_KEY_AGREE = unsafe extern "system" fn(pcontentencryptinfo: *const ::std::mem::ManuallyDrop<CMSG_CONTENT_ENCRYPT_INFO>, pkeyagreeencodeinfo: *const CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO, pkeyagreeencryptinfo: *mut CMSG_KEY_AGREE_ENCRYPT_INFO, dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26810 #[cfg(feature = "Win32_Foundation")]
26811 pub type PFN_CMSG_EXPORT_KEY_TRANS = unsafe extern "system" fn(pcontentencryptinfo: *const ::std::mem::ManuallyDrop<CMSG_CONTENT_ENCRYPT_INFO>, pkeytransencodeinfo: *const CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO, pkeytransencryptinfo: *mut CMSG_KEY_TRANS_ENCRYPT_INFO, dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26812 #[cfg(feature = "Win32_Foundation")]
26813 pub type PFN_CMSG_EXPORT_MAIL_LIST = unsafe extern "system" fn(pcontentencryptinfo: *const ::std::mem::ManuallyDrop<CMSG_CONTENT_ENCRYPT_INFO>, pmaillistencodeinfo: *const CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO, pmaillistencryptinfo: *mut CMSG_MAIL_LIST_ENCRYPT_INFO, dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26814 pub type PFN_CMSG_FREE = unsafe extern "system" fn(pv: *mut ::std::ffi::c_void);
26815 #[cfg(feature = "Win32_Foundation")]
26816 pub type PFN_CMSG_GEN_CONTENT_ENCRYPT_KEY = unsafe extern "system" fn(pcontentencryptinfo: *mut ::std::mem::ManuallyDrop<CMSG_CONTENT_ENCRYPT_INFO>, dwflags: u32, pvreserved: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26817 #[cfg(feature = "Win32_Foundation")]
26818 pub type PFN_CMSG_GEN_ENCRYPT_KEY = unsafe extern "system" fn(phcryptprov: *mut usize, paiencrypt: *const CRYPT_ALGORITHM_IDENTIFIER, pvencryptauxinfo: *const ::std::ffi::c_void, ppublickeyinfo: *const CERT_PUBLIC_KEY_INFO, pfnalloc: ::windows::runtime::RawPtr, phencryptkey: *mut usize, ppbencryptparameters: *mut *mut u8, pcbencryptparameters: *mut u32) -> super::super::Foundation::BOOL;
26819 #[cfg(feature = "Win32_Foundation")]
26820 pub type PFN_CMSG_IMPORT_ENCRYPT_KEY = unsafe extern "system" fn(hcryptprov: usize, dwkeyspec: u32, paiencrypt: *const CRYPT_ALGORITHM_IDENTIFIER, paipubkey: *const CRYPT_ALGORITHM_IDENTIFIER, pbencodedkey: *const u8, cbencodedkey: u32, phencryptkey: *mut usize) -> super::super::Foundation::BOOL;
26821 #[cfg(feature = "Win32_Foundation")]
26822 pub type PFN_CMSG_IMPORT_KEY_AGREE = unsafe extern "system" fn(pcontentencryptionalgorithm: *const CRYPT_ALGORITHM_IDENTIFIER, pkeyagreedecryptpara: *const CMSG_CTRL_KEY_AGREE_DECRYPT_PARA, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, phcontentencryptkey: *mut usize) -> super::super::Foundation::BOOL;
26823 #[cfg(feature = "Win32_Foundation")]
26824 pub type PFN_CMSG_IMPORT_KEY_TRANS = unsafe extern "system" fn(pcontentencryptionalgorithm: *const CRYPT_ALGORITHM_IDENTIFIER, pkeytransdecryptpara: *const CMSG_CTRL_KEY_TRANS_DECRYPT_PARA, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, phcontentencryptkey: *mut usize) -> super::super::Foundation::BOOL;
26825 #[cfg(feature = "Win32_Foundation")]
26826 pub type PFN_CMSG_IMPORT_MAIL_LIST = unsafe extern "system" fn(pcontentencryptionalgorithm: *const CRYPT_ALGORITHM_IDENTIFIER, pmaillistdecryptpara: *const CMSG_CTRL_MAIL_LIST_DECRYPT_PARA, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, phcontentencryptkey: *mut usize) -> super::super::Foundation::BOOL;
26827 #[cfg(feature = "Win32_Foundation")]
26828 pub type PFN_CMSG_STREAM_OUTPUT = unsafe extern "system" fn(pvarg: *const ::std::ffi::c_void, pbdata: *const u8, cbdata: u32, ffinal: super::super::Foundation::BOOL) -> super::super::Foundation::BOOL;
26829 pub type PFN_CRYPT_ALLOC = unsafe extern "system" fn(cbsize: usize) -> *mut ::std::ffi::c_void;
26830 #[cfg(feature = "Win32_Foundation")]
26831 pub type PFN_CRYPT_ASYNC_PARAM_FREE_FUNC = unsafe extern "system" fn(pszparamoid: super::super::Foundation::PSTR, pvparam: *const ::std::ffi::c_void);
26832 #[cfg(feature = "Win32_Foundation")]
26833 pub type PFN_CRYPT_ASYNC_RETRIEVAL_COMPLETION_FUNC = unsafe extern "system" fn(pvcompletion: *mut ::std::ffi::c_void, dwcompletioncode: u32, pszurl: super::super::Foundation::PSTR, pszobjectoid: super::super::Foundation::PSTR, pvobject: *const ::std::ffi::c_void);
26834 #[cfg(feature = "Win32_Foundation")]
26835 pub type PFN_CRYPT_CANCEL_RETRIEVAL = unsafe extern "system" fn(dwflags: u32, pvarg: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26836 #[cfg(feature = "Win32_Foundation")]
26837 pub type PFN_CRYPT_ENUM_KEYID_PROP = unsafe extern "system" fn(pkeyidentifier: *const CRYPTOAPI_BLOB, dwflags: u32, pvreserved: *mut ::std::ffi::c_void, pvarg: *mut ::std::ffi::c_void, cprop: u32, rgdwpropid: *const u32, rgpvdata: *const *const ::std::ffi::c_void, rgcbdata: *const u32) -> super::super::Foundation::BOOL;
26838 #[cfg(feature = "Win32_Foundation")]
26839 pub type PFN_CRYPT_ENUM_OID_FUNC = unsafe extern "system" fn(dwencodingtype: u32, pszfuncname: super::super::Foundation::PSTR, pszoid: super::super::Foundation::PSTR, cvalue: u32, rgdwvaluetype: *const u32, rgpwszvaluename: *const super::super::Foundation::PWSTR, rgpbvaluedata: *const *const u8, rgcbvaluedata: *const u32, pvarg: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26840 #[cfg(feature = "Win32_Foundation")]
26841 pub type PFN_CRYPT_ENUM_OID_INFO = unsafe extern "system" fn(pinfo: *const CRYPT_OID_INFO, pvarg: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26842 #[cfg(feature = "Win32_Foundation")]
26843 pub type PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_EX2_FUNC = unsafe extern "system" fn(hncryptkey: usize, dwcertencodingtype: u32, pszpublickeyobjid: super::super::Foundation::PSTR, dwflags: u32, pvauxinfo: *const ::std::ffi::c_void, pinfo: *mut CERT_PUBLIC_KEY_INFO, pcbinfo: *mut u32) -> super::super::Foundation::BOOL;
26844 #[cfg(feature = "Win32_Foundation")]
26845 pub type PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_FROM_BCRYPT_HANDLE_FUNC = unsafe extern "system" fn(hbcryptkey: BCRYPT_KEY_HANDLE, dwcertencodingtype: u32, pszpublickeyobjid: super::super::Foundation::PSTR, dwflags: u32, pvauxinfo: *const ::std::ffi::c_void, pinfo: *mut CERT_PUBLIC_KEY_INFO, pcbinfo: *mut u32) -> super::super::Foundation::BOOL;
26846 #[cfg(feature = "Win32_Foundation")]
26847 pub type PFN_CRYPT_EXTRACT_ENCODED_SIGNATURE_PARAMETERS_FUNC = unsafe extern "system" fn(dwcertencodingtype: u32, psignaturealgorithm: *const CRYPT_ALGORITHM_IDENTIFIER, ppvdecodedsignpara: *mut *mut ::std::ffi::c_void, ppwszcnghashalgid: *mut super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
26848 pub type PFN_CRYPT_FREE = unsafe extern "system" fn(pv: *const ::std::ffi::c_void);
26849 #[cfg(feature = "Win32_Foundation")]
26850 pub type PFN_CRYPT_GET_SIGNER_CERTIFICATE = unsafe extern "system" fn(pvgetarg: *mut ::std::ffi::c_void, dwcertencodingtype: u32, psignerid: *const CERT_INFO, hmsgcertstore: *const ::std::ffi::c_void) -> *mut CERT_CONTEXT;
26851 #[cfg(feature = "Win32_Foundation")]
26852 pub type PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FLUSH = unsafe extern "system" fn(pcontext: *const ::std::ffi::c_void, rgidentifierornamelist: *const *const CRYPTOAPI_BLOB, dwidentifierornamelistcount: u32) -> super::super::Foundation::BOOL;
26853 pub type PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE = unsafe extern "system" fn(pplugincontext: *const ::std::ffi::c_void, pbdata: *const u8);
26854 pub type PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_IDENTIFIER = unsafe extern "system" fn(pplugincontext: *const ::std::ffi::c_void, pidentifier: *const CRYPTOAPI_BLOB);
26855 #[cfg(feature = "Win32_Foundation")]
26856 pub type PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_PASSWORD = unsafe extern "system" fn(pplugincontext: *const ::std::ffi::c_void, pwszpassword: super::super::Foundation::PWSTR);
26857 #[cfg(feature = "Win32_Foundation")]
26858 pub type PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_GET = unsafe extern "system" fn(pplugincontext: *const ::std::ffi::c_void, pidentifier: *const CRYPTOAPI_BLOB, dwnametype: u32, pnameblob: *const CRYPTOAPI_BLOB, ppbcontent: *mut *mut u8, pcbcontent: *mut u32, ppwszpassword: *mut super::super::Foundation::PWSTR, ppidentifier: *mut *mut CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL;
26859 #[cfg(feature = "Win32_Foundation")]
26860 pub type PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_INITIALIZE = unsafe extern "system" fn(pfnflush: ::windows::runtime::RawPtr, pcontext: *const ::std::ffi::c_void, pdwexpectedobjectcount: *mut u32, ppfunctable: *mut *mut CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE, ppplugincontext: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26861 pub type PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_RELEASE = unsafe extern "system" fn(dwreason: CRYPT_OBJECT_LOCATOR_RELEASE_REASON, pplugincontext: *const ::std::ffi::c_void);
26862 #[cfg(feature = "Win32_Foundation")]
26863 pub type PFN_CRYPT_SIGN_AND_ENCODE_HASH_FUNC = unsafe extern "system" fn(hkey: usize, dwcertencodingtype: u32, psignaturealgorithm: *const CRYPT_ALGORITHM_IDENTIFIER, pvdecodedsignpara: *const ::std::ffi::c_void, pwszcngpubkeyalgid: super::super::Foundation::PWSTR, pwszcnghashalgid: super::super::Foundation::PWSTR, pbcomputedhash: *const u8, cbcomputedhash: u32, pbsignature: *mut u8, pcbsignature: *mut u32) -> super::super::Foundation::BOOL;
26864 #[cfg(feature = "Win32_Foundation")]
26865 pub type PFN_CRYPT_VERIFY_ENCODED_SIGNATURE_FUNC = unsafe extern "system" fn(dwcertencodingtype: u32, ppubkeyinfo: *const CERT_PUBLIC_KEY_INFO, psignaturealgorithm: *const CRYPT_ALGORITHM_IDENTIFIER, pvdecodedsignpara: *const ::std::ffi::c_void, pwszcngpubkeyalgid: super::super::Foundation::PWSTR, pwszcnghashalgid: super::super::Foundation::PWSTR, pbcomputedhash: *const u8, cbcomputedhash: u32, pbsignature: *const u8, cbsignature: u32) -> super::super::Foundation::BOOL;
26866 #[cfg(feature = "Win32_Foundation")]
26867 pub type PFN_CRYPT_XML_CREATE_TRANSFORM = unsafe extern "system" fn(ptransform: *const CRYPT_XML_ALGORITHM, pproviderin: *const ::std::mem::ManuallyDrop<CRYPT_XML_DATA_PROVIDER>, pproviderout: *mut ::std::mem::ManuallyDrop<CRYPT_XML_DATA_PROVIDER>) -> ::windows::runtime::HRESULT;
26868 pub type PFN_CRYPT_XML_DATA_PROVIDER_CLOSE = unsafe extern "system" fn(pvcallbackstate: *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
26869 pub type PFN_CRYPT_XML_DATA_PROVIDER_READ = unsafe extern "system" fn(pvcallbackstate: *mut ::std::ffi::c_void, pbdata: *mut u8, cbdata: u32, pcbread: *mut u32) -> ::windows::runtime::HRESULT;
26870 #[cfg(feature = "Win32_Foundation")]
26871 pub type PFN_CRYPT_XML_ENUM_ALG_INFO = unsafe extern "system" fn(pinfo: *const CRYPT_XML_ALGORITHM_INFO, pvarg: *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26872 pub type PFN_CRYPT_XML_WRITE_CALLBACK = unsafe extern "system" fn(pvcallbackstate: *mut ::std::ffi::c_void, pbdata: *const u8, cbdata: u32) -> ::windows::runtime::HRESULT;
26873 #[cfg(feature = "Win32_Foundation")]
26874 pub type PFN_EXPORT_PRIV_KEY_FUNC = unsafe extern "system" fn(hcryptprov: usize, dwkeyspec: u32, pszprivatekeyobjid: super::super::Foundation::PSTR, dwflags: u32, pvauxinfo: *const ::std::ffi::c_void, pprivatekeyinfo: *mut CRYPT_PRIVATE_KEY_INFO, pcbprivatekeyinfo: *mut u32) -> super::super::Foundation::BOOL;
26875 #[cfg(feature = "Win32_Foundation")]
26876 pub type PFN_FREE_ENCODED_OBJECT_FUNC = unsafe extern "system" fn(pszobjectoid: super::super::Foundation::PSTR, pobject: *mut CRYPT_BLOB_ARRAY, pvfreecontext: *mut ::std::ffi::c_void);
26877 #[cfg(feature = "Win32_Foundation")]
26878 pub type PFN_IMPORT_PRIV_KEY_FUNC = unsafe extern "system" fn(hcryptprov: usize, pprivatekeyinfo: *const CRYPT_PRIVATE_KEY_INFO, dwflags: u32, pvauxinfo: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
26879 #[cfg(feature = "Win32_Foundation")]
26880 pub type PFN_IMPORT_PUBLIC_KEY_INFO_EX2_FUNC = unsafe extern "system" fn(dwcertencodingtype: u32, pinfo: *const CERT_PUBLIC_KEY_INFO, dwflags: u32, pvauxinfo: *const ::std::ffi::c_void, phkey: *mut BCRYPT_KEY_HANDLE) -> super::super::Foundation::BOOL;
26881 pub type PFN_NCRYPT_ALLOC = unsafe extern "system" fn(cbsize: usize) -> *mut ::std::ffi::c_void;
26882 pub type PFN_NCRYPT_FREE = unsafe extern "system" fn(pv: *const ::std::ffi::c_void);
26883 #[cfg(feature = "Win32_Foundation")]
26884 #[inline]
PFXExportCertStore<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hstore: *const ::std::ffi::c_void, ppfx: *mut CRYPTOAPI_BLOB, szpassword: Param2, dwflags: u32) -> super::super::Foundation::BOOL26885 pub unsafe fn PFXExportCertStore<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hstore: *const ::std::ffi::c_void, ppfx: *mut CRYPTOAPI_BLOB, szpassword: Param2, dwflags: u32) -> super::super::Foundation::BOOL {
26886     #[cfg(windows)]
26887     {
26888         #[link(name = "windows")]
26889         extern "system" {
26890             fn PFXExportCertStore(hstore: *const ::std::ffi::c_void, ppfx: *mut CRYPTOAPI_BLOB, szpassword: super::super::Foundation::PWSTR, dwflags: u32) -> super::super::Foundation::BOOL;
26891         }
26892         ::std::mem::transmute(PFXExportCertStore(::std::mem::transmute(hstore), ::std::mem::transmute(ppfx), szpassword.into_param().abi(), ::std::mem::transmute(dwflags)))
26893     }
26894     #[cfg(not(windows))]
26895     unimplemented!("Unsupported target OS");
26896 }
26897 #[cfg(feature = "Win32_Foundation")]
26898 #[inline]
PFXExportCertStoreEx<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hstore: *const ::std::ffi::c_void, ppfx: *mut CRYPTOAPI_BLOB, szpassword: Param2, pvpara: *const ::std::ffi::c_void, dwflags: u32) -> super::super::Foundation::BOOL26899 pub unsafe fn PFXExportCertStoreEx<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hstore: *const ::std::ffi::c_void, ppfx: *mut CRYPTOAPI_BLOB, szpassword: Param2, pvpara: *const ::std::ffi::c_void, dwflags: u32) -> super::super::Foundation::BOOL {
26900     #[cfg(windows)]
26901     {
26902         #[link(name = "windows")]
26903         extern "system" {
26904             fn PFXExportCertStoreEx(hstore: *const ::std::ffi::c_void, ppfx: *mut CRYPTOAPI_BLOB, szpassword: super::super::Foundation::PWSTR, pvpara: *const ::std::ffi::c_void, dwflags: u32) -> super::super::Foundation::BOOL;
26905         }
26906         ::std::mem::transmute(PFXExportCertStoreEx(::std::mem::transmute(hstore), ::std::mem::transmute(ppfx), szpassword.into_param().abi(), ::std::mem::transmute(pvpara), ::std::mem::transmute(dwflags)))
26907     }
26908     #[cfg(not(windows))]
26909     unimplemented!("Unsupported target OS");
26910 }
26911 #[cfg(feature = "Win32_Foundation")]
26912 #[inline]
PFXImportCertStore<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(ppfx: *const CRYPTOAPI_BLOB, szpassword: Param1, dwflags: CRYPT_KEY_FLAGS) -> *mut ::std::ffi::c_void26913 pub unsafe fn PFXImportCertStore<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(ppfx: *const CRYPTOAPI_BLOB, szpassword: Param1, dwflags: CRYPT_KEY_FLAGS) -> *mut ::std::ffi::c_void {
26914     #[cfg(windows)]
26915     {
26916         #[link(name = "windows")]
26917         extern "system" {
26918             fn PFXImportCertStore(ppfx: *const CRYPTOAPI_BLOB, szpassword: super::super::Foundation::PWSTR, dwflags: CRYPT_KEY_FLAGS) -> *mut ::std::ffi::c_void;
26919         }
26920         ::std::mem::transmute(PFXImportCertStore(::std::mem::transmute(ppfx), szpassword.into_param().abi(), ::std::mem::transmute(dwflags)))
26921     }
26922     #[cfg(not(windows))]
26923     unimplemented!("Unsupported target OS");
26924 }
26925 #[cfg(feature = "Win32_Foundation")]
26926 #[inline]
PFXIsPFXBlob(ppfx: *const CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL26927 pub unsafe fn PFXIsPFXBlob(ppfx: *const CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL {
26928     #[cfg(windows)]
26929     {
26930         #[link(name = "windows")]
26931         extern "system" {
26932             fn PFXIsPFXBlob(ppfx: *const CRYPTOAPI_BLOB) -> super::super::Foundation::BOOL;
26933         }
26934         ::std::mem::transmute(PFXIsPFXBlob(::std::mem::transmute(ppfx)))
26935     }
26936     #[cfg(not(windows))]
26937     unimplemented!("Unsupported target OS");
26938 }
26939 #[cfg(feature = "Win32_Foundation")]
26940 #[inline]
PFXVerifyPassword<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(ppfx: *const CRYPTOAPI_BLOB, szpassword: Param1, dwflags: u32) -> super::super::Foundation::BOOL26941 pub unsafe fn PFXVerifyPassword<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(ppfx: *const CRYPTOAPI_BLOB, szpassword: Param1, dwflags: u32) -> super::super::Foundation::BOOL {
26942     #[cfg(windows)]
26943     {
26944         #[link(name = "windows")]
26945         extern "system" {
26946             fn PFXVerifyPassword(ppfx: *const CRYPTOAPI_BLOB, szpassword: super::super::Foundation::PWSTR, dwflags: u32) -> super::super::Foundation::BOOL;
26947         }
26948         ::std::mem::transmute(PFXVerifyPassword(::std::mem::transmute(ppfx), szpassword.into_param().abi(), ::std::mem::transmute(dwflags)))
26949     }
26950     #[cfg(not(windows))]
26951     unimplemented!("Unsupported target OS");
26952 }
26953 pub const PKCS12_DISABLE_ENCRYPT_CERTIFICATES: u32 = 256u32;
26954 pub const PKCS12_ENCRYPT_CERTIFICATES: u32 = 512u32;
26955 pub const PKCS12_EXPORT_ECC_CURVE_OID: u32 = 8192u32;
26956 pub const PKCS12_EXPORT_ECC_CURVE_PARAMETERS: u32 = 4096u32;
26957 pub const PKCS12_EXPORT_PBES2_PARAMS: u32 = 128u32;
26958 pub const PKCS12_EXPORT_RESERVED_MASK: u32 = 4294901760u32;
26959 pub const PKCS12_EXPORT_SILENT: u32 = 64u32;
26960 pub const PKCS12_IMPORT_RESERVED_MASK: u32 = 4294901760u32;
26961 pub const PKCS12_IMPORT_SILENT: u32 = 64u32;
26962 pub const PKCS12_ONLY_CERTIFICATES: u32 = 1024u32;
26963 pub const PKCS12_ONLY_CERTIFICATES_PROVIDER_TYPE: u32 = 0u32;
26964 pub const PKCS12_ONLY_NOT_ENCRYPTED_CERTIFICATES: u32 = 2048u32;
26965 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
26966 #[repr(C)]
26967 #[cfg(feature = "Win32_Foundation")]
26968 pub struct PKCS12_PBES2_EXPORT_PARAMS {
26969     pub dwSize: u32,
26970     pub hNcryptDescriptor: *mut ::std::ffi::c_void,
26971     pub pwszPbes2Alg: super::super::Foundation::PWSTR,
26972 }
26973 #[cfg(feature = "Win32_Foundation")]
26974 impl PKCS12_PBES2_EXPORT_PARAMS {}
26975 #[cfg(feature = "Win32_Foundation")]
26976 impl ::std::default::Default for PKCS12_PBES2_EXPORT_PARAMS {
default() -> Self26977     fn default() -> Self {
26978         unsafe { ::std::mem::zeroed() }
26979     }
26980 }
26981 #[cfg(feature = "Win32_Foundation")]
26982 impl ::std::fmt::Debug for PKCS12_PBES2_EXPORT_PARAMS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result26983     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
26984         fmt.debug_struct("PKCS12_PBES2_EXPORT_PARAMS").field("dwSize", &self.dwSize).field("hNcryptDescriptor", &self.hNcryptDescriptor).field("pwszPbes2Alg", &self.pwszPbes2Alg).finish()
26985     }
26986 }
26987 #[cfg(feature = "Win32_Foundation")]
26988 impl ::std::cmp::PartialEq for PKCS12_PBES2_EXPORT_PARAMS {
eq(&self, other: &Self) -> bool26989     fn eq(&self, other: &Self) -> bool {
26990         self.dwSize == other.dwSize && self.hNcryptDescriptor == other.hNcryptDescriptor && self.pwszPbes2Alg == other.pwszPbes2Alg
26991     }
26992 }
26993 #[cfg(feature = "Win32_Foundation")]
26994 impl ::std::cmp::Eq for PKCS12_PBES2_EXPORT_PARAMS {}
26995 #[cfg(feature = "Win32_Foundation")]
26996 unsafe impl ::windows::runtime::Abi for PKCS12_PBES2_EXPORT_PARAMS {
26997     type Abi = Self;
26998     type DefaultType = Self;
26999 }
27000 pub const PKCS12_PROTECT_TO_DOMAIN_SIDS: u32 = 32u32;
27001 pub const PKCS12_VIRTUAL_ISOLATION_KEY: u32 = 65536u32;
27002 pub const PKCS5_PADDING: u32 = 1u32;
27003 pub const PKCS_7_NDR_ENCODING: u32 = 131072u32;
27004 pub const PKCS_RSA_SSA_PSS_TRAILER_FIELD_BC: u32 = 1u32;
27005 pub const PLAINTEXTKEYBLOB: u32 = 8u32;
27006 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
27007 #[repr(C)]
27008 #[cfg(feature = "Win32_Foundation")]
27009 pub struct POLICY_ELEMENT {
27010     pub targetEndpointAddress: super::super::Foundation::PWSTR,
27011     pub issuerEndpointAddress: super::super::Foundation::PWSTR,
27012     pub issuedTokenParameters: super::super::Foundation::PWSTR,
27013     pub privacyNoticeLink: super::super::Foundation::PWSTR,
27014     pub privacyNoticeVersion: u32,
27015     pub useManagedPresentation: super::super::Foundation::BOOL,
27016 }
27017 #[cfg(feature = "Win32_Foundation")]
27018 impl POLICY_ELEMENT {}
27019 #[cfg(feature = "Win32_Foundation")]
27020 impl ::std::default::Default for POLICY_ELEMENT {
default() -> Self27021     fn default() -> Self {
27022         unsafe { ::std::mem::zeroed() }
27023     }
27024 }
27025 #[cfg(feature = "Win32_Foundation")]
27026 impl ::std::fmt::Debug for POLICY_ELEMENT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result27027     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
27028         fmt.debug_struct("POLICY_ELEMENT")
27029             .field("targetEndpointAddress", &self.targetEndpointAddress)
27030             .field("issuerEndpointAddress", &self.issuerEndpointAddress)
27031             .field("issuedTokenParameters", &self.issuedTokenParameters)
27032             .field("privacyNoticeLink", &self.privacyNoticeLink)
27033             .field("privacyNoticeVersion", &self.privacyNoticeVersion)
27034             .field("useManagedPresentation", &self.useManagedPresentation)
27035             .finish()
27036     }
27037 }
27038 #[cfg(feature = "Win32_Foundation")]
27039 impl ::std::cmp::PartialEq for POLICY_ELEMENT {
eq(&self, other: &Self) -> bool27040     fn eq(&self, other: &Self) -> bool {
27041         self.targetEndpointAddress == other.targetEndpointAddress && self.issuerEndpointAddress == other.issuerEndpointAddress && self.issuedTokenParameters == other.issuedTokenParameters && self.privacyNoticeLink == other.privacyNoticeLink && self.privacyNoticeVersion == other.privacyNoticeVersion && self.useManagedPresentation == other.useManagedPresentation
27042     }
27043 }
27044 #[cfg(feature = "Win32_Foundation")]
27045 impl ::std::cmp::Eq for POLICY_ELEMENT {}
27046 #[cfg(feature = "Win32_Foundation")]
27047 unsafe impl ::windows::runtime::Abi for POLICY_ELEMENT {
27048     type Abi = Self;
27049     type DefaultType = Self;
27050 }
27051 pub const POLICY_IGNORE_NON_CRITICAL_BC: u32 = 1u32;
27052 pub const PP_ADMIN_PIN: u32 = 31u32;
27053 pub const PP_APPLI_CERT: u32 = 18u32;
27054 pub const PP_CERTCHAIN: u32 = 9u32;
27055 pub const PP_CHANGE_PASSWORD: u32 = 7u32;
27056 pub const PP_CONTAINER: u32 = 6u32;
27057 pub const PP_CONTEXT_INFO: u32 = 11u32;
27058 pub const PP_CRYPT_COUNT_KEY_USE: u32 = 41u32;
27059 pub const PP_DISMISS_PIN_UI_SEC: u32 = 49u32;
27060 pub const PP_ENUMALGS: u32 = 1u32;
27061 pub const PP_ENUMALGS_EX: u32 = 22u32;
27062 pub const PP_ENUMCONTAINERS: u32 = 2u32;
27063 pub const PP_ENUMELECTROOTS: u32 = 26u32;
27064 pub const PP_ENUMEX_SIGNING_PROT: u32 = 40u32;
27065 pub const PP_ENUMMANDROOTS: u32 = 25u32;
27066 pub const PP_IMPTYPE: u32 = 3u32;
27067 pub const PP_KEYSET_TYPE: u32 = 27u32;
27068 pub const PP_KEYSPEC: u32 = 39u32;
27069 pub const PP_KEYSTORAGE: u32 = 17u32;
27070 pub const PP_KEYX_KEYSIZE_INC: u32 = 35u32;
27071 pub const PP_KEY_TYPE_SUBTYPE: u32 = 10u32;
27072 pub const PP_NAME: u32 = 4u32;
27073 pub const PP_PROVTYPE: u32 = 16u32;
27074 pub const PP_SESSION_KEYSIZE: u32 = 20u32;
27075 pub const PP_SGC_INFO: u32 = 37u32;
27076 pub const PP_SIG_KEYSIZE_INC: u32 = 34u32;
27077 pub const PP_SMARTCARD_GUID: u32 = 45u32;
27078 pub const PP_SMARTCARD_READER_ICON: u32 = 47u32;
27079 pub const PP_SYM_KEYSIZE: u32 = 19u32;
27080 pub const PP_UNIQUE_CONTAINER: u32 = 36u32;
27081 pub const PP_VERSION: u32 = 5u32;
27082 pub const PRIVATEKEYBLOB: u32 = 7u32;
27083 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
27084 #[repr(C)]
27085 pub struct PRIVKEYVER3 {
27086     pub magic: u32,
27087     pub bitlenP: u32,
27088     pub bitlenQ: u32,
27089     pub bitlenJ: u32,
27090     pub bitlenX: u32,
27091     pub DSSSeed: DSSSEED,
27092 }
27093 impl PRIVKEYVER3 {}
27094 impl ::std::default::Default for PRIVKEYVER3 {
default() -> Self27095     fn default() -> Self {
27096         unsafe { ::std::mem::zeroed() }
27097     }
27098 }
27099 impl ::std::fmt::Debug for PRIVKEYVER3 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result27100     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
27101         fmt.debug_struct("PRIVKEYVER3").field("magic", &self.magic).field("bitlenP", &self.bitlenP).field("bitlenQ", &self.bitlenQ).field("bitlenJ", &self.bitlenJ).field("bitlenX", &self.bitlenX).field("DSSSeed", &self.DSSSeed).finish()
27102     }
27103 }
27104 impl ::std::cmp::PartialEq for PRIVKEYVER3 {
eq(&self, other: &Self) -> bool27105     fn eq(&self, other: &Self) -> bool {
27106         self.magic == other.magic && self.bitlenP == other.bitlenP && self.bitlenQ == other.bitlenQ && self.bitlenJ == other.bitlenJ && self.bitlenX == other.bitlenX && self.DSSSeed == other.DSSSeed
27107     }
27108 }
27109 impl ::std::cmp::Eq for PRIVKEYVER3 {}
27110 unsafe impl ::windows::runtime::Abi for PRIVKEYVER3 {
27111     type Abi = Self;
27112     type DefaultType = Self;
27113 }
27114 pub const PROV_DH_SCHANNEL: u32 = 18u32;
27115 pub const PROV_DSS: u32 = 3u32;
27116 pub const PROV_DSS_DH: u32 = 13u32;
27117 pub const PROV_EC_ECDSA_FULL: u32 = 16u32;
27118 pub const PROV_EC_ECDSA_SIG: u32 = 14u32;
27119 pub const PROV_EC_ECNRA_FULL: u32 = 17u32;
27120 pub const PROV_EC_ECNRA_SIG: u32 = 15u32;
27121 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
27122 #[repr(C)]
27123 #[cfg(feature = "Win32_Foundation")]
27124 pub struct PROV_ENUMALGS {
27125     pub aiAlgid: u32,
27126     pub dwBitLen: u32,
27127     pub dwNameLen: u32,
27128     pub szName: [super::super::Foundation::CHAR; 20],
27129 }
27130 #[cfg(feature = "Win32_Foundation")]
27131 impl PROV_ENUMALGS {}
27132 #[cfg(feature = "Win32_Foundation")]
27133 impl ::std::default::Default for PROV_ENUMALGS {
default() -> Self27134     fn default() -> Self {
27135         unsafe { ::std::mem::zeroed() }
27136     }
27137 }
27138 #[cfg(feature = "Win32_Foundation")]
27139 impl ::std::fmt::Debug for PROV_ENUMALGS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result27140     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
27141         fmt.debug_struct("PROV_ENUMALGS").field("aiAlgid", &self.aiAlgid).field("dwBitLen", &self.dwBitLen).field("dwNameLen", &self.dwNameLen).field("szName", &self.szName).finish()
27142     }
27143 }
27144 #[cfg(feature = "Win32_Foundation")]
27145 impl ::std::cmp::PartialEq for PROV_ENUMALGS {
eq(&self, other: &Self) -> bool27146     fn eq(&self, other: &Self) -> bool {
27147         self.aiAlgid == other.aiAlgid && self.dwBitLen == other.dwBitLen && self.dwNameLen == other.dwNameLen && self.szName == other.szName
27148     }
27149 }
27150 #[cfg(feature = "Win32_Foundation")]
27151 impl ::std::cmp::Eq for PROV_ENUMALGS {}
27152 #[cfg(feature = "Win32_Foundation")]
27153 unsafe impl ::windows::runtime::Abi for PROV_ENUMALGS {
27154     type Abi = Self;
27155     type DefaultType = Self;
27156 }
27157 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
27158 #[repr(C)]
27159 #[cfg(feature = "Win32_Foundation")]
27160 pub struct PROV_ENUMALGS_EX {
27161     pub aiAlgid: u32,
27162     pub dwDefaultLen: u32,
27163     pub dwMinLen: u32,
27164     pub dwMaxLen: u32,
27165     pub dwProtocols: u32,
27166     pub dwNameLen: u32,
27167     pub szName: [super::super::Foundation::CHAR; 20],
27168     pub dwLongNameLen: u32,
27169     pub szLongName: [super::super::Foundation::CHAR; 40],
27170 }
27171 #[cfg(feature = "Win32_Foundation")]
27172 impl PROV_ENUMALGS_EX {}
27173 #[cfg(feature = "Win32_Foundation")]
27174 impl ::std::default::Default for PROV_ENUMALGS_EX {
default() -> Self27175     fn default() -> Self {
27176         unsafe { ::std::mem::zeroed() }
27177     }
27178 }
27179 #[cfg(feature = "Win32_Foundation")]
27180 impl ::std::fmt::Debug for PROV_ENUMALGS_EX {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result27181     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
27182         fmt.debug_struct("PROV_ENUMALGS_EX")
27183             .field("aiAlgid", &self.aiAlgid)
27184             .field("dwDefaultLen", &self.dwDefaultLen)
27185             .field("dwMinLen", &self.dwMinLen)
27186             .field("dwMaxLen", &self.dwMaxLen)
27187             .field("dwProtocols", &self.dwProtocols)
27188             .field("dwNameLen", &self.dwNameLen)
27189             .field("szName", &self.szName)
27190             .field("dwLongNameLen", &self.dwLongNameLen)
27191             .field("szLongName", &self.szLongName)
27192             .finish()
27193     }
27194 }
27195 #[cfg(feature = "Win32_Foundation")]
27196 impl ::std::cmp::PartialEq for PROV_ENUMALGS_EX {
eq(&self, other: &Self) -> bool27197     fn eq(&self, other: &Self) -> bool {
27198         self.aiAlgid == other.aiAlgid && self.dwDefaultLen == other.dwDefaultLen && self.dwMinLen == other.dwMinLen && self.dwMaxLen == other.dwMaxLen && self.dwProtocols == other.dwProtocols && self.dwNameLen == other.dwNameLen && self.szName == other.szName && self.dwLongNameLen == other.dwLongNameLen && self.szLongName == other.szLongName
27199     }
27200 }
27201 #[cfg(feature = "Win32_Foundation")]
27202 impl ::std::cmp::Eq for PROV_ENUMALGS_EX {}
27203 #[cfg(feature = "Win32_Foundation")]
27204 unsafe impl ::windows::runtime::Abi for PROV_ENUMALGS_EX {
27205     type Abi = Self;
27206     type DefaultType = Self;
27207 }
27208 pub const PROV_FORTEZZA: u32 = 4u32;
27209 pub const PROV_INTEL_SEC: u32 = 22u32;
27210 pub const PROV_MS_EXCHANGE: u32 = 5u32;
27211 pub const PROV_REPLACE_OWF: u32 = 23u32;
27212 pub const PROV_RNG: u32 = 21u32;
27213 pub const PROV_RSA_AES: u32 = 24u32;
27214 pub const PROV_RSA_FULL: u32 = 1u32;
27215 pub const PROV_RSA_SCHANNEL: u32 = 12u32;
27216 pub const PROV_RSA_SIG: u32 = 2u32;
27217 pub const PROV_SPYRUS_LYNKS: u32 = 20u32;
27218 pub const PROV_SSL: u32 = 6u32;
27219 pub const PROV_STT_ACQ: u32 = 8u32;
27220 pub const PROV_STT_BRND: u32 = 9u32;
27221 pub const PROV_STT_ISS: u32 = 11u32;
27222 pub const PROV_STT_MER: u32 = 7u32;
27223 pub const PROV_STT_ROOT: u32 = 10u32;
27224 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
27225 #[repr(C)]
27226 pub struct PUBKEY {
27227     pub magic: u32,
27228     pub bitlen: u32,
27229 }
27230 impl PUBKEY {}
27231 impl ::std::default::Default for PUBKEY {
default() -> Self27232     fn default() -> Self {
27233         unsafe { ::std::mem::zeroed() }
27234     }
27235 }
27236 impl ::std::fmt::Debug for PUBKEY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result27237     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
27238         fmt.debug_struct("PUBKEY").field("magic", &self.magic).field("bitlen", &self.bitlen).finish()
27239     }
27240 }
27241 impl ::std::cmp::PartialEq for PUBKEY {
eq(&self, other: &Self) -> bool27242     fn eq(&self, other: &Self) -> bool {
27243         self.magic == other.magic && self.bitlen == other.bitlen
27244     }
27245 }
27246 impl ::std::cmp::Eq for PUBKEY {}
27247 unsafe impl ::windows::runtime::Abi for PUBKEY {
27248     type Abi = Self;
27249     type DefaultType = Self;
27250 }
27251 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
27252 #[repr(C)]
27253 pub struct PUBKEYVER3 {
27254     pub magic: u32,
27255     pub bitlenP: u32,
27256     pub bitlenQ: u32,
27257     pub bitlenJ: u32,
27258     pub DSSSeed: DSSSEED,
27259 }
27260 impl PUBKEYVER3 {}
27261 impl ::std::default::Default for PUBKEYVER3 {
default() -> Self27262     fn default() -> Self {
27263         unsafe { ::std::mem::zeroed() }
27264     }
27265 }
27266 impl ::std::fmt::Debug for PUBKEYVER3 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result27267     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
27268         fmt.debug_struct("PUBKEYVER3").field("magic", &self.magic).field("bitlenP", &self.bitlenP).field("bitlenQ", &self.bitlenQ).field("bitlenJ", &self.bitlenJ).field("DSSSeed", &self.DSSSeed).finish()
27269     }
27270 }
27271 impl ::std::cmp::PartialEq for PUBKEYVER3 {
eq(&self, other: &Self) -> bool27272     fn eq(&self, other: &Self) -> bool {
27273         self.magic == other.magic && self.bitlenP == other.bitlenP && self.bitlenQ == other.bitlenQ && self.bitlenJ == other.bitlenJ && self.DSSSeed == other.DSSSeed
27274     }
27275 }
27276 impl ::std::cmp::Eq for PUBKEYVER3 {}
27277 unsafe impl ::windows::runtime::Abi for PUBKEYVER3 {
27278     type Abi = Self;
27279     type DefaultType = Self;
27280 }
27281 pub const PUBLICKEYBLOB: u32 = 6u32;
27282 pub const PUBLICKEYBLOBEX: u32 = 10u32;
27283 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
27284 #[repr(C)]
27285 pub struct PUBLICKEYSTRUC {
27286     pub bType: u8,
27287     pub bVersion: u8,
27288     pub reserved: u16,
27289     pub aiKeyAlg: u32,
27290 }
27291 impl PUBLICKEYSTRUC {}
27292 impl ::std::default::Default for PUBLICKEYSTRUC {
default() -> Self27293     fn default() -> Self {
27294         unsafe { ::std::mem::zeroed() }
27295     }
27296 }
27297 impl ::std::fmt::Debug for PUBLICKEYSTRUC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result27298     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
27299         fmt.debug_struct("PUBLICKEYSTRUC").field("bType", &self.bType).field("bVersion", &self.bVersion).field("reserved", &self.reserved).field("aiKeyAlg", &self.aiKeyAlg).finish()
27300     }
27301 }
27302 impl ::std::cmp::PartialEq for PUBLICKEYSTRUC {
eq(&self, other: &Self) -> bool27303     fn eq(&self, other: &Self) -> bool {
27304         self.bType == other.bType && self.bVersion == other.bVersion && self.reserved == other.reserved && self.aiKeyAlg == other.aiKeyAlg
27305     }
27306 }
27307 impl ::std::cmp::Eq for PUBLICKEYSTRUC {}
27308 unsafe impl ::windows::runtime::Abi for PUBLICKEYSTRUC {
27309     type Abi = Self;
27310     type DefaultType = Self;
27311 }
27312 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
27313 #[repr(transparent)]
27314 pub struct PaddingMode(pub i32);
27315 impl PaddingMode {
27316     pub const None: PaddingMode = PaddingMode(1i32);
27317     pub const PKCS7: PaddingMode = PaddingMode(2i32);
27318     pub const Zeros: PaddingMode = PaddingMode(3i32);
27319     pub const ANSIX923: PaddingMode = PaddingMode(4i32);
27320     pub const ISO10126: PaddingMode = PaddingMode(5i32);
27321 }
27322 impl ::std::convert::From<i32> for PaddingMode {
from(value: i32) -> Self27323     fn from(value: i32) -> Self {
27324         Self(value)
27325     }
27326 }
27327 unsafe impl ::windows::runtime::Abi for PaddingMode {
27328     type Abi = Self;
27329     type DefaultType = Self;
27330 }
27331 pub const RANDOM_PADDING: u32 = 2u32;
27332 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
27333 #[repr(C)]
27334 #[cfg(feature = "Win32_Foundation")]
27335 pub struct RECIPIENTPOLICY {
27336     pub recipient: ENDPOINTADDRESS,
27337     pub issuer: ENDPOINTADDRESS,
27338     pub tokenType: super::super::Foundation::PWSTR,
27339     pub requiredClaims: CLAIMLIST,
27340     pub optionalClaims: CLAIMLIST,
27341     pub privacyUrl: super::super::Foundation::PWSTR,
27342     pub privacyVersion: u32,
27343 }
27344 #[cfg(feature = "Win32_Foundation")]
27345 impl RECIPIENTPOLICY {}
27346 #[cfg(feature = "Win32_Foundation")]
27347 impl ::std::default::Default for RECIPIENTPOLICY {
default() -> Self27348     fn default() -> Self {
27349         unsafe { ::std::mem::zeroed() }
27350     }
27351 }
27352 #[cfg(feature = "Win32_Foundation")]
27353 impl ::std::fmt::Debug for RECIPIENTPOLICY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result27354     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
27355         fmt.debug_struct("RECIPIENTPOLICY")
27356             .field("recipient", &self.recipient)
27357             .field("issuer", &self.issuer)
27358             .field("tokenType", &self.tokenType)
27359             .field("requiredClaims", &self.requiredClaims)
27360             .field("optionalClaims", &self.optionalClaims)
27361             .field("privacyUrl", &self.privacyUrl)
27362             .field("privacyVersion", &self.privacyVersion)
27363             .finish()
27364     }
27365 }
27366 #[cfg(feature = "Win32_Foundation")]
27367 impl ::std::cmp::PartialEq for RECIPIENTPOLICY {
eq(&self, other: &Self) -> bool27368     fn eq(&self, other: &Self) -> bool {
27369         self.recipient == other.recipient && self.issuer == other.issuer && self.tokenType == other.tokenType && self.requiredClaims == other.requiredClaims && self.optionalClaims == other.optionalClaims && self.privacyUrl == other.privacyUrl && self.privacyVersion == other.privacyVersion
27370     }
27371 }
27372 #[cfg(feature = "Win32_Foundation")]
27373 impl ::std::cmp::Eq for RECIPIENTPOLICY {}
27374 #[cfg(feature = "Win32_Foundation")]
27375 unsafe impl ::windows::runtime::Abi for RECIPIENTPOLICY {
27376     type Abi = Self;
27377     type DefaultType = Self;
27378 }
27379 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
27380 #[repr(C)]
27381 #[cfg(feature = "Win32_Foundation")]
27382 pub struct RECIPIENTPOLICY2 {
27383     pub recipient: ENDPOINTADDRESS2,
27384     pub issuer: ENDPOINTADDRESS2,
27385     pub tokenType: super::super::Foundation::PWSTR,
27386     pub requiredClaims: CLAIMLIST,
27387     pub optionalClaims: CLAIMLIST,
27388     pub privacyUrl: super::super::Foundation::PWSTR,
27389     pub privacyVersion: u32,
27390 }
27391 #[cfg(feature = "Win32_Foundation")]
27392 impl RECIPIENTPOLICY2 {}
27393 #[cfg(feature = "Win32_Foundation")]
27394 impl ::std::default::Default for RECIPIENTPOLICY2 {
default() -> Self27395     fn default() -> Self {
27396         unsafe { ::std::mem::zeroed() }
27397     }
27398 }
27399 #[cfg(feature = "Win32_Foundation")]
27400 impl ::std::fmt::Debug for RECIPIENTPOLICY2 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result27401     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
27402         fmt.debug_struct("RECIPIENTPOLICY2")
27403             .field("recipient", &self.recipient)
27404             .field("issuer", &self.issuer)
27405             .field("tokenType", &self.tokenType)
27406             .field("requiredClaims", &self.requiredClaims)
27407             .field("optionalClaims", &self.optionalClaims)
27408             .field("privacyUrl", &self.privacyUrl)
27409             .field("privacyVersion", &self.privacyVersion)
27410             .finish()
27411     }
27412 }
27413 #[cfg(feature = "Win32_Foundation")]
27414 impl ::std::cmp::PartialEq for RECIPIENTPOLICY2 {
eq(&self, other: &Self) -> bool27415     fn eq(&self, other: &Self) -> bool {
27416         self.recipient == other.recipient && self.issuer == other.issuer && self.tokenType == other.tokenType && self.requiredClaims == other.requiredClaims && self.optionalClaims == other.optionalClaims && self.privacyUrl == other.privacyUrl && self.privacyVersion == other.privacyVersion
27417     }
27418 }
27419 #[cfg(feature = "Win32_Foundation")]
27420 impl ::std::cmp::Eq for RECIPIENTPOLICY2 {}
27421 #[cfg(feature = "Win32_Foundation")]
27422 unsafe impl ::windows::runtime::Abi for RECIPIENTPOLICY2 {
27423     type Abi = Self;
27424     type DefaultType = Self;
27425 }
27426 pub const RECIPIENTPOLICYV1: u32 = 1u32;
27427 pub const RECIPIENTPOLICYV2: u32 = 2u32;
27428 pub const REPORT_NOT_ABLE_TO_EXPORT_PRIVATE_KEY: u32 = 2u32;
27429 pub const REPORT_NO_PRIVATE_KEY: u32 = 1u32;
27430 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
27431 #[repr(C)]
27432 pub struct ROOT_INFO_LUID {
27433     pub LowPart: u32,
27434     pub HighPart: i32,
27435 }
27436 impl ROOT_INFO_LUID {}
27437 impl ::std::default::Default for ROOT_INFO_LUID {
default() -> Self27438     fn default() -> Self {
27439         unsafe { ::std::mem::zeroed() }
27440     }
27441 }
27442 impl ::std::fmt::Debug for ROOT_INFO_LUID {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result27443     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
27444         fmt.debug_struct("ROOT_INFO_LUID").field("LowPart", &self.LowPart).field("HighPart", &self.HighPart).finish()
27445     }
27446 }
27447 impl ::std::cmp::PartialEq for ROOT_INFO_LUID {
eq(&self, other: &Self) -> bool27448     fn eq(&self, other: &Self) -> bool {
27449         self.LowPart == other.LowPart && self.HighPart == other.HighPart
27450     }
27451 }
27452 impl ::std::cmp::Eq for ROOT_INFO_LUID {}
27453 unsafe impl ::windows::runtime::Abi for ROOT_INFO_LUID {
27454     type Abi = Self;
27455     type DefaultType = Self;
27456 }
27457 pub const RSA1024BIT_KEY: u32 = 67108864u32;
27458 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
27459 #[repr(C)]
27460 pub struct RSAPUBKEY {
27461     pub magic: u32,
27462     pub bitlen: u32,
27463     pub pubexp: u32,
27464 }
27465 impl RSAPUBKEY {}
27466 impl ::std::default::Default for RSAPUBKEY {
default() -> Self27467     fn default() -> Self {
27468         unsafe { ::std::mem::zeroed() }
27469     }
27470 }
27471 impl ::std::fmt::Debug for RSAPUBKEY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result27472     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
27473         fmt.debug_struct("RSAPUBKEY").field("magic", &self.magic).field("bitlen", &self.bitlen).field("pubexp", &self.pubexp).finish()
27474     }
27475 }
27476 impl ::std::cmp::PartialEq for RSAPUBKEY {
eq(&self, other: &Self) -> bool27477     fn eq(&self, other: &Self) -> bool {
27478         self.magic == other.magic && self.bitlen == other.bitlen && self.pubexp == other.pubexp
27479     }
27480 }
27481 impl ::std::cmp::Eq for RSAPUBKEY {}
27482 unsafe impl ::windows::runtime::Abi for RSAPUBKEY {
27483     type Abi = Self;
27484     type DefaultType = Self;
27485 }
27486 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
27487 #[repr(C)]
27488 pub struct SCHANNEL_ALG {
27489     pub dwUse: u32,
27490     pub Algid: u32,
27491     pub cBits: u32,
27492     pub dwFlags: u32,
27493     pub dwReserved: u32,
27494 }
27495 impl SCHANNEL_ALG {}
27496 impl ::std::default::Default for SCHANNEL_ALG {
default() -> Self27497     fn default() -> Self {
27498         unsafe { ::std::mem::zeroed() }
27499     }
27500 }
27501 impl ::std::fmt::Debug for SCHANNEL_ALG {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result27502     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
27503         fmt.debug_struct("SCHANNEL_ALG").field("dwUse", &self.dwUse).field("Algid", &self.Algid).field("cBits", &self.cBits).field("dwFlags", &self.dwFlags).field("dwReserved", &self.dwReserved).finish()
27504     }
27505 }
27506 impl ::std::cmp::PartialEq for SCHANNEL_ALG {
eq(&self, other: &Self) -> bool27507     fn eq(&self, other: &Self) -> bool {
27508         self.dwUse == other.dwUse && self.Algid == other.Algid && self.cBits == other.cBits && self.dwFlags == other.dwFlags && self.dwReserved == other.dwReserved
27509     }
27510 }
27511 impl ::std::cmp::Eq for SCHANNEL_ALG {}
27512 unsafe impl ::windows::runtime::Abi for SCHANNEL_ALG {
27513     type Abi = Self;
27514     type DefaultType = Self;
27515 }
27516 pub const SCHANNEL_ENC_KEY: u32 = 1u32;
27517 pub const SCHANNEL_MAC_KEY: u32 = 0u32;
27518 pub const SELCERT_ALGORITHM: u32 = 105u32;
27519 pub const SELCERT_CERTLIST: u32 = 102u32;
27520 pub const SELCERT_FINEPRINT: u32 = 101u32;
27521 pub const SELCERT_ISSUED_TO: u32 = 103u32;
27522 pub const SELCERT_PROPERTIES: u32 = 100u32;
27523 pub const SELCERT_SERIAL_NUM: u32 = 106u32;
27524 pub const SELCERT_THUMBPRINT: u32 = 107u32;
27525 pub const SELCERT_VALIDITY: u32 = 104u32;
27526 pub const SIGNATURE_RESOURCE_NUMBER: u32 = 666u32;
27527 pub const SIMPLEBLOB: u32 = 1u32;
27528 pub const SITE_PIN_RULES_ALL_SUBDOMAINS_FLAG: u32 = 1u32;
27529 pub const SORTED_CTL_EXT_HASHED_SUBJECT_IDENTIFIER_FLAG: u32 = 1u32;
27530 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
27531 #[repr(C)]
27532 pub struct SSL_ECCKEY_BLOB {
27533     pub dwCurveType: u32,
27534     pub cbKey: u32,
27535 }
27536 impl SSL_ECCKEY_BLOB {}
27537 impl ::std::default::Default for SSL_ECCKEY_BLOB {
default() -> Self27538     fn default() -> Self {
27539         unsafe { ::std::mem::zeroed() }
27540     }
27541 }
27542 impl ::std::fmt::Debug for SSL_ECCKEY_BLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result27543     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
27544         fmt.debug_struct("SSL_ECCKEY_BLOB").field("dwCurveType", &self.dwCurveType).field("cbKey", &self.cbKey).finish()
27545     }
27546 }
27547 impl ::std::cmp::PartialEq for SSL_ECCKEY_BLOB {
eq(&self, other: &Self) -> bool27548     fn eq(&self, other: &Self) -> bool {
27549         self.dwCurveType == other.dwCurveType && self.cbKey == other.cbKey
27550     }
27551 }
27552 impl ::std::cmp::Eq for SSL_ECCKEY_BLOB {}
27553 unsafe impl ::windows::runtime::Abi for SSL_ECCKEY_BLOB {
27554     type Abi = Self;
27555     type DefaultType = Self;
27556 }
27557 pub const SSL_F12_ERROR_TEXT_LENGTH: u32 = 256u32;
27558 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
27559 #[repr(C)]
27560 pub struct SSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUS {
27561     pub cbSize: u32,
27562     pub dwErrorLevel: u32,
27563     pub dwErrorCategory: u32,
27564     pub dwReserved: u32,
27565     pub wszErrorText: [u16; 256],
27566 }
27567 impl SSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUS {}
27568 impl ::std::default::Default for SSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUS {
default() -> Self27569     fn default() -> Self {
27570         unsafe { ::std::mem::zeroed() }
27571     }
27572 }
27573 impl ::std::fmt::Debug for SSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result27574     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
27575         fmt.debug_struct("SSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUS").field("cbSize", &self.cbSize).field("dwErrorLevel", &self.dwErrorLevel).field("dwErrorCategory", &self.dwErrorCategory).field("dwReserved", &self.dwReserved).field("wszErrorText", &self.wszErrorText).finish()
27576     }
27577 }
27578 impl ::std::cmp::PartialEq for SSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUS {
eq(&self, other: &Self) -> bool27579     fn eq(&self, other: &Self) -> bool {
27580         self.cbSize == other.cbSize && self.dwErrorLevel == other.dwErrorLevel && self.dwErrorCategory == other.dwErrorCategory && self.dwReserved == other.dwReserved && self.wszErrorText == other.wszErrorText
27581     }
27582 }
27583 impl ::std::cmp::Eq for SSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUS {}
27584 unsafe impl ::windows::runtime::Abi for SSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUS {
27585     type Abi = Self;
27586     type DefaultType = Self;
27587 }
27588 pub const SSL_HPKP_HEADER_COUNT: u32 = 2u32;
27589 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
27590 #[repr(C)]
27591 #[cfg(feature = "Win32_Foundation")]
27592 pub struct SSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARA {
27593     pub cbSize: u32,
27594     pub dwReserved: u32,
27595     pub pwszServerName: super::super::Foundation::PWSTR,
27596     pub rgpszHpkpValue: [super::super::Foundation::PSTR; 2],
27597 }
27598 #[cfg(feature = "Win32_Foundation")]
27599 impl SSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARA {}
27600 #[cfg(feature = "Win32_Foundation")]
27601 impl ::std::default::Default for SSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARA {
default() -> Self27602     fn default() -> Self {
27603         unsafe { ::std::mem::zeroed() }
27604     }
27605 }
27606 #[cfg(feature = "Win32_Foundation")]
27607 impl ::std::fmt::Debug for SSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result27608     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
27609         fmt.debug_struct("SSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARA").field("cbSize", &self.cbSize).field("dwReserved", &self.dwReserved).field("pwszServerName", &self.pwszServerName).field("rgpszHpkpValue", &self.rgpszHpkpValue).finish()
27610     }
27611 }
27612 #[cfg(feature = "Win32_Foundation")]
27613 impl ::std::cmp::PartialEq for SSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARA {
eq(&self, other: &Self) -> bool27614     fn eq(&self, other: &Self) -> bool {
27615         self.cbSize == other.cbSize && self.dwReserved == other.dwReserved && self.pwszServerName == other.pwszServerName && self.rgpszHpkpValue == other.rgpszHpkpValue
27616     }
27617 }
27618 #[cfg(feature = "Win32_Foundation")]
27619 impl ::std::cmp::Eq for SSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARA {}
27620 #[cfg(feature = "Win32_Foundation")]
27621 unsafe impl ::windows::runtime::Abi for SSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARA {
27622     type Abi = Self;
27623     type DefaultType = Self;
27624 }
27625 pub const SSL_HPKP_PKP_HEADER_INDEX: u32 = 0u32;
27626 pub const SSL_HPKP_PKP_RO_HEADER_INDEX: u32 = 1u32;
27627 pub const SSL_KEY_PIN_ERROR_TEXT_LENGTH: u32 = 512u32;
27628 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
27629 #[repr(C)]
27630 #[cfg(feature = "Win32_Foundation")]
27631 pub struct SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARA {
27632     pub cbSize: u32,
27633     pub dwReserved: u32,
27634     pub pwszServerName: super::super::Foundation::PWSTR,
27635 }
27636 #[cfg(feature = "Win32_Foundation")]
27637 impl SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARA {}
27638 #[cfg(feature = "Win32_Foundation")]
27639 impl ::std::default::Default for SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARA {
default() -> Self27640     fn default() -> Self {
27641         unsafe { ::std::mem::zeroed() }
27642     }
27643 }
27644 #[cfg(feature = "Win32_Foundation")]
27645 impl ::std::fmt::Debug for SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result27646     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
27647         fmt.debug_struct("SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARA").field("cbSize", &self.cbSize).field("dwReserved", &self.dwReserved).field("pwszServerName", &self.pwszServerName).finish()
27648     }
27649 }
27650 #[cfg(feature = "Win32_Foundation")]
27651 impl ::std::cmp::PartialEq for SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARA {
eq(&self, other: &Self) -> bool27652     fn eq(&self, other: &Self) -> bool {
27653         self.cbSize == other.cbSize && self.dwReserved == other.dwReserved && self.pwszServerName == other.pwszServerName
27654     }
27655 }
27656 #[cfg(feature = "Win32_Foundation")]
27657 impl ::std::cmp::Eq for SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARA {}
27658 #[cfg(feature = "Win32_Foundation")]
27659 unsafe impl ::windows::runtime::Abi for SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARA {
27660     type Abi = Self;
27661     type DefaultType = Self;
27662 }
27663 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
27664 #[repr(C)]
27665 pub struct SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUS {
27666     pub cbSize: u32,
27667     pub lError: i32,
27668     pub wszErrorText: [u16; 512],
27669 }
27670 impl SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUS {}
27671 impl ::std::default::Default for SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUS {
default() -> Self27672     fn default() -> Self {
27673         unsafe { ::std::mem::zeroed() }
27674     }
27675 }
27676 impl ::std::fmt::Debug for SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result27677     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
27678         fmt.debug_struct("SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUS").field("cbSize", &self.cbSize).field("lError", &self.lError).field("wszErrorText", &self.wszErrorText).finish()
27679     }
27680 }
27681 impl ::std::cmp::PartialEq for SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUS {
eq(&self, other: &Self) -> bool27682     fn eq(&self, other: &Self) -> bool {
27683         self.cbSize == other.cbSize && self.lError == other.lError && self.wszErrorText == other.wszErrorText
27684     }
27685 }
27686 impl ::std::cmp::Eq for SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUS {}
27687 unsafe impl ::windows::runtime::Abi for SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUS {
27688     type Abi = Self;
27689     type DefaultType = Self;
27690 }
27691 pub const SYMMETRICWRAPKEYBLOB: u32 = 11u32;
27692 #[cfg(feature = "Win32_Foundation")]
27693 #[inline]
SignHash<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cbhash: u32, phash: *const u8, hashalgoid: Param3, pcbsig: *mut u32, ppsig: *mut *mut u8) -> ::windows::runtime::Result<()>27694 pub unsafe fn SignHash<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cbhash: u32, phash: *const u8, hashalgoid: Param3, pcbsig: *mut u32, ppsig: *mut *mut u8) -> ::windows::runtime::Result<()> {
27695     #[cfg(windows)]
27696     {
27697         #[link(name = "windows")]
27698         extern "system" {
27699             fn SignHash(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cbhash: u32, phash: *const u8, hashalgoid: super::super::Foundation::PWSTR, pcbsig: *mut u32, ppsig: *mut *mut u8) -> ::windows::runtime::HRESULT;
27700         }
27701         SignHash(::std::mem::transmute(hcrypto), ::std::mem::transmute(cbhash), ::std::mem::transmute(phash), hashalgoid.into_param().abi(), ::std::mem::transmute(pcbsig), ::std::mem::transmute(ppsig)).ok()
27702     }
27703     #[cfg(not(windows))]
27704     unimplemented!("Unsupported target OS");
27705 }
27706 pub const TIMESTAMP_DONT_HASH_DATA: u32 = 1u32;
27707 pub const TIMESTAMP_FAILURE_BAD_ALG: u32 = 0u32;
27708 pub const TIMESTAMP_FAILURE_BAD_FORMAT: u32 = 5u32;
27709 pub const TIMESTAMP_FAILURE_BAD_REQUEST: u32 = 2u32;
27710 pub const TIMESTAMP_FAILURE_EXTENSION_NOT_SUPPORTED: u32 = 16u32;
27711 pub const TIMESTAMP_FAILURE_INFO_NOT_AVAILABLE: u32 = 17u32;
27712 pub const TIMESTAMP_FAILURE_POLICY_NOT_SUPPORTED: u32 = 15u32;
27713 pub const TIMESTAMP_FAILURE_SYSTEM_FAILURE: u32 = 25u32;
27714 pub const TIMESTAMP_FAILURE_TIME_NOT_AVAILABLE: u32 = 14u32;
27715 pub const TIMESTAMP_NO_AUTH_RETRIEVAL: u32 = 131072u32;
27716 pub const TIMESTAMP_VERIFY_CONTEXT_SIGNATURE: u32 = 32u32;
27717 #[inline]
TransformBlock(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cbindata: u32, pindata: *const u8, pcboutdata: *mut u32, ppoutdata: *mut *mut u8) -> ::windows::runtime::Result<()>27718 pub unsafe fn TransformBlock(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cbindata: u32, pindata: *const u8, pcboutdata: *mut u32, ppoutdata: *mut *mut u8) -> ::windows::runtime::Result<()> {
27719     #[cfg(windows)]
27720     {
27721         #[link(name = "windows")]
27722         extern "system" {
27723             fn TransformBlock(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cbindata: u32, pindata: *const u8, pcboutdata: *mut u32, ppoutdata: *mut *mut u8) -> ::windows::runtime::HRESULT;
27724         }
27725         TransformBlock(::std::mem::transmute(hcrypto), ::std::mem::transmute(cbindata), ::std::mem::transmute(pindata), ::std::mem::transmute(pcboutdata), ::std::mem::transmute(ppoutdata)).ok()
27726     }
27727     #[cfg(not(windows))]
27728     unimplemented!("Unsupported target OS");
27729 }
27730 #[inline]
TransformFinalBlock(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cbindata: u32, pindata: *const u8, pcboutdata: *mut u32, ppoutdata: *mut *mut u8) -> ::windows::runtime::Result<()>27731 pub unsafe fn TransformFinalBlock(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cbindata: u32, pindata: *const u8, pcboutdata: *mut u32, ppoutdata: *mut *mut u8) -> ::windows::runtime::Result<()> {
27732     #[cfg(windows)]
27733     {
27734         #[link(name = "windows")]
27735         extern "system" {
27736             fn TransformFinalBlock(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cbindata: u32, pindata: *const u8, pcboutdata: *mut u32, ppoutdata: *mut *mut u8) -> ::windows::runtime::HRESULT;
27737         }
27738         TransformFinalBlock(::std::mem::transmute(hcrypto), ::std::mem::transmute(cbindata), ::std::mem::transmute(pindata), ::std::mem::transmute(pcboutdata), ::std::mem::transmute(ppoutdata)).ok()
27739     }
27740     #[cfg(not(windows))]
27741     unimplemented!("Unsupported target OS");
27742 }
27743 pub const USAGE_MATCH_TYPE_AND: u32 = 0u32;
27744 pub const USAGE_MATCH_TYPE_OR: u32 = 1u32;
27745 #[cfg(feature = "Win32_Foundation")]
27746 #[inline]
VerifyHash<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cbhash: u32, phash: *const u8, hashalgoid: Param3, cbsig: u32, psig: *const u8) -> ::windows::runtime::Result<super::super::Foundation::BOOL>27747 pub unsafe fn VerifyHash<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cbhash: u32, phash: *const u8, hashalgoid: Param3, cbsig: u32, psig: *const u8) -> ::windows::runtime::Result<super::super::Foundation::BOOL> {
27748     #[cfg(windows)]
27749     {
27750         #[link(name = "windows")]
27751         extern "system" {
27752             fn VerifyHash(hcrypto: *const INFORMATIONCARD_CRYPTO_HANDLE, cbhash: u32, phash: *const u8, hashalgoid: super::super::Foundation::PWSTR, cbsig: u32, psig: *const u8, pfverified: *mut super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT;
27753         }
27754         let mut result__: <super::super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
27755         VerifyHash(::std::mem::transmute(hcrypto), ::std::mem::transmute(cbhash), ::std::mem::transmute(phash), hashalgoid.into_param().abi(), ::std::mem::transmute(cbsig), ::std::mem::transmute(psig), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
27756     }
27757     #[cfg(not(windows))]
27758     unimplemented!("Unsupported target OS");
27759 }
27760 pub const X509_NDR_ENCODING: u32 = 2u32;
27761 pub const ZERO_PADDING: u32 = 3u32;
27762 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
27763 #[repr(C)]
27764 pub struct __NCRYPT_PCP_TPM_WEB_AUTHN_ATTESTATION_STATEMENT {
27765     pub Magic: u32,
27766     pub Version: u32,
27767     pub HeaderSize: u32,
27768     pub cbCertifyInfo: u32,
27769     pub cbSignature: u32,
27770     pub cbTpmPublic: u32,
27771 }
27772 impl __NCRYPT_PCP_TPM_WEB_AUTHN_ATTESTATION_STATEMENT {}
27773 impl ::std::default::Default for __NCRYPT_PCP_TPM_WEB_AUTHN_ATTESTATION_STATEMENT {
default() -> Self27774     fn default() -> Self {
27775         unsafe { ::std::mem::zeroed() }
27776     }
27777 }
27778 impl ::std::fmt::Debug for __NCRYPT_PCP_TPM_WEB_AUTHN_ATTESTATION_STATEMENT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result27779     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
27780         fmt.debug_struct("__NCRYPT_PCP_TPM_WEB_AUTHN_ATTESTATION_STATEMENT").field("Magic", &self.Magic).field("Version", &self.Version).field("HeaderSize", &self.HeaderSize).field("cbCertifyInfo", &self.cbCertifyInfo).field("cbSignature", &self.cbSignature).field("cbTpmPublic", &self.cbTpmPublic).finish()
27781     }
27782 }
27783 impl ::std::cmp::PartialEq for __NCRYPT_PCP_TPM_WEB_AUTHN_ATTESTATION_STATEMENT {
eq(&self, other: &Self) -> bool27784     fn eq(&self, other: &Self) -> bool {
27785         self.Magic == other.Magic && self.Version == other.Version && self.HeaderSize == other.HeaderSize && self.cbCertifyInfo == other.cbCertifyInfo && self.cbSignature == other.cbSignature && self.cbTpmPublic == other.cbTpmPublic
27786     }
27787 }
27788 impl ::std::cmp::Eq for __NCRYPT_PCP_TPM_WEB_AUTHN_ATTESTATION_STATEMENT {}
27789 unsafe impl ::windows::runtime::Abi for __NCRYPT_PCP_TPM_WEB_AUTHN_ATTESTATION_STATEMENT {
27790     type Abi = Self;
27791     type DefaultType = Self;
27792 }
27793