1 #![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
2 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3 #[repr(C)]
4 #[cfg(feature = "Win32_Foundation")]
5 pub struct CAT_MEMBERINFO {
6     pub pwszSubjGuid: super::super::Foundation::PWSTR,
7     pub dwCertVersion: u32,
8 }
9 #[cfg(feature = "Win32_Foundation")]
10 impl CAT_MEMBERINFO {}
11 #[cfg(feature = "Win32_Foundation")]
12 impl ::std::default::Default for CAT_MEMBERINFO {
13     fn default() -> Self {
14         unsafe { ::std::mem::zeroed() }
15     }
16 }
17 #[cfg(feature = "Win32_Foundation")]
18 impl ::std::fmt::Debug for CAT_MEMBERINFO {
19     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
20         fmt.debug_struct("CAT_MEMBERINFO").field("pwszSubjGuid", &self.pwszSubjGuid).field("dwCertVersion", &self.dwCertVersion).finish()
21     }
22 }
23 #[cfg(feature = "Win32_Foundation")]
24 impl ::std::cmp::PartialEq for CAT_MEMBERINFO {
25     fn eq(&self, other: &Self) -> bool {
26         self.pwszSubjGuid == other.pwszSubjGuid && self.dwCertVersion == other.dwCertVersion
27     }
28 }
29 #[cfg(feature = "Win32_Foundation")]
30 impl ::std::cmp::Eq for CAT_MEMBERINFO {}
31 #[cfg(feature = "Win32_Foundation")]
32 unsafe impl ::windows::runtime::Abi for CAT_MEMBERINFO {
operator ()TestFn33     type Abi = Self;
34     type DefaultType = Self;
35 }
36 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
37 #[repr(C)]
38 pub struct CAT_MEMBERINFO2 {
39     pub SubjectGuid: ::windows::runtime::GUID,
40     pub dwCertVersion: u32,
41 }
42 impl CAT_MEMBERINFO2 {}
43 impl ::std::default::Default for CAT_MEMBERINFO2 {
44     fn default() -> Self {
45         unsafe { ::std::mem::zeroed() }
46     }
47 }
48 impl ::std::fmt::Debug for CAT_MEMBERINFO2 {
49     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
50         fmt.debug_struct("CAT_MEMBERINFO2").field("SubjectGuid", &self.SubjectGuid).field("dwCertVersion", &self.dwCertVersion).finish()
51     }
52 }
53 impl ::std::cmp::PartialEq for CAT_MEMBERINFO2 {
54     fn eq(&self, other: &Self) -> bool {
55         self.SubjectGuid == other.SubjectGuid && self.dwCertVersion == other.dwCertVersion
56     }
57 }
58 impl ::std::cmp::Eq for CAT_MEMBERINFO2 {}
main(int,char **)59 unsafe impl ::windows::runtime::Abi for CAT_MEMBERINFO2 {
60     type Abi = Self;
61     type DefaultType = Self;
62 }
63 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
64 #[repr(C)]
65 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
66 pub struct CAT_NAMEVALUE {
67     pub pwszTag: super::super::Foundation::PWSTR,
68     pub fdwFlags: u32,
69     pub Value: super::Cryptography::CRYPTOAPI_BLOB,
70 }
71 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
72 impl CAT_NAMEVALUE {}
73 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
74 impl ::std::default::Default for CAT_NAMEVALUE {
75     fn default() -> Self {
76         unsafe { ::std::mem::zeroed() }
77     }
78 }
79 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
80 impl ::std::fmt::Debug for CAT_NAMEVALUE {
81     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
82         fmt.debug_struct("CAT_NAMEVALUE").field("pwszTag", &self.pwszTag).field("fdwFlags", &self.fdwFlags).field("Value", &self.Value).finish()
83     }
84 }
85 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
86 impl ::std::cmp::PartialEq for CAT_NAMEVALUE {
87     fn eq(&self, other: &Self) -> bool {
88         self.pwszTag == other.pwszTag && self.fdwFlags == other.fdwFlags && self.Value == other.Value
89     }
90 }
91 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
92 impl ::std::cmp::Eq for CAT_NAMEVALUE {}
93 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
94 unsafe impl ::windows::runtime::Abi for CAT_NAMEVALUE {
95     type Abi = Self;
96     type DefaultType = Self;
97 }
98 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
99 #[repr(C)]
100 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
101 pub struct CONFIG_CI_PROV_INFO {
102     pub cbSize: u32,
103     pub dwPolicies: u32,
104     pub pPolicies: *mut super::Cryptography::CRYPTOAPI_BLOB,
105     pub result: CONFIG_CI_PROV_INFO_RESULT,
106     pub dwScenario: u32,
107 }
108 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
109 impl CONFIG_CI_PROV_INFO {}
110 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
111 impl ::std::default::Default for CONFIG_CI_PROV_INFO {
112     fn default() -> Self {
113         unsafe { ::std::mem::zeroed() }
114     }
115 }
116 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
117 impl ::std::fmt::Debug for CONFIG_CI_PROV_INFO {
118     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
119         fmt.debug_struct("CONFIG_CI_PROV_INFO").field("cbSize", &self.cbSize).field("dwPolicies", &self.dwPolicies).field("pPolicies", &self.pPolicies).field("result", &self.result).field("dwScenario", &self.dwScenario).finish()
120     }
121 }
122 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
123 impl ::std::cmp::PartialEq for CONFIG_CI_PROV_INFO {
124     fn eq(&self, other: &Self) -> bool {
125         self.cbSize == other.cbSize && self.dwPolicies == other.dwPolicies && self.pPolicies == other.pPolicies && self.result == other.result && self.dwScenario == other.dwScenario
126     }
127 }
128 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
129 impl ::std::cmp::Eq for CONFIG_CI_PROV_INFO {}
130 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
131 unsafe impl ::windows::runtime::Abi for CONFIG_CI_PROV_INFO {
132     type Abi = Self;
133     type DefaultType = Self;
134 }
135 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
136 #[repr(C)]
137 #[cfg(feature = "Win32_Foundation")]
138 pub struct CONFIG_CI_PROV_INFO_RESULT {
139     pub hr: ::windows::runtime::HRESULT,
140     pub dwResult: u32,
141     pub dwPolicyIndex: u32,
142     pub fIsExplicitDeny: super::super::Foundation::BOOLEAN,
143 }
144 #[cfg(feature = "Win32_Foundation")]
145 impl CONFIG_CI_PROV_INFO_RESULT {}
146 #[cfg(feature = "Win32_Foundation")]
147 impl ::std::default::Default for CONFIG_CI_PROV_INFO_RESULT {
148     fn default() -> Self {
149         unsafe { ::std::mem::zeroed() }
150     }
151 }
152 #[cfg(feature = "Win32_Foundation")]
153 impl ::std::fmt::Debug for CONFIG_CI_PROV_INFO_RESULT {
154     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
155         fmt.debug_struct("CONFIG_CI_PROV_INFO_RESULT").field("hr", &self.hr).field("dwResult", &self.dwResult).field("dwPolicyIndex", &self.dwPolicyIndex).field("fIsExplicitDeny", &self.fIsExplicitDeny).finish()
156     }
157 }
158 #[cfg(feature = "Win32_Foundation")]
159 impl ::std::cmp::PartialEq for CONFIG_CI_PROV_INFO_RESULT {
160     fn eq(&self, other: &Self) -> bool {
161         self.hr == other.hr && self.dwResult == other.dwResult && self.dwPolicyIndex == other.dwPolicyIndex && self.fIsExplicitDeny == other.fIsExplicitDeny
162     }
163 }
164 #[cfg(feature = "Win32_Foundation")]
165 impl ::std::cmp::Eq for CONFIG_CI_PROV_INFO_RESULT {}
166 #[cfg(feature = "Win32_Foundation")]
167 unsafe impl ::windows::runtime::Abi for CONFIG_CI_PROV_INFO_RESULT {
168     type Abi = Self;
169     type DefaultType = Self;
170 }
171 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
172 #[repr(C)]
173 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
174 pub struct CRYPT_PROVIDER_CERT {
175     pub cbStruct: u32,
176     pub pCert: *mut super::Cryptography::CERT_CONTEXT,
177     pub fCommercial: super::super::Foundation::BOOL,
178     pub fTrustedRoot: super::super::Foundation::BOOL,
179     pub fSelfSigned: super::super::Foundation::BOOL,
180     pub fTestCert: super::super::Foundation::BOOL,
181     pub dwRevokedReason: u32,
182     pub dwConfidence: u32,
183     pub dwError: u32,
184     pub pTrustListContext: *mut super::Cryptography::CTL_CONTEXT,
185     pub fTrustListSignerCert: super::super::Foundation::BOOL,
186     pub pCtlContext: *mut super::Cryptography::CTL_CONTEXT,
187     pub dwCtlError: u32,
188     pub fIsCyclic: super::super::Foundation::BOOL,
189     pub pChainElement: *mut super::Cryptography::CERT_CHAIN_ELEMENT,
190 }
191 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
192 impl CRYPT_PROVIDER_CERT {}
193 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
194 impl ::std::default::Default for CRYPT_PROVIDER_CERT {
195     fn default() -> Self {
196         unsafe { ::std::mem::zeroed() }
197     }
198 }
199 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
200 impl ::std::fmt::Debug for CRYPT_PROVIDER_CERT {
201     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
202         fmt.debug_struct("CRYPT_PROVIDER_CERT")
203             .field("cbStruct", &self.cbStruct)
204             .field("pCert", &self.pCert)
205             .field("fCommercial", &self.fCommercial)
206             .field("fTrustedRoot", &self.fTrustedRoot)
207             .field("fSelfSigned", &self.fSelfSigned)
208             .field("fTestCert", &self.fTestCert)
209             .field("dwRevokedReason", &self.dwRevokedReason)
210             .field("dwConfidence", &self.dwConfidence)
211             .field("dwError", &self.dwError)
212             .field("pTrustListContext", &self.pTrustListContext)
213             .field("fTrustListSignerCert", &self.fTrustListSignerCert)
214             .field("pCtlContext", &self.pCtlContext)
215             .field("dwCtlError", &self.dwCtlError)
216             .field("fIsCyclic", &self.fIsCyclic)
217             .field("pChainElement", &self.pChainElement)
218             .finish()
219     }
220 }
221 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
222 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_CERT {
223     fn eq(&self, other: &Self) -> bool {
224         self.cbStruct == other.cbStruct
225             && self.pCert == other.pCert
226             && self.fCommercial == other.fCommercial
227             && self.fTrustedRoot == other.fTrustedRoot
228             && self.fSelfSigned == other.fSelfSigned
229             && self.fTestCert == other.fTestCert
230             && self.dwRevokedReason == other.dwRevokedReason
231             && self.dwConfidence == other.dwConfidence
232             && self.dwError == other.dwError
233             && self.pTrustListContext == other.pTrustListContext
234             && self.fTrustListSignerCert == other.fTrustListSignerCert
235             && self.pCtlContext == other.pCtlContext
236             && self.dwCtlError == other.dwCtlError
237             && self.fIsCyclic == other.fIsCyclic
238             && self.pChainElement == other.pChainElement
239     }
240 }
241 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
242 impl ::std::cmp::Eq for CRYPT_PROVIDER_CERT {}
243 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
244 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_CERT {
245     type Abi = Self;
246     type DefaultType = Self;
247 }
248 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
249 #[repr(C)]
250 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
251 pub struct CRYPT_PROVIDER_DATA {
252     pub cbStruct: u32,
253     pub pWintrustData: *mut WINTRUST_DATA,
254     pub fOpenedFile: super::super::Foundation::BOOL,
255     pub hWndParent: super::super::Foundation::HWND,
256     pub pgActionID: *mut ::windows::runtime::GUID,
257     pub hProv: usize,
258     pub dwError: u32,
259     pub dwRegSecuritySettings: u32,
260     pub dwRegPolicySettings: u32,
261     pub psPfns: *mut CRYPT_PROVIDER_FUNCTIONS,
262     pub cdwTrustStepErrors: u32,
263     pub padwTrustStepErrors: *mut u32,
264     pub chStores: u32,
265     pub pahStores: *mut *mut ::std::ffi::c_void,
266     pub dwEncoding: u32,
267     pub hMsg: *mut ::std::ffi::c_void,
268     pub csSigners: u32,
269     pub pasSigners: *mut CRYPT_PROVIDER_SGNR,
270     pub csProvPrivData: u32,
271     pub pasProvPrivData: *mut CRYPT_PROVIDER_PRIVDATA,
272     pub dwSubjectChoice: u32,
273     pub Anonymous: CRYPT_PROVIDER_DATA_0,
274     pub pszUsageOID: super::super::Foundation::PSTR,
275     pub fRecallWithState: super::super::Foundation::BOOL,
276     pub sftSystemTime: super::super::Foundation::FILETIME,
277     pub pszCTLSignerUsageOID: super::super::Foundation::PSTR,
278     pub dwProvFlags: u32,
279     pub dwFinalError: u32,
280     pub pRequestUsage: *mut super::Cryptography::CERT_USAGE_MATCH,
281     pub dwTrustPubSettings: u32,
282     pub dwUIStateFlags: u32,
283     pub pSigState: *mut CRYPT_PROVIDER_SIGSTATE,
284     pub pSigSettings: *mut WINTRUST_SIGNATURE_SETTINGS,
285 }
286 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
287 impl CRYPT_PROVIDER_DATA {}
288 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
289 impl ::std::default::Default for CRYPT_PROVIDER_DATA {
290     fn default() -> Self {
291         unsafe { ::std::mem::zeroed() }
292     }
293 }
294 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
295 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_DATA {
296     fn eq(&self, _other: &Self) -> bool {
297         unimplemented!()
298     }
299 }
300 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
301 impl ::std::cmp::Eq for CRYPT_PROVIDER_DATA {}
302 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
303 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_DATA {
304     type Abi = Self;
305     type DefaultType = Self;
306 }
307 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
308 #[repr(C)]
309 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
310 pub union CRYPT_PROVIDER_DATA_0 {
311     pub pPDSip: *mut PROVDATA_SIP,
312 }
313 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
314 impl CRYPT_PROVIDER_DATA_0 {}
315 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
316 impl ::std::default::Default for CRYPT_PROVIDER_DATA_0 {
317     fn default() -> Self {
318         unsafe { ::std::mem::zeroed() }
319     }
320 }
321 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
322 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_DATA_0 {
323     fn eq(&self, _other: &Self) -> bool {
324         unimplemented!()
325     }
326 }
327 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
328 impl ::std::cmp::Eq for CRYPT_PROVIDER_DATA_0 {}
329 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
330 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_DATA_0 {
331     type Abi = Self;
332     type DefaultType = Self;
333 }
334 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
335 #[repr(C)]
336 pub struct CRYPT_PROVIDER_DEFUSAGE {
337     pub cbStruct: u32,
338     pub gActionID: ::windows::runtime::GUID,
339     pub pDefPolicyCallbackData: *mut ::std::ffi::c_void,
340     pub pDefSIPClientData: *mut ::std::ffi::c_void,
341 }
342 impl CRYPT_PROVIDER_DEFUSAGE {}
343 impl ::std::default::Default for CRYPT_PROVIDER_DEFUSAGE {
344     fn default() -> Self {
345         unsafe { ::std::mem::zeroed() }
346     }
347 }
348 impl ::std::fmt::Debug for CRYPT_PROVIDER_DEFUSAGE {
349     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
350         fmt.debug_struct("CRYPT_PROVIDER_DEFUSAGE").field("cbStruct", &self.cbStruct).field("gActionID", &self.gActionID).field("pDefPolicyCallbackData", &self.pDefPolicyCallbackData).field("pDefSIPClientData", &self.pDefSIPClientData).finish()
351     }
352 }
353 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_DEFUSAGE {
354     fn eq(&self, other: &Self) -> bool {
355         self.cbStruct == other.cbStruct && self.gActionID == other.gActionID && self.pDefPolicyCallbackData == other.pDefPolicyCallbackData && self.pDefSIPClientData == other.pDefSIPClientData
356     }
357 }
358 impl ::std::cmp::Eq for CRYPT_PROVIDER_DEFUSAGE {}
359 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_DEFUSAGE {
360     type Abi = Self;
361     type DefaultType = Self;
362 }
363 #[derive(:: std :: clone :: Clone)]
364 #[repr(C)]
365 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
366 pub struct CRYPT_PROVIDER_FUNCTIONS {
367     pub cbStruct: u32,
368     pub pfnAlloc: ::std::option::Option<PFN_CPD_MEM_ALLOC>,
369     pub pfnFree: ::std::option::Option<PFN_CPD_MEM_FREE>,
370     pub pfnAddStore2Chain: ::std::option::Option<PFN_CPD_ADD_STORE>,
371     pub pfnAddSgnr2Chain: ::std::option::Option<PFN_CPD_ADD_SGNR>,
372     pub pfnAddCert2Chain: ::std::option::Option<PFN_CPD_ADD_CERT>,
373     pub pfnAddPrivData2Chain: ::std::option::Option<PFN_CPD_ADD_PRIVDATA>,
374     pub pfnInitialize: ::std::option::Option<PFN_PROVIDER_INIT_CALL>,
375     pub pfnObjectTrust: ::std::option::Option<PFN_PROVIDER_OBJTRUST_CALL>,
376     pub pfnSignatureTrust: ::std::option::Option<PFN_PROVIDER_SIGTRUST_CALL>,
377     pub pfnCertificateTrust: ::std::option::Option<PFN_PROVIDER_CERTTRUST_CALL>,
378     pub pfnFinalPolicy: ::std::option::Option<PFN_PROVIDER_FINALPOLICY_CALL>,
379     pub pfnCertCheckPolicy: ::std::option::Option<PFN_PROVIDER_CERTCHKPOLICY_CALL>,
380     pub pfnTestFinalPolicy: ::std::option::Option<PFN_PROVIDER_TESTFINALPOLICY_CALL>,
381     pub psUIpfns: *mut CRYPT_PROVUI_FUNCS,
382     pub pfnCleanupPolicy: ::std::option::Option<PFN_PROVIDER_CLEANUP_CALL>,
383 }
384 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
385 impl CRYPT_PROVIDER_FUNCTIONS {}
386 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
387 impl ::std::default::Default for CRYPT_PROVIDER_FUNCTIONS {
388     fn default() -> Self {
389         unsafe { ::std::mem::zeroed() }
390     }
391 }
392 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
393 impl ::std::fmt::Debug for CRYPT_PROVIDER_FUNCTIONS {
394     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
395         fmt.debug_struct("CRYPT_PROVIDER_FUNCTIONS").field("cbStruct", &self.cbStruct).field("psUIpfns", &self.psUIpfns).finish()
396     }
397 }
398 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
399 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_FUNCTIONS {
400     fn eq(&self, other: &Self) -> bool {
401         self.cbStruct == other.cbStruct
402             && self.pfnAlloc.map(|f| f as usize) == other.pfnAlloc.map(|f| f as usize)
403             && self.pfnFree.map(|f| f as usize) == other.pfnFree.map(|f| f as usize)
404             && self.pfnAddStore2Chain.map(|f| f as usize) == other.pfnAddStore2Chain.map(|f| f as usize)
405             && self.pfnAddSgnr2Chain.map(|f| f as usize) == other.pfnAddSgnr2Chain.map(|f| f as usize)
406             && self.pfnAddCert2Chain.map(|f| f as usize) == other.pfnAddCert2Chain.map(|f| f as usize)
407             && self.pfnAddPrivData2Chain.map(|f| f as usize) == other.pfnAddPrivData2Chain.map(|f| f as usize)
408             && self.pfnInitialize.map(|f| f as usize) == other.pfnInitialize.map(|f| f as usize)
409             && self.pfnObjectTrust.map(|f| f as usize) == other.pfnObjectTrust.map(|f| f as usize)
410             && self.pfnSignatureTrust.map(|f| f as usize) == other.pfnSignatureTrust.map(|f| f as usize)
411             && self.pfnCertificateTrust.map(|f| f as usize) == other.pfnCertificateTrust.map(|f| f as usize)
412             && self.pfnFinalPolicy.map(|f| f as usize) == other.pfnFinalPolicy.map(|f| f as usize)
413             && self.pfnCertCheckPolicy.map(|f| f as usize) == other.pfnCertCheckPolicy.map(|f| f as usize)
414             && self.pfnTestFinalPolicy.map(|f| f as usize) == other.pfnTestFinalPolicy.map(|f| f as usize)
415             && self.psUIpfns == other.psUIpfns
416             && self.pfnCleanupPolicy.map(|f| f as usize) == other.pfnCleanupPolicy.map(|f| f as usize)
417     }
418 }
419 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
420 impl ::std::cmp::Eq for CRYPT_PROVIDER_FUNCTIONS {}
421 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
422 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_FUNCTIONS {
423     type Abi = ::std::mem::ManuallyDrop<Self>;
424     type DefaultType = Self;
425 }
426 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
427 #[repr(C)]
428 pub struct CRYPT_PROVIDER_PRIVDATA {
429     pub cbStruct: u32,
430     pub gProviderID: ::windows::runtime::GUID,
431     pub cbProvData: u32,
432     pub pvProvData: *mut ::std::ffi::c_void,
433 }
434 impl CRYPT_PROVIDER_PRIVDATA {}
435 impl ::std::default::Default for CRYPT_PROVIDER_PRIVDATA {
436     fn default() -> Self {
437         unsafe { ::std::mem::zeroed() }
438     }
439 }
440 impl ::std::fmt::Debug for CRYPT_PROVIDER_PRIVDATA {
441     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
442         fmt.debug_struct("CRYPT_PROVIDER_PRIVDATA").field("cbStruct", &self.cbStruct).field("gProviderID", &self.gProviderID).field("cbProvData", &self.cbProvData).field("pvProvData", &self.pvProvData).finish()
443     }
444 }
445 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_PRIVDATA {
446     fn eq(&self, other: &Self) -> bool {
447         self.cbStruct == other.cbStruct && self.gProviderID == other.gProviderID && self.cbProvData == other.cbProvData && self.pvProvData == other.pvProvData
448     }
449 }
450 impl ::std::cmp::Eq for CRYPT_PROVIDER_PRIVDATA {}
451 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_PRIVDATA {
452     type Abi = Self;
453     type DefaultType = Self;
454 }
455 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
456 #[repr(C)]
457 #[cfg(feature = "Win32_Foundation")]
458 pub struct CRYPT_PROVIDER_REGDEFUSAGE {
459     pub cbStruct: u32,
460     pub pgActionID: *mut ::windows::runtime::GUID,
461     pub pwszDllName: super::super::Foundation::PWSTR,
462     pub pwszLoadCallbackDataFunctionName: super::super::Foundation::PSTR,
463     pub pwszFreeCallbackDataFunctionName: super::super::Foundation::PSTR,
464 }
465 #[cfg(feature = "Win32_Foundation")]
466 impl CRYPT_PROVIDER_REGDEFUSAGE {}
467 #[cfg(feature = "Win32_Foundation")]
468 impl ::std::default::Default for CRYPT_PROVIDER_REGDEFUSAGE {
469     fn default() -> Self {
470         unsafe { ::std::mem::zeroed() }
471     }
472 }
473 #[cfg(feature = "Win32_Foundation")]
474 impl ::std::fmt::Debug for CRYPT_PROVIDER_REGDEFUSAGE {
475     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
476         fmt.debug_struct("CRYPT_PROVIDER_REGDEFUSAGE")
477             .field("cbStruct", &self.cbStruct)
478             .field("pgActionID", &self.pgActionID)
479             .field("pwszDllName", &self.pwszDllName)
480             .field("pwszLoadCallbackDataFunctionName", &self.pwszLoadCallbackDataFunctionName)
481             .field("pwszFreeCallbackDataFunctionName", &self.pwszFreeCallbackDataFunctionName)
482             .finish()
483     }
484 }
485 #[cfg(feature = "Win32_Foundation")]
486 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_REGDEFUSAGE {
487     fn eq(&self, other: &Self) -> bool {
488         self.cbStruct == other.cbStruct && self.pgActionID == other.pgActionID && self.pwszDllName == other.pwszDllName && self.pwszLoadCallbackDataFunctionName == other.pwszLoadCallbackDataFunctionName && self.pwszFreeCallbackDataFunctionName == other.pwszFreeCallbackDataFunctionName
489     }
490 }
491 #[cfg(feature = "Win32_Foundation")]
492 impl ::std::cmp::Eq for CRYPT_PROVIDER_REGDEFUSAGE {}
493 #[cfg(feature = "Win32_Foundation")]
494 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_REGDEFUSAGE {
495     type Abi = Self;
496     type DefaultType = Self;
497 }
498 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
499 #[repr(C)]
500 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
501 pub struct CRYPT_PROVIDER_SGNR {
502     pub cbStruct: u32,
503     pub sftVerifyAsOf: super::super::Foundation::FILETIME,
504     pub csCertChain: u32,
505     pub pasCertChain: *mut CRYPT_PROVIDER_CERT,
506     pub dwSignerType: u32,
507     pub psSigner: *mut super::Cryptography::CMSG_SIGNER_INFO,
508     pub dwError: u32,
509     pub csCounterSigners: u32,
510     pub pasCounterSigners: *mut CRYPT_PROVIDER_SGNR,
511     pub pChainContext: *mut super::Cryptography::CERT_CHAIN_CONTEXT,
512 }
513 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
514 impl CRYPT_PROVIDER_SGNR {}
515 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
516 impl ::std::default::Default for CRYPT_PROVIDER_SGNR {
517     fn default() -> Self {
518         unsafe { ::std::mem::zeroed() }
519     }
520 }
521 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
522 impl ::std::fmt::Debug for CRYPT_PROVIDER_SGNR {
523     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
524         fmt.debug_struct("CRYPT_PROVIDER_SGNR")
525             .field("cbStruct", &self.cbStruct)
526             .field("sftVerifyAsOf", &self.sftVerifyAsOf)
527             .field("csCertChain", &self.csCertChain)
528             .field("pasCertChain", &self.pasCertChain)
529             .field("dwSignerType", &self.dwSignerType)
530             .field("psSigner", &self.psSigner)
531             .field("dwError", &self.dwError)
532             .field("csCounterSigners", &self.csCounterSigners)
533             .field("pasCounterSigners", &self.pasCounterSigners)
534             .field("pChainContext", &self.pChainContext)
535             .finish()
536     }
537 }
538 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
539 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_SGNR {
540     fn eq(&self, other: &Self) -> bool {
541         self.cbStruct == other.cbStruct && self.sftVerifyAsOf == other.sftVerifyAsOf && self.csCertChain == other.csCertChain && self.pasCertChain == other.pasCertChain && self.dwSignerType == other.dwSignerType && self.psSigner == other.psSigner && self.dwError == other.dwError && self.csCounterSigners == other.csCounterSigners && self.pasCounterSigners == other.pasCounterSigners && self.pChainContext == other.pChainContext
542     }
543 }
544 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
545 impl ::std::cmp::Eq for CRYPT_PROVIDER_SGNR {}
546 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
547 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_SGNR {
548     type Abi = Self;
549     type DefaultType = Self;
550 }
551 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
552 #[repr(C)]
553 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
554 pub struct CRYPT_PROVIDER_SIGSTATE {
555     pub cbStruct: u32,
556     pub rhSecondarySigs: *mut *mut ::std::ffi::c_void,
557     pub hPrimarySig: *mut ::std::ffi::c_void,
558     pub fFirstAttemptMade: super::super::Foundation::BOOL,
559     pub fNoMoreSigs: super::super::Foundation::BOOL,
560     pub cSecondarySigs: u32,
561     pub dwCurrentIndex: u32,
562     pub fSupportMultiSig: super::super::Foundation::BOOL,
563     pub dwCryptoPolicySupport: u32,
564     pub iAttemptCount: u32,
565     pub fCheckedSealing: super::super::Foundation::BOOL,
566     pub pSealingSignature: *mut SEALING_SIGNATURE_ATTRIBUTE,
567 }
568 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
569 impl CRYPT_PROVIDER_SIGSTATE {}
570 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
571 impl ::std::default::Default for CRYPT_PROVIDER_SIGSTATE {
572     fn default() -> Self {
573         unsafe { ::std::mem::zeroed() }
574     }
575 }
576 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
577 impl ::std::fmt::Debug for CRYPT_PROVIDER_SIGSTATE {
578     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
579         fmt.debug_struct("CRYPT_PROVIDER_SIGSTATE")
580             .field("cbStruct", &self.cbStruct)
581             .field("rhSecondarySigs", &self.rhSecondarySigs)
582             .field("hPrimarySig", &self.hPrimarySig)
583             .field("fFirstAttemptMade", &self.fFirstAttemptMade)
584             .field("fNoMoreSigs", &self.fNoMoreSigs)
585             .field("cSecondarySigs", &self.cSecondarySigs)
586             .field("dwCurrentIndex", &self.dwCurrentIndex)
587             .field("fSupportMultiSig", &self.fSupportMultiSig)
588             .field("dwCryptoPolicySupport", &self.dwCryptoPolicySupport)
589             .field("iAttemptCount", &self.iAttemptCount)
590             .field("fCheckedSealing", &self.fCheckedSealing)
591             .field("pSealingSignature", &self.pSealingSignature)
592             .finish()
593     }
594 }
595 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
596 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_SIGSTATE {
597     fn eq(&self, other: &Self) -> bool {
598         self.cbStruct == other.cbStruct
599             && self.rhSecondarySigs == other.rhSecondarySigs
600             && self.hPrimarySig == other.hPrimarySig
601             && self.fFirstAttemptMade == other.fFirstAttemptMade
602             && self.fNoMoreSigs == other.fNoMoreSigs
603             && self.cSecondarySigs == other.cSecondarySigs
604             && self.dwCurrentIndex == other.dwCurrentIndex
605             && self.fSupportMultiSig == other.fSupportMultiSig
606             && self.dwCryptoPolicySupport == other.dwCryptoPolicySupport
607             && self.iAttemptCount == other.iAttemptCount
608             && self.fCheckedSealing == other.fCheckedSealing
609             && self.pSealingSignature == other.pSealingSignature
610     }
611 }
612 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
613 impl ::std::cmp::Eq for CRYPT_PROVIDER_SIGSTATE {}
614 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
615 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_SIGSTATE {
616     type Abi = Self;
617     type DefaultType = Self;
618 }
619 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
620 #[repr(C)]
621 #[cfg(feature = "Win32_Foundation")]
622 pub struct CRYPT_PROVUI_DATA {
623     pub cbStruct: u32,
624     pub dwFinalError: u32,
625     pub pYesButtonText: super::super::Foundation::PWSTR,
626     pub pNoButtonText: super::super::Foundation::PWSTR,
627     pub pMoreInfoButtonText: super::super::Foundation::PWSTR,
628     pub pAdvancedLinkText: super::super::Foundation::PWSTR,
629     pub pCopyActionText: super::super::Foundation::PWSTR,
630     pub pCopyActionTextNoTS: super::super::Foundation::PWSTR,
631     pub pCopyActionTextNotSigned: super::super::Foundation::PWSTR,
632 }
633 #[cfg(feature = "Win32_Foundation")]
634 impl CRYPT_PROVUI_DATA {}
635 #[cfg(feature = "Win32_Foundation")]
636 impl ::std::default::Default for CRYPT_PROVUI_DATA {
637     fn default() -> Self {
638         unsafe { ::std::mem::zeroed() }
639     }
640 }
641 #[cfg(feature = "Win32_Foundation")]
642 impl ::std::fmt::Debug for CRYPT_PROVUI_DATA {
643     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
644         fmt.debug_struct("CRYPT_PROVUI_DATA")
645             .field("cbStruct", &self.cbStruct)
646             .field("dwFinalError", &self.dwFinalError)
647             .field("pYesButtonText", &self.pYesButtonText)
648             .field("pNoButtonText", &self.pNoButtonText)
649             .field("pMoreInfoButtonText", &self.pMoreInfoButtonText)
650             .field("pAdvancedLinkText", &self.pAdvancedLinkText)
651             .field("pCopyActionText", &self.pCopyActionText)
652             .field("pCopyActionTextNoTS", &self.pCopyActionTextNoTS)
653             .field("pCopyActionTextNotSigned", &self.pCopyActionTextNotSigned)
654             .finish()
655     }
656 }
657 #[cfg(feature = "Win32_Foundation")]
658 impl ::std::cmp::PartialEq for CRYPT_PROVUI_DATA {
659     fn eq(&self, other: &Self) -> bool {
660         self.cbStruct == other.cbStruct && self.dwFinalError == other.dwFinalError && self.pYesButtonText == other.pYesButtonText && self.pNoButtonText == other.pNoButtonText && self.pMoreInfoButtonText == other.pMoreInfoButtonText && self.pAdvancedLinkText == other.pAdvancedLinkText && self.pCopyActionText == other.pCopyActionText && self.pCopyActionTextNoTS == other.pCopyActionTextNoTS && self.pCopyActionTextNotSigned == other.pCopyActionTextNotSigned
661     }
662 }
663 #[cfg(feature = "Win32_Foundation")]
664 impl ::std::cmp::Eq for CRYPT_PROVUI_DATA {}
665 #[cfg(feature = "Win32_Foundation")]
666 unsafe impl ::windows::runtime::Abi for CRYPT_PROVUI_DATA {
667     type Abi = Self;
668     type DefaultType = Self;
669 }
670 #[derive(:: std :: clone :: Clone)]
671 #[repr(C)]
672 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
673 pub struct CRYPT_PROVUI_FUNCS {
674     pub cbStruct: u32,
675     pub psUIData: *mut CRYPT_PROVUI_DATA,
676     pub pfnOnMoreInfoClick: ::std::option::Option<PFN_PROVUI_CALL>,
677     pub pfnOnMoreInfoClickDefault: ::std::option::Option<PFN_PROVUI_CALL>,
678     pub pfnOnAdvancedClick: ::std::option::Option<PFN_PROVUI_CALL>,
679     pub pfnOnAdvancedClickDefault: ::std::option::Option<PFN_PROVUI_CALL>,
680 }
681 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
682 impl CRYPT_PROVUI_FUNCS {}
683 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
684 impl ::std::default::Default for CRYPT_PROVUI_FUNCS {
685     fn default() -> Self {
686         unsafe { ::std::mem::zeroed() }
687     }
688 }
689 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
690 impl ::std::fmt::Debug for CRYPT_PROVUI_FUNCS {
691     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
692         fmt.debug_struct("CRYPT_PROVUI_FUNCS").field("cbStruct", &self.cbStruct).field("psUIData", &self.psUIData).finish()
693     }
694 }
695 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
696 impl ::std::cmp::PartialEq for CRYPT_PROVUI_FUNCS {
697     fn eq(&self, other: &Self) -> bool {
698         self.cbStruct == other.cbStruct && self.psUIData == other.psUIData && self.pfnOnMoreInfoClick.map(|f| f as usize) == other.pfnOnMoreInfoClick.map(|f| f as usize) && self.pfnOnMoreInfoClickDefault.map(|f| f as usize) == other.pfnOnMoreInfoClickDefault.map(|f| f as usize) && self.pfnOnAdvancedClick.map(|f| f as usize) == other.pfnOnAdvancedClick.map(|f| f as usize) && self.pfnOnAdvancedClickDefault.map(|f| f as usize) == other.pfnOnAdvancedClickDefault.map(|f| f as usize)
699     }
700 }
701 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
702 impl ::std::cmp::Eq for CRYPT_PROVUI_FUNCS {}
703 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
704 unsafe impl ::windows::runtime::Abi for CRYPT_PROVUI_FUNCS {
705     type Abi = ::std::mem::ManuallyDrop<Self>;
706     type DefaultType = Self;
707 }
708 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
709 #[repr(C)]
710 #[cfg(feature = "Win32_Foundation")]
711 pub struct CRYPT_REGISTER_ACTIONID {
712     pub cbStruct: u32,
713     pub sInitProvider: CRYPT_TRUST_REG_ENTRY,
714     pub sObjectProvider: CRYPT_TRUST_REG_ENTRY,
715     pub sSignatureProvider: CRYPT_TRUST_REG_ENTRY,
716     pub sCertificateProvider: CRYPT_TRUST_REG_ENTRY,
717     pub sCertificatePolicyProvider: CRYPT_TRUST_REG_ENTRY,
718     pub sFinalPolicyProvider: CRYPT_TRUST_REG_ENTRY,
719     pub sTestPolicyProvider: CRYPT_TRUST_REG_ENTRY,
720     pub sCleanupProvider: CRYPT_TRUST_REG_ENTRY,
721 }
722 #[cfg(feature = "Win32_Foundation")]
723 impl CRYPT_REGISTER_ACTIONID {}
724 #[cfg(feature = "Win32_Foundation")]
725 impl ::std::default::Default for CRYPT_REGISTER_ACTIONID {
726     fn default() -> Self {
727         unsafe { ::std::mem::zeroed() }
728     }
729 }
730 #[cfg(feature = "Win32_Foundation")]
731 impl ::std::fmt::Debug for CRYPT_REGISTER_ACTIONID {
732     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
733         fmt.debug_struct("CRYPT_REGISTER_ACTIONID")
734             .field("cbStruct", &self.cbStruct)
735             .field("sInitProvider", &self.sInitProvider)
736             .field("sObjectProvider", &self.sObjectProvider)
737             .field("sSignatureProvider", &self.sSignatureProvider)
738             .field("sCertificateProvider", &self.sCertificateProvider)
739             .field("sCertificatePolicyProvider", &self.sCertificatePolicyProvider)
740             .field("sFinalPolicyProvider", &self.sFinalPolicyProvider)
741             .field("sTestPolicyProvider", &self.sTestPolicyProvider)
742             .field("sCleanupProvider", &self.sCleanupProvider)
743             .finish()
744     }
745 }
746 #[cfg(feature = "Win32_Foundation")]
747 impl ::std::cmp::PartialEq for CRYPT_REGISTER_ACTIONID {
748     fn eq(&self, other: &Self) -> bool {
749         self.cbStruct == other.cbStruct && self.sInitProvider == other.sInitProvider && self.sObjectProvider == other.sObjectProvider && self.sSignatureProvider == other.sSignatureProvider && self.sCertificateProvider == other.sCertificateProvider && self.sCertificatePolicyProvider == other.sCertificatePolicyProvider && self.sFinalPolicyProvider == other.sFinalPolicyProvider && self.sTestPolicyProvider == other.sTestPolicyProvider && self.sCleanupProvider == other.sCleanupProvider
750     }
751 }
752 #[cfg(feature = "Win32_Foundation")]
753 impl ::std::cmp::Eq for CRYPT_REGISTER_ACTIONID {}
754 #[cfg(feature = "Win32_Foundation")]
755 unsafe impl ::windows::runtime::Abi for CRYPT_REGISTER_ACTIONID {
756     type Abi = Self;
757     type DefaultType = Self;
758 }
759 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
760 #[repr(C)]
761 #[cfg(feature = "Win32_Foundation")]
762 pub struct CRYPT_TRUST_REG_ENTRY {
763     pub cbStruct: u32,
764     pub pwszDLLName: super::super::Foundation::PWSTR,
765     pub pwszFunctionName: super::super::Foundation::PWSTR,
766 }
767 #[cfg(feature = "Win32_Foundation")]
768 impl CRYPT_TRUST_REG_ENTRY {}
769 #[cfg(feature = "Win32_Foundation")]
770 impl ::std::default::Default for CRYPT_TRUST_REG_ENTRY {
771     fn default() -> Self {
772         unsafe { ::std::mem::zeroed() }
773     }
774 }
775 #[cfg(feature = "Win32_Foundation")]
776 impl ::std::fmt::Debug for CRYPT_TRUST_REG_ENTRY {
777     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
778         fmt.debug_struct("CRYPT_TRUST_REG_ENTRY").field("cbStruct", &self.cbStruct).field("pwszDLLName", &self.pwszDLLName).field("pwszFunctionName", &self.pwszFunctionName).finish()
779     }
780 }
781 #[cfg(feature = "Win32_Foundation")]
782 impl ::std::cmp::PartialEq for CRYPT_TRUST_REG_ENTRY {
783     fn eq(&self, other: &Self) -> bool {
784         self.cbStruct == other.cbStruct && self.pwszDLLName == other.pwszDLLName && self.pwszFunctionName == other.pwszFunctionName
785     }
786 }
787 #[cfg(feature = "Win32_Foundation")]
788 impl ::std::cmp::Eq for CRYPT_TRUST_REG_ENTRY {}
789 #[cfg(feature = "Win32_Foundation")]
790 unsafe impl ::windows::runtime::Abi for CRYPT_TRUST_REG_ENTRY {
791     type Abi = Self;
792     type DefaultType = Self;
793 }
794 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
795 #[repr(C)]
796 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
797 pub struct DRIVER_VER_INFO {
798     pub cbStruct: u32,
799     pub dwReserved1: usize,
800     pub dwReserved2: usize,
801     pub dwPlatform: u32,
802     pub dwVersion: u32,
803     pub wszVersion: [u16; 260],
804     pub wszSignedBy: [u16; 260],
805     pub pcSignerCertContext: *mut super::Cryptography::CERT_CONTEXT,
806     pub sOSVersionLow: DRIVER_VER_MAJORMINOR,
807     pub sOSVersionHigh: DRIVER_VER_MAJORMINOR,
808     pub dwBuildNumberLow: u32,
809     pub dwBuildNumberHigh: u32,
810 }
811 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
812 impl DRIVER_VER_INFO {}
813 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
814 impl ::std::default::Default for DRIVER_VER_INFO {
815     fn default() -> Self {
816         unsafe { ::std::mem::zeroed() }
817     }
818 }
819 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
820 impl ::std::fmt::Debug for DRIVER_VER_INFO {
821     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
822         fmt.debug_struct("DRIVER_VER_INFO")
823             .field("cbStruct", &self.cbStruct)
824             .field("dwReserved1", &self.dwReserved1)
825             .field("dwReserved2", &self.dwReserved2)
826             .field("dwPlatform", &self.dwPlatform)
827             .field("dwVersion", &self.dwVersion)
828             .field("wszVersion", &self.wszVersion)
829             .field("wszSignedBy", &self.wszSignedBy)
830             .field("pcSignerCertContext", &self.pcSignerCertContext)
831             .field("sOSVersionLow", &self.sOSVersionLow)
832             .field("sOSVersionHigh", &self.sOSVersionHigh)
833             .field("dwBuildNumberLow", &self.dwBuildNumberLow)
834             .field("dwBuildNumberHigh", &self.dwBuildNumberHigh)
835             .finish()
836     }
837 }
838 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
839 impl ::std::cmp::PartialEq for DRIVER_VER_INFO {
840     fn eq(&self, other: &Self) -> bool {
841         self.cbStruct == other.cbStruct
842             && self.dwReserved1 == other.dwReserved1
843             && self.dwReserved2 == other.dwReserved2
844             && self.dwPlatform == other.dwPlatform
845             && self.dwVersion == other.dwVersion
846             && self.wszVersion == other.wszVersion
847             && self.wszSignedBy == other.wszSignedBy
848             && self.pcSignerCertContext == other.pcSignerCertContext
849             && self.sOSVersionLow == other.sOSVersionLow
850             && self.sOSVersionHigh == other.sOSVersionHigh
851             && self.dwBuildNumberLow == other.dwBuildNumberLow
852             && self.dwBuildNumberHigh == other.dwBuildNumberHigh
853     }
854 }
855 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
856 impl ::std::cmp::Eq for DRIVER_VER_INFO {}
857 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
858 unsafe impl ::windows::runtime::Abi for DRIVER_VER_INFO {
859     type Abi = Self;
860     type DefaultType = Self;
861 }
862 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
863 #[repr(C)]
864 pub struct DRIVER_VER_MAJORMINOR {
865     pub dwMajor: u32,
866     pub dwMinor: u32,
867 }
868 impl DRIVER_VER_MAJORMINOR {}
869 impl ::std::default::Default for DRIVER_VER_MAJORMINOR {
870     fn default() -> Self {
871         unsafe { ::std::mem::zeroed() }
872     }
873 }
874 impl ::std::fmt::Debug for DRIVER_VER_MAJORMINOR {
875     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
876         fmt.debug_struct("DRIVER_VER_MAJORMINOR").field("dwMajor", &self.dwMajor).field("dwMinor", &self.dwMinor).finish()
877     }
878 }
879 impl ::std::cmp::PartialEq for DRIVER_VER_MAJORMINOR {
880     fn eq(&self, other: &Self) -> bool {
881         self.dwMajor == other.dwMajor && self.dwMinor == other.dwMinor
882     }
883 }
884 impl ::std::cmp::Eq for DRIVER_VER_MAJORMINOR {}
885 unsafe impl ::windows::runtime::Abi for DRIVER_VER_MAJORMINOR {
886     type Abi = Self;
887     type DefaultType = Self;
888 }
889 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
890 #[repr(C)]
891 #[cfg(feature = "Win32_Foundation")]
892 pub struct INTENT_TO_SEAL_ATTRIBUTE {
893     pub version: u32,
894     pub seal: super::super::Foundation::BOOLEAN,
895 }
896 #[cfg(feature = "Win32_Foundation")]
897 impl INTENT_TO_SEAL_ATTRIBUTE {}
898 #[cfg(feature = "Win32_Foundation")]
899 impl ::std::default::Default for INTENT_TO_SEAL_ATTRIBUTE {
900     fn default() -> Self {
901         unsafe { ::std::mem::zeroed() }
902     }
903 }
904 #[cfg(feature = "Win32_Foundation")]
905 impl ::std::fmt::Debug for INTENT_TO_SEAL_ATTRIBUTE {
906     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
907         fmt.debug_struct("INTENT_TO_SEAL_ATTRIBUTE").field("version", &self.version).field("seal", &self.seal).finish()
908     }
909 }
910 #[cfg(feature = "Win32_Foundation")]
911 impl ::std::cmp::PartialEq for INTENT_TO_SEAL_ATTRIBUTE {
912     fn eq(&self, other: &Self) -> bool {
913         self.version == other.version && self.seal == other.seal
914     }
915 }
916 #[cfg(feature = "Win32_Foundation")]
917 impl ::std::cmp::Eq for INTENT_TO_SEAL_ATTRIBUTE {}
918 #[cfg(feature = "Win32_Foundation")]
919 unsafe impl ::windows::runtime::Abi for INTENT_TO_SEAL_ATTRIBUTE {
920     type Abi = Self;
921     type DefaultType = Self;
922 }
923 #[cfg(feature = "Win32_Foundation")]
924 #[inline]
925 pub unsafe fn OpenPersonalTrustDBDialog<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hwndparent: Param0) -> super::super::Foundation::BOOL {
926     #[cfg(windows)]
927     {
928         #[link(name = "windows")]
929         extern "system" {
930             fn OpenPersonalTrustDBDialog(hwndparent: super::super::Foundation::HWND) -> super::super::Foundation::BOOL;
931         }
932         ::std::mem::transmute(OpenPersonalTrustDBDialog(hwndparent.into_param().abi()))
933     }
934     #[cfg(not(windows))]
935     unimplemented!("Unsupported target OS");
936 }
937 #[cfg(feature = "Win32_Foundation")]
938 #[inline]
939 pub unsafe fn OpenPersonalTrustDBDialogEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hwndparent: Param0, dwflags: u32, pvreserved: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
940     #[cfg(windows)]
941     {
942         #[link(name = "windows")]
943         extern "system" {
944             fn OpenPersonalTrustDBDialogEx(hwndparent: super::super::Foundation::HWND, dwflags: u32, pvreserved: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
945         }
946         ::std::mem::transmute(OpenPersonalTrustDBDialogEx(hwndparent.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvreserved)))
947     }
948     #[cfg(not(windows))]
949     unimplemented!("Unsupported target OS");
950 }
951 #[cfg(feature = "Win32_Foundation")]
952 pub type PFN_ALLOCANDFILLDEFUSAGE = unsafe extern "system" fn(pszusageoid: super::super::Foundation::PSTR, psdefusage: *const CRYPT_PROVIDER_DEFUSAGE) -> super::super::Foundation::BOOL;
953 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
954 pub type PFN_CPD_ADD_CERT = unsafe extern "system" fn(pprovdata: *const CRYPT_PROVIDER_DATA, idxsigner: u32, fcountersigner: super::super::Foundation::BOOL, idxcountersigner: u32, pcert2add: *const super::Cryptography::CERT_CONTEXT) -> super::super::Foundation::BOOL;
955 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
956 pub type PFN_CPD_ADD_PRIVDATA = unsafe extern "system" fn(pprovdata: *const CRYPT_PROVIDER_DATA, pprivdata2add: *const CRYPT_PROVIDER_PRIVDATA) -> super::super::Foundation::BOOL;
957 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
958 pub type PFN_CPD_ADD_SGNR = unsafe extern "system" fn(pprovdata: *const CRYPT_PROVIDER_DATA, fcountersigner: super::super::Foundation::BOOL, idxsigner: u32, psgnr2add: *const CRYPT_PROVIDER_SGNR) -> super::super::Foundation::BOOL;
959 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
960 pub type PFN_CPD_ADD_STORE = unsafe extern "system" fn(pprovdata: *const CRYPT_PROVIDER_DATA, hstore2add: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
961 pub type PFN_CPD_MEM_ALLOC = unsafe extern "system" fn(cbsize: u32) -> *mut ::std::ffi::c_void;
962 pub type PFN_CPD_MEM_FREE = unsafe extern "system" fn(pvmem2free: *const ::std::ffi::c_void);
963 #[cfg(feature = "Win32_Foundation")]
964 pub type PFN_FREEDEFUSAGE = unsafe extern "system" fn(pszusageoid: super::super::Foundation::PSTR, psdefusage: *const CRYPT_PROVIDER_DEFUSAGE) -> super::super::Foundation::BOOL;
965 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
966 pub type PFN_PROVIDER_CERTCHKPOLICY_CALL = unsafe extern "system" fn(pprovdata: *const CRYPT_PROVIDER_DATA, idxsigner: u32, fcountersignerchain: super::super::Foundation::BOOL, idxcountersigner: u32) -> super::super::Foundation::BOOL;
967 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
968 pub type PFN_PROVIDER_CERTTRUST_CALL = unsafe extern "system" fn(pprovdata: *mut CRYPT_PROVIDER_DATA) -> ::windows::runtime::HRESULT;
969 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
970 pub type PFN_PROVIDER_CLEANUP_CALL = unsafe extern "system" fn(pprovdata: *mut CRYPT_PROVIDER_DATA) -> ::windows::runtime::HRESULT;
971 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
972 pub type PFN_PROVIDER_FINALPOLICY_CALL = unsafe extern "system" fn(pprovdata: *mut CRYPT_PROVIDER_DATA) -> ::windows::runtime::HRESULT;
973 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
974 pub type PFN_PROVIDER_INIT_CALL = unsafe extern "system" fn(pprovdata: *mut CRYPT_PROVIDER_DATA) -> ::windows::runtime::HRESULT;
975 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
976 pub type PFN_PROVIDER_OBJTRUST_CALL = unsafe extern "system" fn(pprovdata: *mut CRYPT_PROVIDER_DATA) -> ::windows::runtime::HRESULT;
977 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
978 pub type PFN_PROVIDER_SIGTRUST_CALL = unsafe extern "system" fn(pprovdata: *mut CRYPT_PROVIDER_DATA) -> ::windows::runtime::HRESULT;
979 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
980 pub type PFN_PROVIDER_TESTFINALPOLICY_CALL = unsafe extern "system" fn(pprovdata: *mut CRYPT_PROVIDER_DATA) -> ::windows::runtime::HRESULT;
981 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
982 pub type PFN_PROVUI_CALL = unsafe extern "system" fn(hwndsecuritydialog: super::super::Foundation::HWND, pprovdata: *const CRYPT_PROVIDER_DATA) -> super::super::Foundation::BOOL;
983 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
984 pub type PFN_WTD_GENERIC_CHAIN_POLICY_CALLBACK = unsafe extern "system" fn(pprovdata: *mut CRYPT_PROVIDER_DATA, dwsteperror: u32, dwregpolicysettings: u32, csigner: u32, rgpsigner: *mut *mut WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO, pvpolicyarg: *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
985 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
986 #[repr(C)]
987 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
988 pub struct PROVDATA_SIP {
989     pub cbStruct: u32,
990     pub gSubject: ::windows::runtime::GUID,
991     pub pSip: *mut super::Cryptography::Sip::SIP_DISPATCH_INFO,
992     pub pCATSip: *mut super::Cryptography::Sip::SIP_DISPATCH_INFO,
993     pub psSipSubjectInfo: *mut super::Cryptography::Sip::SIP_SUBJECTINFO,
994     pub psSipCATSubjectInfo: *mut super::Cryptography::Sip::SIP_SUBJECTINFO,
995     pub psIndirectData: *mut super::Cryptography::Sip::SIP_INDIRECT_DATA,
996 }
997 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
998 impl PROVDATA_SIP {}
999 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
1000 impl ::std::default::Default for PROVDATA_SIP {
1001     fn default() -> Self {
1002         unsafe { ::std::mem::zeroed() }
1003     }
1004 }
1005 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
1006 impl ::std::fmt::Debug for PROVDATA_SIP {
1007     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1008         fmt.debug_struct("PROVDATA_SIP")
1009             .field("cbStruct", &self.cbStruct)
1010             .field("gSubject", &self.gSubject)
1011             .field("pSip", &self.pSip)
1012             .field("pCATSip", &self.pCATSip)
1013             .field("psSipSubjectInfo", &self.psSipSubjectInfo)
1014             .field("psSipCATSubjectInfo", &self.psSipCATSubjectInfo)
1015             .field("psIndirectData", &self.psIndirectData)
1016             .finish()
1017     }
1018 }
1019 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
1020 impl ::std::cmp::PartialEq for PROVDATA_SIP {
1021     fn eq(&self, other: &Self) -> bool {
1022         self.cbStruct == other.cbStruct && self.gSubject == other.gSubject && self.pSip == other.pSip && self.pCATSip == other.pCATSip && self.psSipSubjectInfo == other.psSipSubjectInfo && self.psSipCATSubjectInfo == other.psSipCATSubjectInfo && self.psIndirectData == other.psIndirectData
1023     }
1024 }
1025 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
1026 impl ::std::cmp::Eq for PROVDATA_SIP {}
1027 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
1028 unsafe impl ::windows::runtime::Abi for PROVDATA_SIP {
1029     type Abi = Self;
1030     type DefaultType = Self;
1031 }
1032 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1033 #[repr(C)]
1034 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1035 pub struct SEALING_SIGNATURE_ATTRIBUTE {
1036     pub version: u32,
1037     pub signerIndex: u32,
1038     pub signatureAlgorithm: super::Cryptography::CRYPT_ALGORITHM_IDENTIFIER,
1039     pub encryptedDigest: super::Cryptography::CRYPTOAPI_BLOB,
1040 }
1041 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1042 impl SEALING_SIGNATURE_ATTRIBUTE {}
1043 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1044 impl ::std::default::Default for SEALING_SIGNATURE_ATTRIBUTE {
1045     fn default() -> Self {
1046         unsafe { ::std::mem::zeroed() }
1047     }
1048 }
1049 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1050 impl ::std::fmt::Debug for SEALING_SIGNATURE_ATTRIBUTE {
1051     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1052         fmt.debug_struct("SEALING_SIGNATURE_ATTRIBUTE").field("version", &self.version).field("signerIndex", &self.signerIndex).field("signatureAlgorithm", &self.signatureAlgorithm).field("encryptedDigest", &self.encryptedDigest).finish()
1053     }
1054 }
1055 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1056 impl ::std::cmp::PartialEq for SEALING_SIGNATURE_ATTRIBUTE {
1057     fn eq(&self, other: &Self) -> bool {
1058         self.version == other.version && self.signerIndex == other.signerIndex && self.signatureAlgorithm == other.signatureAlgorithm && self.encryptedDigest == other.encryptedDigest
1059     }
1060 }
1061 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1062 impl ::std::cmp::Eq for SEALING_SIGNATURE_ATTRIBUTE {}
1063 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1064 unsafe impl ::windows::runtime::Abi for SEALING_SIGNATURE_ATTRIBUTE {
1065     type Abi = Self;
1066     type DefaultType = Self;
1067 }
1068 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1069 #[repr(C)]
1070 #[cfg(feature = "Win32_Security_Cryptography")]
1071 pub struct SEALING_TIMESTAMP_ATTRIBUTE {
1072     pub version: u32,
1073     pub signerIndex: u32,
1074     pub sealTimeStampToken: super::Cryptography::CRYPTOAPI_BLOB,
1075 }
1076 #[cfg(feature = "Win32_Security_Cryptography")]
1077 impl SEALING_TIMESTAMP_ATTRIBUTE {}
1078 #[cfg(feature = "Win32_Security_Cryptography")]
1079 impl ::std::default::Default for SEALING_TIMESTAMP_ATTRIBUTE {
1080     fn default() -> Self {
1081         unsafe { ::std::mem::zeroed() }
1082     }
1083 }
1084 #[cfg(feature = "Win32_Security_Cryptography")]
1085 impl ::std::fmt::Debug for SEALING_TIMESTAMP_ATTRIBUTE {
1086     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1087         fmt.debug_struct("SEALING_TIMESTAMP_ATTRIBUTE").field("version", &self.version).field("signerIndex", &self.signerIndex).field("sealTimeStampToken", &self.sealTimeStampToken).finish()
1088     }
1089 }
1090 #[cfg(feature = "Win32_Security_Cryptography")]
1091 impl ::std::cmp::PartialEq for SEALING_TIMESTAMP_ATTRIBUTE {
1092     fn eq(&self, other: &Self) -> bool {
1093         self.version == other.version && self.signerIndex == other.signerIndex && self.sealTimeStampToken == other.sealTimeStampToken
1094     }
1095 }
1096 #[cfg(feature = "Win32_Security_Cryptography")]
1097 impl ::std::cmp::Eq for SEALING_TIMESTAMP_ATTRIBUTE {}
1098 #[cfg(feature = "Win32_Security_Cryptography")]
1099 unsafe impl ::windows::runtime::Abi for SEALING_TIMESTAMP_ATTRIBUTE {
1100     type Abi = Self;
1101     type DefaultType = Self;
1102 }
1103 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1104 #[repr(C)]
1105 #[cfg(feature = "Win32_Foundation")]
1106 pub struct SPC_FINANCIAL_CRITERIA {
1107     pub fFinancialInfoAvailable: super::super::Foundation::BOOL,
1108     pub fMeetsCriteria: super::super::Foundation::BOOL,
1109 }
1110 #[cfg(feature = "Win32_Foundation")]
1111 impl SPC_FINANCIAL_CRITERIA {}
1112 #[cfg(feature = "Win32_Foundation")]
1113 impl ::std::default::Default for SPC_FINANCIAL_CRITERIA {
1114     fn default() -> Self {
1115         unsafe { ::std::mem::zeroed() }
1116     }
1117 }
1118 #[cfg(feature = "Win32_Foundation")]
1119 impl ::std::fmt::Debug for SPC_FINANCIAL_CRITERIA {
1120     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1121         fmt.debug_struct("SPC_FINANCIAL_CRITERIA").field("fFinancialInfoAvailable", &self.fFinancialInfoAvailable).field("fMeetsCriteria", &self.fMeetsCriteria).finish()
1122     }
1123 }
1124 #[cfg(feature = "Win32_Foundation")]
1125 impl ::std::cmp::PartialEq for SPC_FINANCIAL_CRITERIA {
1126     fn eq(&self, other: &Self) -> bool {
1127         self.fFinancialInfoAvailable == other.fFinancialInfoAvailable && self.fMeetsCriteria == other.fMeetsCriteria
1128     }
1129 }
1130 #[cfg(feature = "Win32_Foundation")]
1131 impl ::std::cmp::Eq for SPC_FINANCIAL_CRITERIA {}
1132 #[cfg(feature = "Win32_Foundation")]
1133 unsafe impl ::windows::runtime::Abi for SPC_FINANCIAL_CRITERIA {
1134     type Abi = Self;
1135     type DefaultType = Self;
1136 }
1137 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1138 #[repr(C)]
1139 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1140 pub struct SPC_IMAGE {
1141     pub pImageLink: *mut SPC_LINK,
1142     pub Bitmap: super::Cryptography::CRYPTOAPI_BLOB,
1143     pub Metafile: super::Cryptography::CRYPTOAPI_BLOB,
1144     pub EnhancedMetafile: super::Cryptography::CRYPTOAPI_BLOB,
1145     pub GifFile: super::Cryptography::CRYPTOAPI_BLOB,
1146 }
1147 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1148 impl SPC_IMAGE {}
1149 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1150 impl ::std::default::Default for SPC_IMAGE {
1151     fn default() -> Self {
1152         unsafe { ::std::mem::zeroed() }
1153     }
1154 }
1155 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1156 impl ::std::fmt::Debug for SPC_IMAGE {
1157     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1158         fmt.debug_struct("SPC_IMAGE").field("pImageLink", &self.pImageLink).field("Bitmap", &self.Bitmap).field("Metafile", &self.Metafile).field("EnhancedMetafile", &self.EnhancedMetafile).field("GifFile", &self.GifFile).finish()
1159     }
1160 }
1161 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1162 impl ::std::cmp::PartialEq for SPC_IMAGE {
1163     fn eq(&self, other: &Self) -> bool {
1164         self.pImageLink == other.pImageLink && self.Bitmap == other.Bitmap && self.Metafile == other.Metafile && self.EnhancedMetafile == other.EnhancedMetafile && self.GifFile == other.GifFile
1165     }
1166 }
1167 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1168 impl ::std::cmp::Eq for SPC_IMAGE {}
1169 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1170 unsafe impl ::windows::runtime::Abi for SPC_IMAGE {
1171     type Abi = Self;
1172     type DefaultType = Self;
1173 }
1174 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1175 #[repr(C)]
1176 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1177 pub struct SPC_INDIRECT_DATA_CONTENT {
1178     pub Data: super::Cryptography::CRYPT_ATTRIBUTE_TYPE_VALUE,
1179     pub DigestAlgorithm: super::Cryptography::CRYPT_ALGORITHM_IDENTIFIER,
1180     pub Digest: super::Cryptography::CRYPTOAPI_BLOB,
1181 }
1182 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1183 impl SPC_INDIRECT_DATA_CONTENT {}
1184 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1185 impl ::std::default::Default for SPC_INDIRECT_DATA_CONTENT {
1186     fn default() -> Self {
1187         unsafe { ::std::mem::zeroed() }
1188     }
1189 }
1190 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1191 impl ::std::fmt::Debug for SPC_INDIRECT_DATA_CONTENT {
1192     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1193         fmt.debug_struct("SPC_INDIRECT_DATA_CONTENT").field("Data", &self.Data).field("DigestAlgorithm", &self.DigestAlgorithm).field("Digest", &self.Digest).finish()
1194     }
1195 }
1196 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1197 impl ::std::cmp::PartialEq for SPC_INDIRECT_DATA_CONTENT {
1198     fn eq(&self, other: &Self) -> bool {
1199         self.Data == other.Data && self.DigestAlgorithm == other.DigestAlgorithm && self.Digest == other.Digest
1200     }
1201 }
1202 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1203 impl ::std::cmp::Eq for SPC_INDIRECT_DATA_CONTENT {}
1204 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1205 unsafe impl ::windows::runtime::Abi for SPC_INDIRECT_DATA_CONTENT {
1206     type Abi = Self;
1207     type DefaultType = Self;
1208 }
1209 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1210 #[repr(C)]
1211 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1212 pub struct SPC_LINK {
1213     pub dwLinkChoice: u32,
1214     pub Anonymous: SPC_LINK_0,
1215 }
1216 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1217 impl SPC_LINK {}
1218 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1219 impl ::std::default::Default for SPC_LINK {
1220     fn default() -> Self {
1221         unsafe { ::std::mem::zeroed() }
1222     }
1223 }
1224 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1225 impl ::std::cmp::PartialEq for SPC_LINK {
1226     fn eq(&self, _other: &Self) -> bool {
1227         unimplemented!()
1228     }
1229 }
1230 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1231 impl ::std::cmp::Eq for SPC_LINK {}
1232 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1233 unsafe impl ::windows::runtime::Abi for SPC_LINK {
1234     type Abi = Self;
1235     type DefaultType = Self;
1236 }
1237 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1238 #[repr(C)]
1239 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1240 pub union SPC_LINK_0 {
1241     pub pwszUrl: super::super::Foundation::PWSTR,
1242     pub Moniker: SPC_SERIALIZED_OBJECT,
1243     pub pwszFile: super::super::Foundation::PWSTR,
1244 }
1245 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1246 impl SPC_LINK_0 {}
1247 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1248 impl ::std::default::Default for SPC_LINK_0 {
1249     fn default() -> Self {
1250         unsafe { ::std::mem::zeroed() }
1251     }
1252 }
1253 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1254 impl ::std::cmp::PartialEq for SPC_LINK_0 {
1255     fn eq(&self, _other: &Self) -> bool {
1256         unimplemented!()
1257     }
1258 }
1259 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1260 impl ::std::cmp::Eq for SPC_LINK_0 {}
1261 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1262 unsafe impl ::windows::runtime::Abi for SPC_LINK_0 {
1263     type Abi = Self;
1264     type DefaultType = Self;
1265 }
1266 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1267 #[repr(C)]
1268 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1269 pub struct SPC_PE_IMAGE_DATA {
1270     pub Flags: super::Cryptography::CRYPT_BIT_BLOB,
1271     pub pFile: *mut SPC_LINK,
1272 }
1273 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1274 impl SPC_PE_IMAGE_DATA {}
1275 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1276 impl ::std::default::Default for SPC_PE_IMAGE_DATA {
1277     fn default() -> Self {
1278         unsafe { ::std::mem::zeroed() }
1279     }
1280 }
1281 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1282 impl ::std::fmt::Debug for SPC_PE_IMAGE_DATA {
1283     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1284         fmt.debug_struct("SPC_PE_IMAGE_DATA").field("Flags", &self.Flags).field("pFile", &self.pFile).finish()
1285     }
1286 }
1287 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1288 impl ::std::cmp::PartialEq for SPC_PE_IMAGE_DATA {
1289     fn eq(&self, other: &Self) -> bool {
1290         self.Flags == other.Flags && self.pFile == other.pFile
1291     }
1292 }
1293 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1294 impl ::std::cmp::Eq for SPC_PE_IMAGE_DATA {}
1295 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1296 unsafe impl ::windows::runtime::Abi for SPC_PE_IMAGE_DATA {
1297     type Abi = Self;
1298     type DefaultType = Self;
1299 }
1300 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1301 #[repr(C)]
1302 #[cfg(feature = "Win32_Security_Cryptography")]
1303 pub struct SPC_SERIALIZED_OBJECT {
1304     pub ClassId: [u8; 16],
1305     pub SerializedData: super::Cryptography::CRYPTOAPI_BLOB,
1306 }
1307 #[cfg(feature = "Win32_Security_Cryptography")]
1308 impl SPC_SERIALIZED_OBJECT {}
1309 #[cfg(feature = "Win32_Security_Cryptography")]
1310 impl ::std::default::Default for SPC_SERIALIZED_OBJECT {
1311     fn default() -> Self {
1312         unsafe { ::std::mem::zeroed() }
1313     }
1314 }
1315 #[cfg(feature = "Win32_Security_Cryptography")]
1316 impl ::std::fmt::Debug for SPC_SERIALIZED_OBJECT {
1317     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1318         fmt.debug_struct("SPC_SERIALIZED_OBJECT").field("ClassId", &self.ClassId).field("SerializedData", &self.SerializedData).finish()
1319     }
1320 }
1321 #[cfg(feature = "Win32_Security_Cryptography")]
1322 impl ::std::cmp::PartialEq for SPC_SERIALIZED_OBJECT {
1323     fn eq(&self, other: &Self) -> bool {
1324         self.ClassId == other.ClassId && self.SerializedData == other.SerializedData
1325     }
1326 }
1327 #[cfg(feature = "Win32_Security_Cryptography")]
1328 impl ::std::cmp::Eq for SPC_SERIALIZED_OBJECT {}
1329 #[cfg(feature = "Win32_Security_Cryptography")]
1330 unsafe impl ::windows::runtime::Abi for SPC_SERIALIZED_OBJECT {
1331     type Abi = Self;
1332     type DefaultType = Self;
1333 }
1334 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1335 #[repr(C)]
1336 pub struct SPC_SIGINFO {
1337     pub dwSipVersion: u32,
1338     pub gSIPGuid: ::windows::runtime::GUID,
1339     pub dwReserved1: u32,
1340     pub dwReserved2: u32,
1341     pub dwReserved3: u32,
1342     pub dwReserved4: u32,
1343     pub dwReserved5: u32,
1344 }
1345 impl SPC_SIGINFO {}
1346 impl ::std::default::Default for SPC_SIGINFO {
1347     fn default() -> Self {
1348         unsafe { ::std::mem::zeroed() }
1349     }
1350 }
1351 impl ::std::fmt::Debug for SPC_SIGINFO {
1352     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1353         fmt.debug_struct("SPC_SIGINFO")
1354             .field("dwSipVersion", &self.dwSipVersion)
1355             .field("gSIPGuid", &self.gSIPGuid)
1356             .field("dwReserved1", &self.dwReserved1)
1357             .field("dwReserved2", &self.dwReserved2)
1358             .field("dwReserved3", &self.dwReserved3)
1359             .field("dwReserved4", &self.dwReserved4)
1360             .field("dwReserved5", &self.dwReserved5)
1361             .finish()
1362     }
1363 }
1364 impl ::std::cmp::PartialEq for SPC_SIGINFO {
1365     fn eq(&self, other: &Self) -> bool {
1366         self.dwSipVersion == other.dwSipVersion && self.gSIPGuid == other.gSIPGuid && self.dwReserved1 == other.dwReserved1 && self.dwReserved2 == other.dwReserved2 && self.dwReserved3 == other.dwReserved3 && self.dwReserved4 == other.dwReserved4 && self.dwReserved5 == other.dwReserved5
1367     }
1368 }
1369 impl ::std::cmp::Eq for SPC_SIGINFO {}
1370 unsafe impl ::windows::runtime::Abi for SPC_SIGINFO {
1371     type Abi = Self;
1372     type DefaultType = Self;
1373 }
1374 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1375 #[repr(C)]
1376 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1377 pub struct SPC_SP_AGENCY_INFO {
1378     pub pPolicyInformation: *mut SPC_LINK,
1379     pub pwszPolicyDisplayText: super::super::Foundation::PWSTR,
1380     pub pLogoImage: *mut SPC_IMAGE,
1381     pub pLogoLink: *mut SPC_LINK,
1382 }
1383 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1384 impl SPC_SP_AGENCY_INFO {}
1385 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1386 impl ::std::default::Default for SPC_SP_AGENCY_INFO {
1387     fn default() -> Self {
1388         unsafe { ::std::mem::zeroed() }
1389     }
1390 }
1391 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1392 impl ::std::fmt::Debug for SPC_SP_AGENCY_INFO {
1393     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1394         fmt.debug_struct("SPC_SP_AGENCY_INFO").field("pPolicyInformation", &self.pPolicyInformation).field("pwszPolicyDisplayText", &self.pwszPolicyDisplayText).field("pLogoImage", &self.pLogoImage).field("pLogoLink", &self.pLogoLink).finish()
1395     }
1396 }
1397 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1398 impl ::std::cmp::PartialEq for SPC_SP_AGENCY_INFO {
1399     fn eq(&self, other: &Self) -> bool {
1400         self.pPolicyInformation == other.pPolicyInformation && self.pwszPolicyDisplayText == other.pwszPolicyDisplayText && self.pLogoImage == other.pLogoImage && self.pLogoLink == other.pLogoLink
1401     }
1402 }
1403 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1404 impl ::std::cmp::Eq for SPC_SP_AGENCY_INFO {}
1405 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1406 unsafe impl ::windows::runtime::Abi for SPC_SP_AGENCY_INFO {
1407     type Abi = Self;
1408     type DefaultType = Self;
1409 }
1410 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1411 #[repr(C)]
1412 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1413 pub struct SPC_SP_OPUS_INFO {
1414     pub pwszProgramName: super::super::Foundation::PWSTR,
1415     pub pMoreInfo: *mut SPC_LINK,
1416     pub pPublisherInfo: *mut SPC_LINK,
1417 }
1418 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1419 impl SPC_SP_OPUS_INFO {}
1420 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1421 impl ::std::default::Default for SPC_SP_OPUS_INFO {
1422     fn default() -> Self {
1423         unsafe { ::std::mem::zeroed() }
1424     }
1425 }
1426 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1427 impl ::std::fmt::Debug for SPC_SP_OPUS_INFO {
1428     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1429         fmt.debug_struct("SPC_SP_OPUS_INFO").field("pwszProgramName", &self.pwszProgramName).field("pMoreInfo", &self.pMoreInfo).field("pPublisherInfo", &self.pPublisherInfo).finish()
1430     }
1431 }
1432 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1433 impl ::std::cmp::PartialEq for SPC_SP_OPUS_INFO {
1434     fn eq(&self, other: &Self) -> bool {
1435         self.pwszProgramName == other.pwszProgramName && self.pMoreInfo == other.pMoreInfo && self.pPublisherInfo == other.pPublisherInfo
1436     }
1437 }
1438 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1439 impl ::std::cmp::Eq for SPC_SP_OPUS_INFO {}
1440 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1441 unsafe impl ::windows::runtime::Abi for SPC_SP_OPUS_INFO {
1442     type Abi = Self;
1443     type DefaultType = Self;
1444 }
1445 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1446 #[repr(C)]
1447 #[cfg(feature = "Win32_Foundation")]
1448 pub struct SPC_STATEMENT_TYPE {
1449     pub cKeyPurposeId: u32,
1450     pub rgpszKeyPurposeId: *mut super::super::Foundation::PSTR,
1451 }
1452 #[cfg(feature = "Win32_Foundation")]
1453 impl SPC_STATEMENT_TYPE {}
1454 #[cfg(feature = "Win32_Foundation")]
1455 impl ::std::default::Default for SPC_STATEMENT_TYPE {
1456     fn default() -> Self {
1457         unsafe { ::std::mem::zeroed() }
1458     }
1459 }
1460 #[cfg(feature = "Win32_Foundation")]
1461 impl ::std::fmt::Debug for SPC_STATEMENT_TYPE {
1462     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1463         fmt.debug_struct("SPC_STATEMENT_TYPE").field("cKeyPurposeId", &self.cKeyPurposeId).field("rgpszKeyPurposeId", &self.rgpszKeyPurposeId).finish()
1464     }
1465 }
1466 #[cfg(feature = "Win32_Foundation")]
1467 impl ::std::cmp::PartialEq for SPC_STATEMENT_TYPE {
1468     fn eq(&self, other: &Self) -> bool {
1469         self.cKeyPurposeId == other.cKeyPurposeId && self.rgpszKeyPurposeId == other.rgpszKeyPurposeId
1470     }
1471 }
1472 #[cfg(feature = "Win32_Foundation")]
1473 impl ::std::cmp::Eq for SPC_STATEMENT_TYPE {}
1474 #[cfg(feature = "Win32_Foundation")]
1475 unsafe impl ::windows::runtime::Abi for SPC_STATEMENT_TYPE {
1476     type Abi = Self;
1477     type DefaultType = Self;
1478 }
1479 pub const SPC_UUID_LENGTH: u32 = 16u32;
1480 pub const TRUSTERROR_MAX_STEPS: u32 = 38u32;
1481 pub const TRUSTERROR_STEP_CATALOGFILE: u32 = 6u32;
1482 pub const TRUSTERROR_STEP_CERTSTORE: u32 = 7u32;
1483 pub const TRUSTERROR_STEP_FILEIO: u32 = 2u32;
1484 pub const TRUSTERROR_STEP_FINAL_CERTCHKPROV: u32 = 35u32;
1485 pub const TRUSTERROR_STEP_FINAL_CERTPROV: u32 = 34u32;
1486 pub const TRUSTERROR_STEP_FINAL_INITPROV: u32 = 31u32;
1487 pub const TRUSTERROR_STEP_FINAL_OBJPROV: u32 = 32u32;
1488 pub const TRUSTERROR_STEP_FINAL_POLICYPROV: u32 = 36u32;
1489 pub const TRUSTERROR_STEP_FINAL_SIGPROV: u32 = 33u32;
1490 pub const TRUSTERROR_STEP_FINAL_UIPROV: u32 = 37u32;
1491 pub const TRUSTERROR_STEP_FINAL_WVTINIT: u32 = 30u32;
1492 pub const TRUSTERROR_STEP_MESSAGE: u32 = 8u32;
1493 pub const TRUSTERROR_STEP_MSG_CERTCHAIN: u32 = 15u32;
1494 pub const TRUSTERROR_STEP_MSG_COUNTERSIGCERT: u32 = 17u32;
1495 pub const TRUSTERROR_STEP_MSG_COUNTERSIGINFO: u32 = 16u32;
1496 pub const TRUSTERROR_STEP_MSG_INNERCNT: u32 = 11u32;
1497 pub const TRUSTERROR_STEP_MSG_INNERCNTTYPE: u32 = 10u32;
1498 pub const TRUSTERROR_STEP_MSG_SIGNERCERT: u32 = 14u32;
1499 pub const TRUSTERROR_STEP_MSG_SIGNERCOUNT: u32 = 9u32;
1500 pub const TRUSTERROR_STEP_MSG_SIGNERINFO: u32 = 13u32;
1501 pub const TRUSTERROR_STEP_MSG_STORE: u32 = 12u32;
1502 pub const TRUSTERROR_STEP_SIP: u32 = 3u32;
1503 pub const TRUSTERROR_STEP_SIPSUBJINFO: u32 = 5u32;
1504 pub const TRUSTERROR_STEP_VERIFY_MSGHASH: u32 = 18u32;
1505 pub const TRUSTERROR_STEP_VERIFY_MSGINDIRECTDATA: u32 = 19u32;
1506 pub const TRUSTERROR_STEP_WVTPARAMS: u32 = 0u32;
1507 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1508 #[repr(C)]
1509 #[cfg(feature = "Win32_Foundation")]
1510 pub struct WINTRUST_BLOB_INFO {
1511     pub cbStruct: u32,
1512     pub gSubject: ::windows::runtime::GUID,
1513     pub pcwszDisplayName: super::super::Foundation::PWSTR,
1514     pub cbMemObject: u32,
1515     pub pbMemObject: *mut u8,
1516     pub cbMemSignedMsg: u32,
1517     pub pbMemSignedMsg: *mut u8,
1518 }
1519 #[cfg(feature = "Win32_Foundation")]
1520 impl WINTRUST_BLOB_INFO {}
1521 #[cfg(feature = "Win32_Foundation")]
1522 impl ::std::default::Default for WINTRUST_BLOB_INFO {
1523     fn default() -> Self {
1524         unsafe { ::std::mem::zeroed() }
1525     }
1526 }
1527 #[cfg(feature = "Win32_Foundation")]
1528 impl ::std::fmt::Debug for WINTRUST_BLOB_INFO {
1529     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1530         fmt.debug_struct("WINTRUST_BLOB_INFO")
1531             .field("cbStruct", &self.cbStruct)
1532             .field("gSubject", &self.gSubject)
1533             .field("pcwszDisplayName", &self.pcwszDisplayName)
1534             .field("cbMemObject", &self.cbMemObject)
1535             .field("pbMemObject", &self.pbMemObject)
1536             .field("cbMemSignedMsg", &self.cbMemSignedMsg)
1537             .field("pbMemSignedMsg", &self.pbMemSignedMsg)
1538             .finish()
1539     }
1540 }
1541 #[cfg(feature = "Win32_Foundation")]
1542 impl ::std::cmp::PartialEq for WINTRUST_BLOB_INFO {
1543     fn eq(&self, other: &Self) -> bool {
1544         self.cbStruct == other.cbStruct && self.gSubject == other.gSubject && self.pcwszDisplayName == other.pcwszDisplayName && self.cbMemObject == other.cbMemObject && self.pbMemObject == other.pbMemObject && self.cbMemSignedMsg == other.cbMemSignedMsg && self.pbMemSignedMsg == other.pbMemSignedMsg
1545     }
1546 }
1547 #[cfg(feature = "Win32_Foundation")]
1548 impl ::std::cmp::Eq for WINTRUST_BLOB_INFO {}
1549 #[cfg(feature = "Win32_Foundation")]
1550 unsafe impl ::windows::runtime::Abi for WINTRUST_BLOB_INFO {
1551     type Abi = Self;
1552     type DefaultType = Self;
1553 }
1554 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1555 #[repr(C)]
1556 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1557 pub struct WINTRUST_CATALOG_INFO {
1558     pub cbStruct: u32,
1559     pub dwCatalogVersion: u32,
1560     pub pcwszCatalogFilePath: super::super::Foundation::PWSTR,
1561     pub pcwszMemberTag: super::super::Foundation::PWSTR,
1562     pub pcwszMemberFilePath: super::super::Foundation::PWSTR,
1563     pub hMemberFile: super::super::Foundation::HANDLE,
1564     pub pbCalculatedFileHash: *mut u8,
1565     pub cbCalculatedFileHash: u32,
1566     pub pcCatalogContext: *mut super::Cryptography::CTL_CONTEXT,
1567     pub hCatAdmin: isize,
1568 }
1569 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1570 impl WINTRUST_CATALOG_INFO {}
1571 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1572 impl ::std::default::Default for WINTRUST_CATALOG_INFO {
1573     fn default() -> Self {
1574         unsafe { ::std::mem::zeroed() }
1575     }
1576 }
1577 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1578 impl ::std::fmt::Debug for WINTRUST_CATALOG_INFO {
1579     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1580         fmt.debug_struct("WINTRUST_CATALOG_INFO")
1581             .field("cbStruct", &self.cbStruct)
1582             .field("dwCatalogVersion", &self.dwCatalogVersion)
1583             .field("pcwszCatalogFilePath", &self.pcwszCatalogFilePath)
1584             .field("pcwszMemberTag", &self.pcwszMemberTag)
1585             .field("pcwszMemberFilePath", &self.pcwszMemberFilePath)
1586             .field("hMemberFile", &self.hMemberFile)
1587             .field("pbCalculatedFileHash", &self.pbCalculatedFileHash)
1588             .field("cbCalculatedFileHash", &self.cbCalculatedFileHash)
1589             .field("pcCatalogContext", &self.pcCatalogContext)
1590             .field("hCatAdmin", &self.hCatAdmin)
1591             .finish()
1592     }
1593 }
1594 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1595 impl ::std::cmp::PartialEq for WINTRUST_CATALOG_INFO {
1596     fn eq(&self, other: &Self) -> bool {
1597         self.cbStruct == other.cbStruct && self.dwCatalogVersion == other.dwCatalogVersion && self.pcwszCatalogFilePath == other.pcwszCatalogFilePath && self.pcwszMemberTag == other.pcwszMemberTag && self.pcwszMemberFilePath == other.pcwszMemberFilePath && self.hMemberFile == other.hMemberFile && self.pbCalculatedFileHash == other.pbCalculatedFileHash && self.cbCalculatedFileHash == other.cbCalculatedFileHash && self.pcCatalogContext == other.pcCatalogContext && self.hCatAdmin == other.hCatAdmin
1598     }
1599 }
1600 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1601 impl ::std::cmp::Eq for WINTRUST_CATALOG_INFO {}
1602 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1603 unsafe impl ::windows::runtime::Abi for WINTRUST_CATALOG_INFO {
1604     type Abi = Self;
1605     type DefaultType = Self;
1606 }
1607 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1608 #[repr(C)]
1609 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1610 pub struct WINTRUST_CERT_INFO {
1611     pub cbStruct: u32,
1612     pub pcwszDisplayName: super::super::Foundation::PWSTR,
1613     pub psCertContext: *mut super::Cryptography::CERT_CONTEXT,
1614     pub chStores: u32,
1615     pub pahStores: *mut *mut ::std::ffi::c_void,
1616     pub dwFlags: u32,
1617     pub psftVerifyAsOf: *mut super::super::Foundation::FILETIME,
1618 }
1619 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1620 impl WINTRUST_CERT_INFO {}
1621 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1622 impl ::std::default::Default for WINTRUST_CERT_INFO {
1623     fn default() -> Self {
1624         unsafe { ::std::mem::zeroed() }
1625     }
1626 }
1627 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1628 impl ::std::fmt::Debug for WINTRUST_CERT_INFO {
1629     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1630         fmt.debug_struct("WINTRUST_CERT_INFO")
1631             .field("cbStruct", &self.cbStruct)
1632             .field("pcwszDisplayName", &self.pcwszDisplayName)
1633             .field("psCertContext", &self.psCertContext)
1634             .field("chStores", &self.chStores)
1635             .field("pahStores", &self.pahStores)
1636             .field("dwFlags", &self.dwFlags)
1637             .field("psftVerifyAsOf", &self.psftVerifyAsOf)
1638             .finish()
1639     }
1640 }
1641 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1642 impl ::std::cmp::PartialEq for WINTRUST_CERT_INFO {
1643     fn eq(&self, other: &Self) -> bool {
1644         self.cbStruct == other.cbStruct && self.pcwszDisplayName == other.pcwszDisplayName && self.psCertContext == other.psCertContext && self.chStores == other.chStores && self.pahStores == other.pahStores && self.dwFlags == other.dwFlags && self.psftVerifyAsOf == other.psftVerifyAsOf
1645     }
1646 }
1647 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1648 impl ::std::cmp::Eq for WINTRUST_CERT_INFO {}
1649 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1650 unsafe impl ::windows::runtime::Abi for WINTRUST_CERT_INFO {
1651     type Abi = Self;
1652     type DefaultType = Self;
1653 }
1654 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1655 #[repr(C)]
1656 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1657 pub struct WINTRUST_DATA {
1658     pub cbStruct: u32,
1659     pub pPolicyCallbackData: *mut ::std::ffi::c_void,
1660     pub pSIPClientData: *mut ::std::ffi::c_void,
1661     pub dwUIChoice: WINTRUST_DATA_UICHOICE,
1662     pub fdwRevocationChecks: WINTRUST_DATA_REVOCATION_CHECKS,
1663     pub dwUnionChoice: WINTRUST_DATA_UNION_CHOICE,
1664     pub Anonymous: WINTRUST_DATA_0,
1665     pub dwStateAction: WINTRUST_DATA_STATE_ACTION,
1666     pub hWVTStateData: super::super::Foundation::HANDLE,
1667     pub pwszURLReference: super::super::Foundation::PWSTR,
1668     pub dwProvFlags: u32,
1669     pub dwUIContext: WINTRUST_DATA_UICONTEXT,
1670     pub pSignatureSettings: *mut WINTRUST_SIGNATURE_SETTINGS,
1671 }
1672 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1673 impl WINTRUST_DATA {}
1674 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1675 impl ::std::default::Default for WINTRUST_DATA {
1676     fn default() -> Self {
1677         unsafe { ::std::mem::zeroed() }
1678     }
1679 }
1680 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1681 impl ::std::cmp::PartialEq for WINTRUST_DATA {
1682     fn eq(&self, _other: &Self) -> bool {
1683         unimplemented!()
1684     }
1685 }
1686 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1687 impl ::std::cmp::Eq for WINTRUST_DATA {}
1688 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1689 unsafe impl ::windows::runtime::Abi for WINTRUST_DATA {
1690     type Abi = Self;
1691     type DefaultType = Self;
1692 }
1693 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1694 #[repr(C)]
1695 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1696 pub union WINTRUST_DATA_0 {
1697     pub pFile: *mut WINTRUST_FILE_INFO,
1698     pub pCatalog: *mut WINTRUST_CATALOG_INFO,
1699     pub pBlob: *mut WINTRUST_BLOB_INFO,
1700     pub pSgnr: *mut WINTRUST_SGNR_INFO,
1701     pub pCert: *mut WINTRUST_CERT_INFO,
1702 }
1703 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1704 impl WINTRUST_DATA_0 {}
1705 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1706 impl ::std::default::Default for WINTRUST_DATA_0 {
1707     fn default() -> Self {
1708         unsafe { ::std::mem::zeroed() }
1709     }
1710 }
1711 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1712 impl ::std::cmp::PartialEq for WINTRUST_DATA_0 {
1713     fn eq(&self, _other: &Self) -> bool {
1714         unimplemented!()
1715     }
1716 }
1717 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1718 impl ::std::cmp::Eq for WINTRUST_DATA_0 {}
1719 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1720 unsafe impl ::windows::runtime::Abi for WINTRUST_DATA_0 {
1721     type Abi = Self;
1722     type DefaultType = Self;
1723 }
1724 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1725 #[repr(transparent)]
1726 pub struct WINTRUST_DATA_REVOCATION_CHECKS(pub u32);
1727 pub const WTD_REVOKE_NONE: WINTRUST_DATA_REVOCATION_CHECKS = WINTRUST_DATA_REVOCATION_CHECKS(0u32);
1728 pub const WTD_REVOKE_WHOLECHAIN: WINTRUST_DATA_REVOCATION_CHECKS = WINTRUST_DATA_REVOCATION_CHECKS(1u32);
1729 impl ::std::convert::From<u32> for WINTRUST_DATA_REVOCATION_CHECKS {
1730     fn from(value: u32) -> Self {
1731         Self(value)
1732     }
1733 }
1734 unsafe impl ::windows::runtime::Abi for WINTRUST_DATA_REVOCATION_CHECKS {
1735     type Abi = Self;
1736     type DefaultType = Self;
1737 }
1738 impl ::std::ops::BitOr for WINTRUST_DATA_REVOCATION_CHECKS {
1739     type Output = Self;
1740     fn bitor(self, rhs: Self) -> Self {
1741         Self(self.0 | rhs.0)
1742     }
1743 }
1744 impl ::std::ops::BitAnd for WINTRUST_DATA_REVOCATION_CHECKS {
1745     type Output = Self;
1746     fn bitand(self, rhs: Self) -> Self {
1747         Self(self.0 & rhs.0)
1748     }
1749 }
1750 impl ::std::ops::BitOrAssign for WINTRUST_DATA_REVOCATION_CHECKS {
1751     fn bitor_assign(&mut self, rhs: Self) {
1752         self.0.bitor_assign(rhs.0)
1753     }
1754 }
1755 impl ::std::ops::BitAndAssign for WINTRUST_DATA_REVOCATION_CHECKS {
1756     fn bitand_assign(&mut self, rhs: Self) {
1757         self.0.bitand_assign(rhs.0)
1758     }
1759 }
1760 impl ::std::ops::Not for WINTRUST_DATA_REVOCATION_CHECKS {
1761     type Output = Self;
1762     fn not(self) -> Self {
1763         Self(self.0.not())
1764     }
1765 }
1766 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1767 #[repr(transparent)]
1768 pub struct WINTRUST_DATA_STATE_ACTION(pub u32);
1769 pub const WTD_STATEACTION_IGNORE: WINTRUST_DATA_STATE_ACTION = WINTRUST_DATA_STATE_ACTION(0u32);
1770 pub const WTD_STATEACTION_VERIFY: WINTRUST_DATA_STATE_ACTION = WINTRUST_DATA_STATE_ACTION(1u32);
1771 pub const WTD_STATEACTION_CLOSE: WINTRUST_DATA_STATE_ACTION = WINTRUST_DATA_STATE_ACTION(2u32);
1772 pub const WTD_STATEACTION_AUTO_CACHE: WINTRUST_DATA_STATE_ACTION = WINTRUST_DATA_STATE_ACTION(3u32);
1773 pub const WTD_STATEACTION_AUTO_CACHE_FLUSH: WINTRUST_DATA_STATE_ACTION = WINTRUST_DATA_STATE_ACTION(4u32);
1774 impl ::std::convert::From<u32> for WINTRUST_DATA_STATE_ACTION {
1775     fn from(value: u32) -> Self {
1776         Self(value)
1777     }
1778 }
1779 unsafe impl ::windows::runtime::Abi for WINTRUST_DATA_STATE_ACTION {
1780     type Abi = Self;
1781     type DefaultType = Self;
1782 }
1783 impl ::std::ops::BitOr for WINTRUST_DATA_STATE_ACTION {
1784     type Output = Self;
1785     fn bitor(self, rhs: Self) -> Self {
1786         Self(self.0 | rhs.0)
1787     }
1788 }
1789 impl ::std::ops::BitAnd for WINTRUST_DATA_STATE_ACTION {
1790     type Output = Self;
1791     fn bitand(self, rhs: Self) -> Self {
1792         Self(self.0 & rhs.0)
1793     }
1794 }
1795 impl ::std::ops::BitOrAssign for WINTRUST_DATA_STATE_ACTION {
1796     fn bitor_assign(&mut self, rhs: Self) {
1797         self.0.bitor_assign(rhs.0)
1798     }
1799 }
1800 impl ::std::ops::BitAndAssign for WINTRUST_DATA_STATE_ACTION {
1801     fn bitand_assign(&mut self, rhs: Self) {
1802         self.0.bitand_assign(rhs.0)
1803     }
1804 }
1805 impl ::std::ops::Not for WINTRUST_DATA_STATE_ACTION {
1806     type Output = Self;
1807     fn not(self) -> Self {
1808         Self(self.0.not())
1809     }
1810 }
1811 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1812 #[repr(transparent)]
1813 pub struct WINTRUST_DATA_UICHOICE(pub u32);
1814 pub const WTD_UI_ALL: WINTRUST_DATA_UICHOICE = WINTRUST_DATA_UICHOICE(1u32);
1815 pub const WTD_UI_NONE: WINTRUST_DATA_UICHOICE = WINTRUST_DATA_UICHOICE(2u32);
1816 pub const WTD_UI_NOBAD: WINTRUST_DATA_UICHOICE = WINTRUST_DATA_UICHOICE(3u32);
1817 pub const WTD_UI_NOGOOD: WINTRUST_DATA_UICHOICE = WINTRUST_DATA_UICHOICE(4u32);
1818 impl ::std::convert::From<u32> for WINTRUST_DATA_UICHOICE {
1819     fn from(value: u32) -> Self {
1820         Self(value)
1821     }
1822 }
1823 unsafe impl ::windows::runtime::Abi for WINTRUST_DATA_UICHOICE {
1824     type Abi = Self;
1825     type DefaultType = Self;
1826 }
1827 impl ::std::ops::BitOr for WINTRUST_DATA_UICHOICE {
1828     type Output = Self;
1829     fn bitor(self, rhs: Self) -> Self {
1830         Self(self.0 | rhs.0)
1831     }
1832 }
1833 impl ::std::ops::BitAnd for WINTRUST_DATA_UICHOICE {
1834     type Output = Self;
1835     fn bitand(self, rhs: Self) -> Self {
1836         Self(self.0 & rhs.0)
1837     }
1838 }
1839 impl ::std::ops::BitOrAssign for WINTRUST_DATA_UICHOICE {
1840     fn bitor_assign(&mut self, rhs: Self) {
1841         self.0.bitor_assign(rhs.0)
1842     }
1843 }
1844 impl ::std::ops::BitAndAssign for WINTRUST_DATA_UICHOICE {
1845     fn bitand_assign(&mut self, rhs: Self) {
1846         self.0.bitand_assign(rhs.0)
1847     }
1848 }
1849 impl ::std::ops::Not for WINTRUST_DATA_UICHOICE {
1850     type Output = Self;
1851     fn not(self) -> Self {
1852         Self(self.0.not())
1853     }
1854 }
1855 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1856 #[repr(transparent)]
1857 pub struct WINTRUST_DATA_UICONTEXT(pub u32);
1858 pub const WTD_UICONTEXT_EXECUTE: WINTRUST_DATA_UICONTEXT = WINTRUST_DATA_UICONTEXT(0u32);
1859 pub const WTD_UICONTEXT_INSTALL: WINTRUST_DATA_UICONTEXT = WINTRUST_DATA_UICONTEXT(1u32);
1860 impl ::std::convert::From<u32> for WINTRUST_DATA_UICONTEXT {
1861     fn from(value: u32) -> Self {
1862         Self(value)
1863     }
1864 }
1865 unsafe impl ::windows::runtime::Abi for WINTRUST_DATA_UICONTEXT {
1866     type Abi = Self;
1867     type DefaultType = Self;
1868 }
1869 impl ::std::ops::BitOr for WINTRUST_DATA_UICONTEXT {
1870     type Output = Self;
1871     fn bitor(self, rhs: Self) -> Self {
1872         Self(self.0 | rhs.0)
1873     }
1874 }
1875 impl ::std::ops::BitAnd for WINTRUST_DATA_UICONTEXT {
1876     type Output = Self;
1877     fn bitand(self, rhs: Self) -> Self {
1878         Self(self.0 & rhs.0)
1879     }
1880 }
1881 impl ::std::ops::BitOrAssign for WINTRUST_DATA_UICONTEXT {
1882     fn bitor_assign(&mut self, rhs: Self) {
1883         self.0.bitor_assign(rhs.0)
1884     }
1885 }
1886 impl ::std::ops::BitAndAssign for WINTRUST_DATA_UICONTEXT {
1887     fn bitand_assign(&mut self, rhs: Self) {
1888         self.0.bitand_assign(rhs.0)
1889     }
1890 }
1891 impl ::std::ops::Not for WINTRUST_DATA_UICONTEXT {
1892     type Output = Self;
1893     fn not(self) -> Self {
1894         Self(self.0.not())
1895     }
1896 }
1897 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1898 #[repr(transparent)]
1899 pub struct WINTRUST_DATA_UNION_CHOICE(pub u32);
1900 pub const WTD_CHOICE_FILE: WINTRUST_DATA_UNION_CHOICE = WINTRUST_DATA_UNION_CHOICE(1u32);
1901 pub const WTD_CHOICE_CATALOG: WINTRUST_DATA_UNION_CHOICE = WINTRUST_DATA_UNION_CHOICE(2u32);
1902 pub const WTD_CHOICE_BLOB: WINTRUST_DATA_UNION_CHOICE = WINTRUST_DATA_UNION_CHOICE(3u32);
1903 pub const WTD_CHOICE_SIGNER: WINTRUST_DATA_UNION_CHOICE = WINTRUST_DATA_UNION_CHOICE(4u32);
1904 pub const WTD_CHOICE_CERT: WINTRUST_DATA_UNION_CHOICE = WINTRUST_DATA_UNION_CHOICE(5u32);
1905 impl ::std::convert::From<u32> for WINTRUST_DATA_UNION_CHOICE {
1906     fn from(value: u32) -> Self {
1907         Self(value)
1908     }
1909 }
1910 unsafe impl ::windows::runtime::Abi for WINTRUST_DATA_UNION_CHOICE {
1911     type Abi = Self;
1912     type DefaultType = Self;
1913 }
1914 impl ::std::ops::BitOr for WINTRUST_DATA_UNION_CHOICE {
1915     type Output = Self;
1916     fn bitor(self, rhs: Self) -> Self {
1917         Self(self.0 | rhs.0)
1918     }
1919 }
1920 impl ::std::ops::BitAnd for WINTRUST_DATA_UNION_CHOICE {
1921     type Output = Self;
1922     fn bitand(self, rhs: Self) -> Self {
1923         Self(self.0 & rhs.0)
1924     }
1925 }
1926 impl ::std::ops::BitOrAssign for WINTRUST_DATA_UNION_CHOICE {
1927     fn bitor_assign(&mut self, rhs: Self) {
1928         self.0.bitor_assign(rhs.0)
1929     }
1930 }
1931 impl ::std::ops::BitAndAssign for WINTRUST_DATA_UNION_CHOICE {
1932     fn bitand_assign(&mut self, rhs: Self) {
1933         self.0.bitand_assign(rhs.0)
1934     }
1935 }
1936 impl ::std::ops::Not for WINTRUST_DATA_UNION_CHOICE {
1937     type Output = Self;
1938     fn not(self) -> Self {
1939         Self(self.0.not())
1940     }
1941 }
1942 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1943 #[repr(C)]
1944 #[cfg(feature = "Win32_Foundation")]
1945 pub struct WINTRUST_FILE_INFO {
1946     pub cbStruct: u32,
1947     pub pcwszFilePath: super::super::Foundation::PWSTR,
1948     pub hFile: super::super::Foundation::HANDLE,
1949     pub pgKnownSubject: *mut ::windows::runtime::GUID,
1950 }
1951 #[cfg(feature = "Win32_Foundation")]
1952 impl WINTRUST_FILE_INFO {}
1953 #[cfg(feature = "Win32_Foundation")]
1954 impl ::std::default::Default for WINTRUST_FILE_INFO {
1955     fn default() -> Self {
1956         unsafe { ::std::mem::zeroed() }
1957     }
1958 }
1959 #[cfg(feature = "Win32_Foundation")]
1960 impl ::std::fmt::Debug for WINTRUST_FILE_INFO {
1961     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1962         fmt.debug_struct("WINTRUST_FILE_INFO").field("cbStruct", &self.cbStruct).field("pcwszFilePath", &self.pcwszFilePath).field("hFile", &self.hFile).field("pgKnownSubject", &self.pgKnownSubject).finish()
1963     }
1964 }
1965 #[cfg(feature = "Win32_Foundation")]
1966 impl ::std::cmp::PartialEq for WINTRUST_FILE_INFO {
1967     fn eq(&self, other: &Self) -> bool {
1968         self.cbStruct == other.cbStruct && self.pcwszFilePath == other.pcwszFilePath && self.hFile == other.hFile && self.pgKnownSubject == other.pgKnownSubject
1969     }
1970 }
1971 #[cfg(feature = "Win32_Foundation")]
1972 impl ::std::cmp::Eq for WINTRUST_FILE_INFO {}
1973 #[cfg(feature = "Win32_Foundation")]
1974 unsafe impl ::windows::runtime::Abi for WINTRUST_FILE_INFO {
1975     type Abi = Self;
1976     type DefaultType = Self;
1977 }
1978 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1979 #[repr(transparent)]
1980 pub struct WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION(pub u32);
1981 pub const DWACTION_ALLOCANDFILL: WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION = WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION(1u32);
1982 pub const DWACTION_FREE: WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION = WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION(2u32);
1983 impl ::std::convert::From<u32> for WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION {
1984     fn from(value: u32) -> Self {
1985         Self(value)
1986     }
1987 }
1988 unsafe impl ::windows::runtime::Abi for WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION {
1989     type Abi = Self;
1990     type DefaultType = Self;
1991 }
1992 impl ::std::ops::BitOr for WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION {
1993     type Output = Self;
1994     fn bitor(self, rhs: Self) -> Self {
1995         Self(self.0 | rhs.0)
1996     }
1997 }
1998 impl ::std::ops::BitAnd for WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION {
1999     type Output = Self;
2000     fn bitand(self, rhs: Self) -> Self {
2001         Self(self.0 & rhs.0)
2002     }
2003 }
2004 impl ::std::ops::BitOrAssign for WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION {
2005     fn bitor_assign(&mut self, rhs: Self) {
2006         self.0.bitor_assign(rhs.0)
2007     }
2008 }
2009 impl ::std::ops::BitAndAssign for WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION {
2010     fn bitand_assign(&mut self, rhs: Self) {
2011         self.0.bitand_assign(rhs.0)
2012     }
2013 }
2014 impl ::std::ops::Not for WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION {
2015     type Output = Self;
2016     fn not(self) -> Self {
2017         Self(self.0.not())
2018     }
2019 }
2020 pub const WINTRUST_MAX_HASH_BYTES_TO_MAP_DEFAULT: u32 = 1048576u32;
2021 pub const WINTRUST_MAX_HEADER_BYTES_TO_MAP_DEFAULT: u32 = 10485760u32;
2022 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2023 #[repr(transparent)]
2024 pub struct WINTRUST_POLICY_FLAGS(pub u32);
2025 pub const WTPF_TRUSTTEST: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(32u32);
2026 pub const WTPF_TESTCANBEVALID: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(128u32);
2027 pub const WTPF_IGNOREEXPIRATION: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(256u32);
2028 pub const WTPF_IGNOREREVOKATION: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(512u32);
2029 pub const WTPF_OFFLINEOK_IND: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(1024u32);
2030 pub const WTPF_OFFLINEOK_COM: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(2048u32);
2031 pub const WTPF_OFFLINEOKNBU_IND: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(4096u32);
2032 pub const WTPF_OFFLINEOKNBU_COM: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(8192u32);
2033 pub const WTPF_VERIFY_V1_OFF: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(65536u32);
2034 pub const WTPF_IGNOREREVOCATIONONTS: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(131072u32);
2035 pub const WTPF_ALLOWONLYPERTRUST: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(262144u32);
2036 impl ::std::convert::From<u32> for WINTRUST_POLICY_FLAGS {
2037     fn from(value: u32) -> Self {
2038         Self(value)
2039     }
2040 }
2041 unsafe impl ::windows::runtime::Abi for WINTRUST_POLICY_FLAGS {
2042     type Abi = Self;
2043     type DefaultType = Self;
2044 }
2045 impl ::std::ops::BitOr for WINTRUST_POLICY_FLAGS {
2046     type Output = Self;
2047     fn bitor(self, rhs: Self) -> Self {
2048         Self(self.0 | rhs.0)
2049     }
2050 }
2051 impl ::std::ops::BitAnd for WINTRUST_POLICY_FLAGS {
2052     type Output = Self;
2053     fn bitand(self, rhs: Self) -> Self {
2054         Self(self.0 & rhs.0)
2055     }
2056 }
2057 impl ::std::ops::BitOrAssign for WINTRUST_POLICY_FLAGS {
2058     fn bitor_assign(&mut self, rhs: Self) {
2059         self.0.bitor_assign(rhs.0)
2060     }
2061 }
2062 impl ::std::ops::BitAndAssign for WINTRUST_POLICY_FLAGS {
2063     fn bitand_assign(&mut self, rhs: Self) {
2064         self.0.bitand_assign(rhs.0)
2065     }
2066 }
2067 impl ::std::ops::Not for WINTRUST_POLICY_FLAGS {
2068     type Output = Self;
2069     fn not(self) -> Self {
2070         Self(self.0.not())
2071     }
2072 }
2073 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2074 #[repr(C)]
2075 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2076 pub struct WINTRUST_SGNR_INFO {
2077     pub cbStruct: u32,
2078     pub pcwszDisplayName: super::super::Foundation::PWSTR,
2079     pub psSignerInfo: *mut super::Cryptography::CMSG_SIGNER_INFO,
2080     pub chStores: u32,
2081     pub pahStores: *mut *mut ::std::ffi::c_void,
2082 }
2083 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2084 impl WINTRUST_SGNR_INFO {}
2085 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2086 impl ::std::default::Default for WINTRUST_SGNR_INFO {
2087     fn default() -> Self {
2088         unsafe { ::std::mem::zeroed() }
2089     }
2090 }
2091 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2092 impl ::std::fmt::Debug for WINTRUST_SGNR_INFO {
2093     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2094         fmt.debug_struct("WINTRUST_SGNR_INFO").field("cbStruct", &self.cbStruct).field("pcwszDisplayName", &self.pcwszDisplayName).field("psSignerInfo", &self.psSignerInfo).field("chStores", &self.chStores).field("pahStores", &self.pahStores).finish()
2095     }
2096 }
2097 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2098 impl ::std::cmp::PartialEq for WINTRUST_SGNR_INFO {
2099     fn eq(&self, other: &Self) -> bool {
2100         self.cbStruct == other.cbStruct && self.pcwszDisplayName == other.pcwszDisplayName && self.psSignerInfo == other.psSignerInfo && self.chStores == other.chStores && self.pahStores == other.pahStores
2101     }
2102 }
2103 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2104 impl ::std::cmp::Eq for WINTRUST_SGNR_INFO {}
2105 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2106 unsafe impl ::windows::runtime::Abi for WINTRUST_SGNR_INFO {
2107     type Abi = Self;
2108     type DefaultType = Self;
2109 }
2110 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2111 #[repr(C)]
2112 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2113 pub struct WINTRUST_SIGNATURE_SETTINGS {
2114     pub cbStruct: u32,
2115     pub dwIndex: u32,
2116     pub dwFlags: WINTRUST_SIGNATURE_SETTINGS_FLAGS,
2117     pub cSecondarySigs: u32,
2118     pub dwVerifiedSigIndex: u32,
2119     pub pCryptoPolicy: *mut super::Cryptography::CERT_STRONG_SIGN_PARA,
2120 }
2121 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2122 impl WINTRUST_SIGNATURE_SETTINGS {}
2123 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2124 impl ::std::default::Default for WINTRUST_SIGNATURE_SETTINGS {
2125     fn default() -> Self {
2126         unsafe { ::std::mem::zeroed() }
2127     }
2128 }
2129 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2130 impl ::std::fmt::Debug for WINTRUST_SIGNATURE_SETTINGS {
2131     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2132         fmt.debug_struct("WINTRUST_SIGNATURE_SETTINGS").field("cbStruct", &self.cbStruct).field("dwIndex", &self.dwIndex).field("dwFlags", &self.dwFlags).field("cSecondarySigs", &self.cSecondarySigs).field("dwVerifiedSigIndex", &self.dwVerifiedSigIndex).field("pCryptoPolicy", &self.pCryptoPolicy).finish()
2133     }
2134 }
2135 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2136 impl ::std::cmp::PartialEq for WINTRUST_SIGNATURE_SETTINGS {
2137     fn eq(&self, other: &Self) -> bool {
2138         self.cbStruct == other.cbStruct && self.dwIndex == other.dwIndex && self.dwFlags == other.dwFlags && self.cSecondarySigs == other.cSecondarySigs && self.dwVerifiedSigIndex == other.dwVerifiedSigIndex && self.pCryptoPolicy == other.pCryptoPolicy
2139     }
2140 }
2141 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2142 impl ::std::cmp::Eq for WINTRUST_SIGNATURE_SETTINGS {}
2143 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2144 unsafe impl ::windows::runtime::Abi for WINTRUST_SIGNATURE_SETTINGS {
2145     type Abi = Self;
2146     type DefaultType = Self;
2147 }
2148 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2149 #[repr(transparent)]
2150 pub struct WINTRUST_SIGNATURE_SETTINGS_FLAGS(pub u32);
2151 pub const WSS_VERIFY_SPECIFIC: WINTRUST_SIGNATURE_SETTINGS_FLAGS = WINTRUST_SIGNATURE_SETTINGS_FLAGS(1u32);
2152 pub const WSS_GET_SECONDARY_SIG_COUNT: WINTRUST_SIGNATURE_SETTINGS_FLAGS = WINTRUST_SIGNATURE_SETTINGS_FLAGS(2u32);
2153 impl ::std::convert::From<u32> for WINTRUST_SIGNATURE_SETTINGS_FLAGS {
2154     fn from(value: u32) -> Self {
2155         Self(value)
2156     }
2157 }
2158 unsafe impl ::windows::runtime::Abi for WINTRUST_SIGNATURE_SETTINGS_FLAGS {
2159     type Abi = Self;
2160     type DefaultType = Self;
2161 }
2162 impl ::std::ops::BitOr for WINTRUST_SIGNATURE_SETTINGS_FLAGS {
2163     type Output = Self;
2164     fn bitor(self, rhs: Self) -> Self {
2165         Self(self.0 | rhs.0)
2166     }
2167 }
2168 impl ::std::ops::BitAnd for WINTRUST_SIGNATURE_SETTINGS_FLAGS {
2169     type Output = Self;
2170     fn bitand(self, rhs: Self) -> Self {
2171         Self(self.0 & rhs.0)
2172     }
2173 }
2174 impl ::std::ops::BitOrAssign for WINTRUST_SIGNATURE_SETTINGS_FLAGS {
2175     fn bitor_assign(&mut self, rhs: Self) {
2176         self.0.bitor_assign(rhs.0)
2177     }
2178 }
2179 impl ::std::ops::BitAndAssign for WINTRUST_SIGNATURE_SETTINGS_FLAGS {
2180     fn bitand_assign(&mut self, rhs: Self) {
2181         self.0.bitand_assign(rhs.0)
2182     }
2183 }
2184 impl ::std::ops::Not for WINTRUST_SIGNATURE_SETTINGS_FLAGS {
2185     type Output = Self;
2186     fn not(self) -> Self {
2187         Self(self.0.not())
2188     }
2189 }
2190 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2191 #[repr(C)]
2192 pub struct WIN_CERTIFICATE {
2193     pub dwLength: u32,
2194     pub wRevision: u16,
2195     pub wCertificateType: u16,
2196     pub bCertificate: [u8; 1],
2197 }
2198 impl WIN_CERTIFICATE {}
2199 impl ::std::default::Default for WIN_CERTIFICATE {
2200     fn default() -> Self {
2201         unsafe { ::std::mem::zeroed() }
2202     }
2203 }
2204 impl ::std::fmt::Debug for WIN_CERTIFICATE {
2205     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2206         fmt.debug_struct("WIN_CERTIFICATE").field("dwLength", &self.dwLength).field("wRevision", &self.wRevision).field("wCertificateType", &self.wCertificateType).field("bCertificate", &self.bCertificate).finish()
2207     }
2208 }
2209 impl ::std::cmp::PartialEq for WIN_CERTIFICATE {
2210     fn eq(&self, other: &Self) -> bool {
2211         self.dwLength == other.dwLength && self.wRevision == other.wRevision && self.wCertificateType == other.wCertificateType && self.bCertificate == other.bCertificate
2212     }
2213 }
2214 impl ::std::cmp::Eq for WIN_CERTIFICATE {}
2215 unsafe impl ::windows::runtime::Abi for WIN_CERTIFICATE {
2216     type Abi = Self;
2217     type DefaultType = Self;
2218 }
2219 pub const WIN_CERT_REVISION_1_0: u32 = 256u32;
2220 pub const WIN_CERT_REVISION_2_0: u32 = 512u32;
2221 pub const WIN_CERT_TYPE_PKCS_SIGNED_DATA: u32 = 2u32;
2222 pub const WIN_CERT_TYPE_RESERVED_1: u32 = 3u32;
2223 pub const WIN_CERT_TYPE_TS_STACK_SIGNED: u32 = 4u32;
2224 pub const WIN_CERT_TYPE_X509: u32 = 1u32;
2225 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2226 #[repr(C)]
2227 #[cfg(feature = "Win32_Foundation")]
2228 pub struct WIN_SPUB_TRUSTED_PUBLISHER_DATA {
2229     pub hClientToken: super::super::Foundation::HANDLE,
2230     pub lpCertificate: *mut WIN_CERTIFICATE,
2231 }
2232 #[cfg(feature = "Win32_Foundation")]
2233 impl WIN_SPUB_TRUSTED_PUBLISHER_DATA {}
2234 #[cfg(feature = "Win32_Foundation")]
2235 impl ::std::default::Default for WIN_SPUB_TRUSTED_PUBLISHER_DATA {
2236     fn default() -> Self {
2237         unsafe { ::std::mem::zeroed() }
2238     }
2239 }
2240 #[cfg(feature = "Win32_Foundation")]
2241 impl ::std::fmt::Debug for WIN_SPUB_TRUSTED_PUBLISHER_DATA {
2242     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2243         fmt.debug_struct("WIN_SPUB_TRUSTED_PUBLISHER_DATA").field("hClientToken", &self.hClientToken).field("lpCertificate", &self.lpCertificate).finish()
2244     }
2245 }
2246 #[cfg(feature = "Win32_Foundation")]
2247 impl ::std::cmp::PartialEq for WIN_SPUB_TRUSTED_PUBLISHER_DATA {
2248     fn eq(&self, other: &Self) -> bool {
2249         self.hClientToken == other.hClientToken && self.lpCertificate == other.lpCertificate
2250     }
2251 }
2252 #[cfg(feature = "Win32_Foundation")]
2253 impl ::std::cmp::Eq for WIN_SPUB_TRUSTED_PUBLISHER_DATA {}
2254 #[cfg(feature = "Win32_Foundation")]
2255 unsafe impl ::windows::runtime::Abi for WIN_SPUB_TRUSTED_PUBLISHER_DATA {
2256     type Abi = Self;
2257     type DefaultType = Self;
2258 }
2259 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2260 #[repr(C)]
2261 #[cfg(feature = "Win32_Foundation")]
2262 pub struct WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT {
2263     pub hClientToken: super::super::Foundation::HANDLE,
2264     pub SubjectType: *mut ::windows::runtime::GUID,
2265     pub Subject: *mut ::std::ffi::c_void,
2266 }
2267 #[cfg(feature = "Win32_Foundation")]
2268 impl WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT {}
2269 #[cfg(feature = "Win32_Foundation")]
2270 impl ::std::default::Default for WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT {
2271     fn default() -> Self {
2272         unsafe { ::std::mem::zeroed() }
2273     }
2274 }
2275 #[cfg(feature = "Win32_Foundation")]
2276 impl ::std::fmt::Debug for WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT {
2277     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2278         fmt.debug_struct("WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT").field("hClientToken", &self.hClientToken).field("SubjectType", &self.SubjectType).field("Subject", &self.Subject).finish()
2279     }
2280 }
2281 #[cfg(feature = "Win32_Foundation")]
2282 impl ::std::cmp::PartialEq for WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT {
2283     fn eq(&self, other: &Self) -> bool {
2284         self.hClientToken == other.hClientToken && self.SubjectType == other.SubjectType && self.Subject == other.Subject
2285     }
2286 }
2287 #[cfg(feature = "Win32_Foundation")]
2288 impl ::std::cmp::Eq for WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT {}
2289 #[cfg(feature = "Win32_Foundation")]
2290 unsafe impl ::windows::runtime::Abi for WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT {
2291     type Abi = Self;
2292     type DefaultType = Self;
2293 }
2294 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2295 #[repr(C)]
2296 pub struct WIN_TRUST_ACTDATA_SUBJECT_ONLY {
2297     pub SubjectType: *mut ::windows::runtime::GUID,
2298     pub Subject: *mut ::std::ffi::c_void,
2299 }
2300 impl WIN_TRUST_ACTDATA_SUBJECT_ONLY {}
2301 impl ::std::default::Default for WIN_TRUST_ACTDATA_SUBJECT_ONLY {
2302     fn default() -> Self {
2303         unsafe { ::std::mem::zeroed() }
2304     }
2305 }
2306 impl ::std::fmt::Debug for WIN_TRUST_ACTDATA_SUBJECT_ONLY {
2307     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2308         fmt.debug_struct("WIN_TRUST_ACTDATA_SUBJECT_ONLY").field("SubjectType", &self.SubjectType).field("Subject", &self.Subject).finish()
2309     }
2310 }
2311 impl ::std::cmp::PartialEq for WIN_TRUST_ACTDATA_SUBJECT_ONLY {
2312     fn eq(&self, other: &Self) -> bool {
2313         self.SubjectType == other.SubjectType && self.Subject == other.Subject
2314     }
2315 }
2316 impl ::std::cmp::Eq for WIN_TRUST_ACTDATA_SUBJECT_ONLY {}
2317 unsafe impl ::windows::runtime::Abi for WIN_TRUST_ACTDATA_SUBJECT_ONLY {
2318     type Abi = Self;
2319     type DefaultType = Self;
2320 }
2321 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2322 #[repr(C)]
2323 #[cfg(feature = "Win32_Foundation")]
2324 pub struct WIN_TRUST_SUBJECT_FILE {
2325     pub hFile: super::super::Foundation::HANDLE,
2326     pub lpPath: super::super::Foundation::PWSTR,
2327 }
2328 #[cfg(feature = "Win32_Foundation")]
2329 impl WIN_TRUST_SUBJECT_FILE {}
2330 #[cfg(feature = "Win32_Foundation")]
2331 impl ::std::default::Default for WIN_TRUST_SUBJECT_FILE {
2332     fn default() -> Self {
2333         unsafe { ::std::mem::zeroed() }
2334     }
2335 }
2336 #[cfg(feature = "Win32_Foundation")]
2337 impl ::std::fmt::Debug for WIN_TRUST_SUBJECT_FILE {
2338     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2339         fmt.debug_struct("WIN_TRUST_SUBJECT_FILE").field("hFile", &self.hFile).field("lpPath", &self.lpPath).finish()
2340     }
2341 }
2342 #[cfg(feature = "Win32_Foundation")]
2343 impl ::std::cmp::PartialEq for WIN_TRUST_SUBJECT_FILE {
2344     fn eq(&self, other: &Self) -> bool {
2345         self.hFile == other.hFile && self.lpPath == other.lpPath
2346     }
2347 }
2348 #[cfg(feature = "Win32_Foundation")]
2349 impl ::std::cmp::Eq for WIN_TRUST_SUBJECT_FILE {}
2350 #[cfg(feature = "Win32_Foundation")]
2351 unsafe impl ::windows::runtime::Abi for WIN_TRUST_SUBJECT_FILE {
2352     type Abi = Self;
2353     type DefaultType = Self;
2354 }
2355 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2356 #[repr(C)]
2357 #[cfg(feature = "Win32_Foundation")]
2358 pub struct WIN_TRUST_SUBJECT_FILE_AND_DISPLAY {
2359     pub hFile: super::super::Foundation::HANDLE,
2360     pub lpPath: super::super::Foundation::PWSTR,
2361     pub lpDisplayName: super::super::Foundation::PWSTR,
2362 }
2363 #[cfg(feature = "Win32_Foundation")]
2364 impl WIN_TRUST_SUBJECT_FILE_AND_DISPLAY {}
2365 #[cfg(feature = "Win32_Foundation")]
2366 impl ::std::default::Default for WIN_TRUST_SUBJECT_FILE_AND_DISPLAY {
2367     fn default() -> Self {
2368         unsafe { ::std::mem::zeroed() }
2369     }
2370 }
2371 #[cfg(feature = "Win32_Foundation")]
2372 impl ::std::fmt::Debug for WIN_TRUST_SUBJECT_FILE_AND_DISPLAY {
2373     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2374         fmt.debug_struct("WIN_TRUST_SUBJECT_FILE_AND_DISPLAY").field("hFile", &self.hFile).field("lpPath", &self.lpPath).field("lpDisplayName", &self.lpDisplayName).finish()
2375     }
2376 }
2377 #[cfg(feature = "Win32_Foundation")]
2378 impl ::std::cmp::PartialEq for WIN_TRUST_SUBJECT_FILE_AND_DISPLAY {
2379     fn eq(&self, other: &Self) -> bool {
2380         self.hFile == other.hFile && self.lpPath == other.lpPath && self.lpDisplayName == other.lpDisplayName
2381     }
2382 }
2383 #[cfg(feature = "Win32_Foundation")]
2384 impl ::std::cmp::Eq for WIN_TRUST_SUBJECT_FILE_AND_DISPLAY {}
2385 #[cfg(feature = "Win32_Foundation")]
2386 unsafe impl ::windows::runtime::Abi for WIN_TRUST_SUBJECT_FILE_AND_DISPLAY {
2387     type Abi = Self;
2388     type DefaultType = Self;
2389 }
2390 pub const WSS_CERTTRUST_SUPPORT: u32 = 4u32;
2391 pub const WSS_INPUT_FLAG_MASK: u32 = 7u32;
2392 pub const WSS_OBJTRUST_SUPPORT: u32 = 1u32;
2393 pub const WSS_OUTPUT_FLAG_MASK: u32 = 3758096384u32;
2394 pub const WSS_OUT_FILE_SUPPORTS_SEAL: u32 = 536870912u32;
2395 pub const WSS_OUT_HAS_SEALING_INTENT: u32 = 1073741824u32;
2396 pub const WSS_OUT_SEALING_STATUS_VERIFIED: u32 = 2147483648u32;
2397 pub const WSS_SIGTRUST_SUPPORT: u32 = 2u32;
2398 pub const WSS_VERIFY_SEALING: u32 = 4u32;
2399 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2400 #[repr(C)]
2401 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2402 pub struct WTD_GENERIC_CHAIN_POLICY_CREATE_INFO {
2403     pub Anonymous: WTD_GENERIC_CHAIN_POLICY_CREATE_INFO_0,
2404     pub hChainEngine: super::Cryptography::HCERTCHAINENGINE,
2405     pub pChainPara: *mut super::Cryptography::CERT_CHAIN_PARA,
2406     pub dwFlags: u32,
2407     pub pvReserved: *mut ::std::ffi::c_void,
2408 }
2409 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2410 impl WTD_GENERIC_CHAIN_POLICY_CREATE_INFO {}
2411 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2412 impl ::std::default::Default for WTD_GENERIC_CHAIN_POLICY_CREATE_INFO {
2413     fn default() -> Self {
2414         unsafe { ::std::mem::zeroed() }
2415     }
2416 }
2417 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2418 impl ::std::cmp::PartialEq for WTD_GENERIC_CHAIN_POLICY_CREATE_INFO {
2419     fn eq(&self, _other: &Self) -> bool {
2420         unimplemented!()
2421     }
2422 }
2423 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2424 impl ::std::cmp::Eq for WTD_GENERIC_CHAIN_POLICY_CREATE_INFO {}
2425 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2426 unsafe impl ::windows::runtime::Abi for WTD_GENERIC_CHAIN_POLICY_CREATE_INFO {
2427     type Abi = Self;
2428     type DefaultType = Self;
2429 }
2430 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2431 #[repr(C)]
2432 pub union WTD_GENERIC_CHAIN_POLICY_CREATE_INFO_0 {
2433     pub cbStruct: u32,
2434     pub cbSize: u32,
2435 }
2436 impl WTD_GENERIC_CHAIN_POLICY_CREATE_INFO_0 {}
2437 impl ::std::default::Default for WTD_GENERIC_CHAIN_POLICY_CREATE_INFO_0 {
2438     fn default() -> Self {
2439         unsafe { ::std::mem::zeroed() }
2440     }
2441 }
2442 impl ::std::cmp::PartialEq for WTD_GENERIC_CHAIN_POLICY_CREATE_INFO_0 {
2443     fn eq(&self, _other: &Self) -> bool {
2444         unimplemented!()
2445     }
2446 }
2447 impl ::std::cmp::Eq for WTD_GENERIC_CHAIN_POLICY_CREATE_INFO_0 {}
2448 unsafe impl ::windows::runtime::Abi for WTD_GENERIC_CHAIN_POLICY_CREATE_INFO_0 {
2449     type Abi = Self;
2450     type DefaultType = Self;
2451 }
2452 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2453 impl ::std::clone::Clone for WTD_GENERIC_CHAIN_POLICY_DATA {
2454     fn clone(&self) -> Self {
2455         unimplemented!()
2456     }
2457 }
2458 #[repr(C)]
2459 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2460 pub struct WTD_GENERIC_CHAIN_POLICY_DATA {
2461     pub Anonymous: WTD_GENERIC_CHAIN_POLICY_DATA_0,
2462     pub pSignerChainInfo: *mut WTD_GENERIC_CHAIN_POLICY_CREATE_INFO,
2463     pub pCounterSignerChainInfo: *mut WTD_GENERIC_CHAIN_POLICY_CREATE_INFO,
2464     pub pfnPolicyCallback: ::std::option::Option<PFN_WTD_GENERIC_CHAIN_POLICY_CALLBACK>,
2465     pub pvPolicyArg: *mut ::std::ffi::c_void,
2466 }
2467 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2468 impl WTD_GENERIC_CHAIN_POLICY_DATA {}
2469 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2470 impl ::std::default::Default for WTD_GENERIC_CHAIN_POLICY_DATA {
2471     fn default() -> Self {
2472         unsafe { ::std::mem::zeroed() }
2473     }
2474 }
2475 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2476 impl ::std::cmp::PartialEq for WTD_GENERIC_CHAIN_POLICY_DATA {
2477     fn eq(&self, _other: &Self) -> bool {
2478         unimplemented!()
2479     }
2480 }
2481 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2482 impl ::std::cmp::Eq for WTD_GENERIC_CHAIN_POLICY_DATA {}
2483 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2484 unsafe impl ::windows::runtime::Abi for WTD_GENERIC_CHAIN_POLICY_DATA {
2485     type Abi = ::std::mem::ManuallyDrop<Self>;
2486     type DefaultType = Self;
2487 }
2488 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2489 #[repr(C)]
2490 pub union WTD_GENERIC_CHAIN_POLICY_DATA_0 {
2491     pub cbStruct: u32,
2492     pub cbSize: u32,
2493 }
2494 impl WTD_GENERIC_CHAIN_POLICY_DATA_0 {}
2495 impl ::std::default::Default for WTD_GENERIC_CHAIN_POLICY_DATA_0 {
2496     fn default() -> Self {
2497         unsafe { ::std::mem::zeroed() }
2498     }
2499 }
2500 impl ::std::cmp::PartialEq for WTD_GENERIC_CHAIN_POLICY_DATA_0 {
2501     fn eq(&self, _other: &Self) -> bool {
2502         unimplemented!()
2503     }
2504 }
2505 impl ::std::cmp::Eq for WTD_GENERIC_CHAIN_POLICY_DATA_0 {}
2506 unsafe impl ::windows::runtime::Abi for WTD_GENERIC_CHAIN_POLICY_DATA_0 {
2507     type Abi = Self;
2508     type DefaultType = Self;
2509 }
2510 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2511 #[repr(C)]
2512 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2513 pub struct WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO {
2514     pub Anonymous: WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO_0,
2515     pub pChainContext: *mut super::Cryptography::CERT_CHAIN_CONTEXT,
2516     pub dwSignerType: u32,
2517     pub pMsgSignerInfo: *mut super::Cryptography::CMSG_SIGNER_INFO,
2518     pub dwError: u32,
2519     pub cCounterSigner: u32,
2520     pub rgpCounterSigner: *mut *mut WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO,
2521 }
2522 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2523 impl WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO {}
2524 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2525 impl ::std::default::Default for WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO {
2526     fn default() -> Self {
2527         unsafe { ::std::mem::zeroed() }
2528     }
2529 }
2530 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2531 impl ::std::cmp::PartialEq for WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO {
2532     fn eq(&self, _other: &Self) -> bool {
2533         unimplemented!()
2534     }
2535 }
2536 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2537 impl ::std::cmp::Eq for WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO {}
2538 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2539 unsafe impl ::windows::runtime::Abi for WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO {
2540     type Abi = Self;
2541     type DefaultType = Self;
2542 }
2543 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2544 #[repr(C)]
2545 pub union WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO_0 {
2546     pub cbStruct: u32,
2547     pub cbSize: u32,
2548 }
2549 impl WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO_0 {}
2550 impl ::std::default::Default for WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO_0 {
2551     fn default() -> Self {
2552         unsafe { ::std::mem::zeroed() }
2553     }
2554 }
2555 impl ::std::cmp::PartialEq for WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO_0 {
2556     fn eq(&self, _other: &Self) -> bool {
2557         unimplemented!()
2558     }
2559 }
2560 impl ::std::cmp::Eq for WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO_0 {}
2561 unsafe impl ::windows::runtime::Abi for WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO_0 {
2562     type Abi = Self;
2563     type DefaultType = Self;
2564 }
2565 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2566 #[inline]
2567 pub unsafe fn WTHelperCertCheckValidSignature(pprovdata: *mut CRYPT_PROVIDER_DATA) -> ::windows::runtime::Result<()> {
2568     #[cfg(windows)]
2569     {
2570         #[link(name = "windows")]
2571         extern "system" {
2572             fn WTHelperCertCheckValidSignature(pprovdata: *mut CRYPT_PROVIDER_DATA) -> ::windows::runtime::HRESULT;
2573         }
2574         WTHelperCertCheckValidSignature(::std::mem::transmute(pprovdata)).ok()
2575     }
2576     #[cfg(not(windows))]
2577     unimplemented!("Unsupported target OS");
2578 }
2579 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2580 #[inline]
2581 pub unsafe fn WTHelperCertIsSelfSigned(dwencoding: u32, pcert: *mut super::Cryptography::CERT_INFO) -> super::super::Foundation::BOOL {
2582     #[cfg(windows)]
2583     {
2584         #[link(name = "windows")]
2585         extern "system" {
2586             fn WTHelperCertIsSelfSigned(dwencoding: u32, pcert: *mut super::Cryptography::CERT_INFO) -> super::super::Foundation::BOOL;
2587         }
2588         ::std::mem::transmute(WTHelperCertIsSelfSigned(::std::mem::transmute(dwencoding), ::std::mem::transmute(pcert)))
2589     }
2590     #[cfg(not(windows))]
2591     unimplemented!("Unsupported target OS");
2592 }
2593 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2594 #[inline]
2595 pub unsafe fn WTHelperGetProvCertFromChain(psgnr: *mut CRYPT_PROVIDER_SGNR, idxcert: u32) -> *mut CRYPT_PROVIDER_CERT {
2596     #[cfg(windows)]
2597     {
2598         #[link(name = "windows")]
2599         extern "system" {
2600             fn WTHelperGetProvCertFromChain(psgnr: *mut CRYPT_PROVIDER_SGNR, idxcert: u32) -> *mut CRYPT_PROVIDER_CERT;
2601         }
2602         ::std::mem::transmute(WTHelperGetProvCertFromChain(::std::mem::transmute(psgnr), ::std::mem::transmute(idxcert)))
2603     }
2604     #[cfg(not(windows))]
2605     unimplemented!("Unsupported target OS");
2606 }
2607 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2608 #[inline]
2609 pub unsafe fn WTHelperGetProvPrivateDataFromChain(pprovdata: *mut CRYPT_PROVIDER_DATA, pgproviderid: *mut ::windows::runtime::GUID) -> *mut CRYPT_PROVIDER_PRIVDATA {
2610     #[cfg(windows)]
2611     {
2612         #[link(name = "windows")]
2613         extern "system" {
2614             fn WTHelperGetProvPrivateDataFromChain(pprovdata: *mut CRYPT_PROVIDER_DATA, pgproviderid: *mut ::windows::runtime::GUID) -> *mut CRYPT_PROVIDER_PRIVDATA;
2615         }
2616         ::std::mem::transmute(WTHelperGetProvPrivateDataFromChain(::std::mem::transmute(pprovdata), ::std::mem::transmute(pgproviderid)))
2617     }
2618     #[cfg(not(windows))]
2619     unimplemented!("Unsupported target OS");
2620 }
2621 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2622 #[inline]
2623 pub unsafe fn WTHelperGetProvSignerFromChain<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(pprovdata: *mut CRYPT_PROVIDER_DATA, idxsigner: u32, fcountersigner: Param2, idxcountersigner: u32) -> *mut CRYPT_PROVIDER_SGNR {
2624     #[cfg(windows)]
2625     {
2626         #[link(name = "windows")]
2627         extern "system" {
2628             fn WTHelperGetProvSignerFromChain(pprovdata: *mut CRYPT_PROVIDER_DATA, idxsigner: u32, fcountersigner: super::super::Foundation::BOOL, idxcountersigner: u32) -> *mut CRYPT_PROVIDER_SGNR;
2629         }
2630         ::std::mem::transmute(WTHelperGetProvSignerFromChain(::std::mem::transmute(pprovdata), ::std::mem::transmute(idxsigner), fcountersigner.into_param().abi(), ::std::mem::transmute(idxcountersigner)))
2631     }
2632     #[cfg(not(windows))]
2633     unimplemented!("Unsupported target OS");
2634 }
2635 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2636 #[inline]
2637 pub unsafe fn WTHelperProvDataFromStateData<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hstatedata: Param0) -> *mut CRYPT_PROVIDER_DATA {
2638     #[cfg(windows)]
2639     {
2640         #[link(name = "windows")]
2641         extern "system" {
2642             fn WTHelperProvDataFromStateData(hstatedata: super::super::Foundation::HANDLE) -> *mut CRYPT_PROVIDER_DATA;
2643         }
2644         ::std::mem::transmute(WTHelperProvDataFromStateData(hstatedata.into_param().abi()))
2645     }
2646     #[cfg(not(windows))]
2647     unimplemented!("Unsupported target OS");
2648 }
2649 pub const WT_ADD_ACTION_ID_RET_RESULT_FLAG: u32 = 1u32;
2650 pub const WT_CURRENT_VERSION: u32 = 512u32;
2651 pub const WT_TRUSTDBDIALOG_NO_UI_FLAG: u32 = 1u32;
2652 pub const WT_TRUSTDBDIALOG_ONLY_PUB_TAB_FLAG: u32 = 2u32;
2653 pub const WT_TRUSTDBDIALOG_WRITE_IEAK_STORE_FLAG: u32 = 512u32;
2654 pub const WT_TRUSTDBDIALOG_WRITE_LEGACY_REG_FLAG: u32 = 256u32;
2655 #[cfg(feature = "Win32_Foundation")]
2656 #[inline]
2657 pub unsafe fn WinVerifyTrust<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hwnd: Param0, pgactionid: *mut ::windows::runtime::GUID, pwvtdata: *mut ::std::ffi::c_void) -> i32 {
2658     #[cfg(windows)]
2659     {
2660         #[link(name = "windows")]
2661         extern "system" {
2662             fn WinVerifyTrust(hwnd: super::super::Foundation::HWND, pgactionid: *mut ::windows::runtime::GUID, pwvtdata: *mut ::std::ffi::c_void) -> i32;
2663         }
2664         ::std::mem::transmute(WinVerifyTrust(hwnd.into_param().abi(), ::std::mem::transmute(pgactionid), ::std::mem::transmute(pwvtdata)))
2665     }
2666     #[cfg(not(windows))]
2667     unimplemented!("Unsupported target OS");
2668 }
2669 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2670 #[inline]
2671 pub unsafe fn WinVerifyTrustEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hwnd: Param0, pgactionid: *mut ::windows::runtime::GUID, pwintrustdata: *mut WINTRUST_DATA) -> i32 {
2672     #[cfg(windows)]
2673     {
2674         #[link(name = "windows")]
2675         extern "system" {
2676             fn WinVerifyTrustEx(hwnd: super::super::Foundation::HWND, pgactionid: *mut ::windows::runtime::GUID, pwintrustdata: *mut WINTRUST_DATA) -> i32;
2677         }
2678         ::std::mem::transmute(WinVerifyTrustEx(hwnd.into_param().abi(), ::std::mem::transmute(pgactionid), ::std::mem::transmute(pwintrustdata)))
2679     }
2680     #[cfg(not(windows))]
2681     unimplemented!("Unsupported target OS");
2682 }
2683 #[cfg(feature = "Win32_Foundation")]
2684 #[inline]
2685 pub unsafe fn WintrustAddActionID(pgactionid: *const ::windows::runtime::GUID, fdwflags: u32, psprovinfo: *const CRYPT_REGISTER_ACTIONID) -> super::super::Foundation::BOOL {
2686     #[cfg(windows)]
2687     {
2688         #[link(name = "windows")]
2689         extern "system" {
2690             fn WintrustAddActionID(pgactionid: *const ::windows::runtime::GUID, fdwflags: u32, psprovinfo: *const CRYPT_REGISTER_ACTIONID) -> super::super::Foundation::BOOL;
2691         }
2692         ::std::mem::transmute(WintrustAddActionID(::std::mem::transmute(pgactionid), ::std::mem::transmute(fdwflags), ::std::mem::transmute(psprovinfo)))
2693     }
2694     #[cfg(not(windows))]
2695     unimplemented!("Unsupported target OS");
2696 }
2697 #[cfg(feature = "Win32_Foundation")]
2698 #[inline]
2699 pub unsafe fn WintrustAddDefaultForUsage<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszusageoid: Param0, psdefusage: *const CRYPT_PROVIDER_REGDEFUSAGE) -> super::super::Foundation::BOOL {
2700     #[cfg(windows)]
2701     {
2702         #[link(name = "windows")]
2703         extern "system" {
2704             fn WintrustAddDefaultForUsage(pszusageoid: super::super::Foundation::PSTR, psdefusage: *const CRYPT_PROVIDER_REGDEFUSAGE) -> super::super::Foundation::BOOL;
2705         }
2706         ::std::mem::transmute(WintrustAddDefaultForUsage(pszusageoid.into_param().abi(), ::std::mem::transmute(psdefusage)))
2707     }
2708     #[cfg(not(windows))]
2709     unimplemented!("Unsupported target OS");
2710 }
2711 #[cfg(feature = "Win32_Foundation")]
2712 #[inline]
2713 pub unsafe fn WintrustGetDefaultForUsage<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwaction: WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION, pszusageoid: Param1, psusage: *mut CRYPT_PROVIDER_DEFUSAGE) -> super::super::Foundation::BOOL {
2714     #[cfg(windows)]
2715     {
2716         #[link(name = "windows")]
2717         extern "system" {
2718             fn WintrustGetDefaultForUsage(dwaction: WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION, pszusageoid: super::super::Foundation::PSTR, psusage: *mut CRYPT_PROVIDER_DEFUSAGE) -> super::super::Foundation::BOOL;
2719         }
2720         ::std::mem::transmute(WintrustGetDefaultForUsage(::std::mem::transmute(dwaction), pszusageoid.into_param().abi(), ::std::mem::transmute(psusage)))
2721     }
2722     #[cfg(not(windows))]
2723     unimplemented!("Unsupported target OS");
2724 }
2725 #[inline]
2726 pub unsafe fn WintrustGetRegPolicyFlags(pdwpolicyflags: *mut WINTRUST_POLICY_FLAGS) {
2727     #[cfg(windows)]
2728     {
2729         #[link(name = "windows")]
2730         extern "system" {
2731             fn WintrustGetRegPolicyFlags(pdwpolicyflags: *mut WINTRUST_POLICY_FLAGS);
2732         }
2733         ::std::mem::transmute(WintrustGetRegPolicyFlags(::std::mem::transmute(pdwpolicyflags)))
2734     }
2735     #[cfg(not(windows))]
2736     unimplemented!("Unsupported target OS");
2737 }
2738 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2739 #[inline]
2740 pub unsafe fn WintrustLoadFunctionPointers(pgactionid: *mut ::windows::runtime::GUID, ppfns: *mut CRYPT_PROVIDER_FUNCTIONS) -> super::super::Foundation::BOOL {
2741     #[cfg(windows)]
2742     {
2743         #[link(name = "windows")]
2744         extern "system" {
2745             fn WintrustLoadFunctionPointers(pgactionid: *mut ::windows::runtime::GUID, ppfns: *mut ::std::mem::ManuallyDrop<CRYPT_PROVIDER_FUNCTIONS>) -> super::super::Foundation::BOOL;
2746         }
2747         ::std::mem::transmute(WintrustLoadFunctionPointers(::std::mem::transmute(pgactionid), ::std::mem::transmute(ppfns)))
2748     }
2749     #[cfg(not(windows))]
2750     unimplemented!("Unsupported target OS");
2751 }
2752 #[cfg(feature = "Win32_Foundation")]
2753 #[inline]
2754 pub unsafe fn WintrustRemoveActionID(pgactionid: *const ::windows::runtime::GUID) -> super::super::Foundation::BOOL {
2755     #[cfg(windows)]
2756     {
2757         #[link(name = "windows")]
2758         extern "system" {
2759             fn WintrustRemoveActionID(pgactionid: *const ::windows::runtime::GUID) -> super::super::Foundation::BOOL;
2760         }
2761         ::std::mem::transmute(WintrustRemoveActionID(::std::mem::transmute(pgactionid)))
2762     }
2763     #[cfg(not(windows))]
2764     unimplemented!("Unsupported target OS");
2765 }
2766 #[cfg(feature = "Win32_Foundation")]
2767 #[inline]
2768 pub unsafe fn WintrustSetDefaultIncludePEPageHashes<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(fincludepepagehashes: Param0) {
2769     #[cfg(windows)]
2770     {
2771         #[link(name = "windows")]
2772         extern "system" {
2773             fn WintrustSetDefaultIncludePEPageHashes(fincludepepagehashes: super::super::Foundation::BOOL);
2774         }
2775         ::std::mem::transmute(WintrustSetDefaultIncludePEPageHashes(fincludepepagehashes.into_param().abi()))
2776     }
2777     #[cfg(not(windows))]
2778     unimplemented!("Unsupported target OS");
2779 }
2780 #[cfg(feature = "Win32_Foundation")]
2781 #[inline]
2782 pub unsafe fn WintrustSetRegPolicyFlags(dwpolicyflags: WINTRUST_POLICY_FLAGS) -> super::super::Foundation::BOOL {
2783     #[cfg(windows)]
2784     {
2785         #[link(name = "windows")]
2786         extern "system" {
2787             fn WintrustSetRegPolicyFlags(dwpolicyflags: WINTRUST_POLICY_FLAGS) -> super::super::Foundation::BOOL;
2788         }
2789         ::std::mem::transmute(WintrustSetRegPolicyFlags(::std::mem::transmute(dwpolicyflags)))
2790     }
2791     #[cfg(not(windows))]
2792     unimplemented!("Unsupported target OS");
2793 }
2794