1 #![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
2 #[cfg(feature = "Win32_Security_Authentication_Identity_Provider")]
3 pub mod Provider;
4 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5 #[repr(transparent)]
6 pub struct ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ(pub u32);
7 pub const ASC_REQ_ALLOCATE_MEMORY: ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ = ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ(256u32);
8 pub const ASC_REQ_CONNECTION: ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ = ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ(2048u32);
9 pub const ASC_REQ_DELEGATE: ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ = ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ(1u32);
10 pub const ASC_REQ_EXTENDED_ERROR: ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ = ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ(32768u32);
11 pub const ASC_REQ_REPLAY_DETECT: ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ = ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ(4u32);
12 pub const ASC_REQ_SEQUENCE_DETECT: ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ = ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ(8u32);
13 pub const ASC_REQ_STREAM: ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ = ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ(65536u32);
14 impl ::std::convert::From<u32> for ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ {
15     fn from(value: u32) -> Self {
16         Self(value)
17     }
18 }
19 unsafe impl ::windows::runtime::Abi for ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ {
20     type Abi = Self;
21     type DefaultType = Self;
22 }
23 impl ::std::ops::BitOr for ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ {
24     type Output = Self;
25     fn bitor(self, rhs: Self) -> Self {
26         Self(self.0 | rhs.0)
27     }
28 }
29 impl ::std::ops::BitAnd for ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ {
30     type Output = Self;
31     fn bitand(self, rhs: Self) -> Self {
32         Self(self.0 & rhs.0)
33     }
34 }
35 impl ::std::ops::BitOrAssign for ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ {
36     fn bitor_assign(&mut self, rhs: Self) {
37         self.0.bitor_assign(rhs.0)
38     }
39 }
40 impl ::std::ops::BitAndAssign for ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ {
41     fn bitand_assign(&mut self, rhs: Self) {
42         self.0.bitand_assign(rhs.0)
43     }
44 }
45 impl ::std::ops::Not for ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ {
46     type Output = Self;
47     fn not(self) -> Self {
48         Self(self.0.not())
49     }
50 }
51 #[cfg(feature = "Win32_Security_Credentials")]
52 pub type ACCEPT_SECURITY_CONTEXT_FN = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: *mut super::super::Credentials::SecHandle, param2: *mut SecBufferDesc, param3: u32, param4: u32, param5: *mut super::super::Credentials::SecHandle, param6: *mut SecBufferDesc, param7: *mut u32, param8: *mut i64) -> i32;
53 pub const ACCOUNT_ADJUST_PRIVILEGES: i32 = 2i32;
54 pub const ACCOUNT_ADJUST_QUOTAS: i32 = 4i32;
55 pub const ACCOUNT_ADJUST_SYSTEM_ACCESS: i32 = 8i32;
56 pub const ACCOUNT_VIEW: i32 = 1i32;
57 #[cfg(feature = "Win32_Security_Credentials")]
58 pub type ACQUIRE_CREDENTIALS_HANDLE_FN_A = unsafe extern "system" fn(param0: *mut i8, param1: *mut i8, param2: u32, param3: *mut ::std::ffi::c_void, param4: *mut ::std::ffi::c_void, param5: ::windows::runtime::RawPtr, param6: *mut ::std::ffi::c_void, param7: *mut super::super::Credentials::SecHandle, param8: *mut i64) -> i32;
59 #[cfg(feature = "Win32_Security_Credentials")]
60 pub type ACQUIRE_CREDENTIALS_HANDLE_FN_W = unsafe extern "system" fn(param0: *mut u16, param1: *mut u16, param2: u32, param3: *mut ::std::ffi::c_void, param4: *mut ::std::ffi::c_void, param5: ::windows::runtime::RawPtr, param6: *mut ::std::ffi::c_void, param7: *mut super::super::Credentials::SecHandle, param8: *mut i64) -> i32;
61 #[cfg(feature = "Win32_Security_Credentials")]
62 pub type ADD_CREDENTIALS_FN_A = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: *mut i8, param2: *mut i8, param3: u32, param4: *mut ::std::ffi::c_void, param5: ::windows::runtime::RawPtr, param6: *mut ::std::ffi::c_void, param7: *mut i64) -> i32;
63 #[cfg(feature = "Win32_Security_Credentials")]
64 pub type ADD_CREDENTIALS_FN_W = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: *mut u16, param2: *mut u16, param3: u32, param4: *mut ::std::ffi::c_void, param5: ::windows::runtime::RawPtr, param6: *mut ::std::ffi::c_void, param7: *mut i64) -> i32;
65 #[cfg(feature = "Win32_Security_Credentials")]
66 pub type APPLY_CONTROL_TOKEN_FN = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: *mut SecBufferDesc) -> i32;
67 pub const ASC_REQ_ALLOW_CONTEXT_REPLAY: u32 = 4194304u32;
68 pub const ASC_REQ_ALLOW_MISSING_BINDINGS: u32 = 268435456u32;
69 pub const ASC_REQ_ALLOW_NON_USER_LOGONS: u32 = 2097152u32;
70 pub const ASC_REQ_ALLOW_NULL_SESSION: u32 = 1048576u32;
71 pub const ASC_REQ_CALL_LEVEL: u32 = 4096u32;
72 pub const ASC_REQ_CONFIDENTIALITY: u32 = 16u32;
73 pub const ASC_REQ_DATAGRAM: u32 = 1024u32;
74 pub const ASC_REQ_FRAGMENT_SUPPLIED: u32 = 8192u32;
75 pub const ASC_REQ_FRAGMENT_TO_FIT: u32 = 8388608u32;
76 pub const ASC_REQ_IDENTIFY: u32 = 524288u32;
77 pub const ASC_REQ_INTEGRITY: u32 = 131072u32;
78 pub const ASC_REQ_LICENSING: u32 = 262144u32;
79 pub const ASC_REQ_MESSAGES: u64 = 4294967296u64;
80 pub const ASC_REQ_MUTUAL_AUTH: u32 = 2u32;
81 pub const ASC_REQ_NO_TOKEN: u32 = 16777216u32;
82 pub const ASC_REQ_PROXY_BINDINGS: u32 = 67108864u32;
83 pub const ASC_REQ_SESSION_TICKET: u32 = 64u32;
84 pub const ASC_REQ_USE_DCE_STYLE: u32 = 512u32;
85 pub const ASC_REQ_USE_SESSION_KEY: u32 = 32u32;
86 pub const ASC_RET_ALLOCATED_MEMORY: u32 = 256u32;
87 pub const ASC_RET_ALLOW_CONTEXT_REPLAY: u32 = 4194304u32;
88 pub const ASC_RET_ALLOW_NON_USER_LOGONS: u32 = 2097152u32;
89 pub const ASC_RET_CALL_LEVEL: u32 = 8192u32;
90 pub const ASC_RET_CONFIDENTIALITY: u32 = 16u32;
91 pub const ASC_RET_CONNECTION: u32 = 2048u32;
92 pub const ASC_RET_DATAGRAM: u32 = 1024u32;
93 pub const ASC_RET_DELEGATE: u32 = 1u32;
94 pub const ASC_RET_EXTENDED_ERROR: u32 = 32768u32;
95 pub const ASC_RET_FRAGMENT_ONLY: u32 = 8388608u32;
96 pub const ASC_RET_IDENTIFY: u32 = 524288u32;
97 pub const ASC_RET_INTEGRITY: u32 = 131072u32;
98 pub const ASC_RET_LICENSING: u32 = 262144u32;
99 pub const ASC_RET_MESSAGES: u64 = 4294967296u64;
100 pub const ASC_RET_MUTUAL_AUTH: u32 = 2u32;
101 pub const ASC_RET_NO_ADDITIONAL_TOKEN: u32 = 33554432u32;
102 pub const ASC_RET_NO_TOKEN: u32 = 16777216u32;
103 pub const ASC_RET_NULL_SESSION: u32 = 1048576u32;
104 pub const ASC_RET_REPLAY_DETECT: u32 = 4u32;
105 pub const ASC_RET_SEQUENCE_DETECT: u32 = 8u32;
106 pub const ASC_RET_SESSION_TICKET: u32 = 64u32;
107 pub const ASC_RET_STREAM: u32 = 65536u32;
108 pub const ASC_RET_THIRD_LEG_FAILED: u32 = 16384u32;
109 pub const ASC_RET_USED_DCE_STYLE: u32 = 512u32;
110 pub const ASC_RET_USE_SESSION_KEY: u32 = 32u32;
111 pub const AUDIT_ENUMERATE_USERS: u32 = 16u32;
112 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
113 #[repr(C)]
114 pub struct AUDIT_POLICY_INFORMATION {
115     pub AuditSubCategoryGuid: ::windows::runtime::GUID,
116     pub AuditingInformation: u32,
117     pub AuditCategoryGuid: ::windows::runtime::GUID,
118 }
119 impl AUDIT_POLICY_INFORMATION {}
120 impl ::std::default::Default for AUDIT_POLICY_INFORMATION {
121     fn default() -> Self {
122         unsafe { ::std::mem::zeroed() }
123     }
124 }
125 impl ::std::fmt::Debug for AUDIT_POLICY_INFORMATION {
126     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
127         fmt.debug_struct("AUDIT_POLICY_INFORMATION").field("AuditSubCategoryGuid", &self.AuditSubCategoryGuid).field("AuditingInformation", &self.AuditingInformation).field("AuditCategoryGuid", &self.AuditCategoryGuid).finish()
128     }
129 }
130 impl ::std::cmp::PartialEq for AUDIT_POLICY_INFORMATION {
131     fn eq(&self, other: &Self) -> bool {
132         self.AuditSubCategoryGuid == other.AuditSubCategoryGuid && self.AuditingInformation == other.AuditingInformation && self.AuditCategoryGuid == other.AuditCategoryGuid
133     }
134 }
135 impl ::std::cmp::Eq for AUDIT_POLICY_INFORMATION {}
136 unsafe impl ::windows::runtime::Abi for AUDIT_POLICY_INFORMATION {
137     type Abi = Self;
138     type DefaultType = Self;
139 }
140 pub const AUDIT_QUERY_MISC_POLICY: u32 = 64u32;
141 pub const AUDIT_QUERY_SYSTEM_POLICY: u32 = 2u32;
142 pub const AUDIT_QUERY_USER_POLICY: u32 = 8u32;
143 pub const AUDIT_SET_MISC_POLICY: u32 = 32u32;
144 pub const AUDIT_SET_SYSTEM_POLICY: u32 = 1u32;
145 pub const AUDIT_SET_USER_POLICY: u32 = 4u32;
146 pub const AUTH_REQ_ALLOW_ENC_TKT_IN_SKEY: u32 = 32u32;
147 pub const AUTH_REQ_ALLOW_FORWARDABLE: u32 = 1u32;
148 pub const AUTH_REQ_ALLOW_NOADDRESS: u32 = 16u32;
149 pub const AUTH_REQ_ALLOW_POSTDATE: u32 = 4u32;
150 pub const AUTH_REQ_ALLOW_PROXIABLE: u32 = 2u32;
151 pub const AUTH_REQ_ALLOW_RENEWABLE: u32 = 8u32;
152 pub const AUTH_REQ_ALLOW_S4U_DELEGATE: u32 = 2048u32;
153 pub const AUTH_REQ_ALLOW_VALIDATE: u32 = 64u32;
154 pub const AUTH_REQ_OK_AS_DELEGATE: u32 = 256u32;
155 pub const AUTH_REQ_PREAUTH_REQUIRED: u32 = 512u32;
156 pub const AUTH_REQ_TRANSITIVE_TRUST: u32 = 1024u32;
157 pub const AUTH_REQ_VALIDATE_CLIENT: u32 = 128u32;
158 #[cfg(feature = "Win32_Security_Credentials")]
159 #[inline]
160 pub unsafe fn AcceptSecurityContext(phcredential: *const super::super::Credentials::SecHandle, phcontext: *const super::super::Credentials::SecHandle, pinput: *const SecBufferDesc, fcontextreq: ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ, targetdatarep: u32, phnewcontext: *mut super::super::Credentials::SecHandle, poutput: *mut SecBufferDesc, pfcontextattr: *mut u32, ptsexpiry: *mut i64) -> i32 {
161     #[cfg(windows)]
162     {
163         #[link(name = "windows")]
164         extern "system" {
165             fn AcceptSecurityContext(phcredential: *const super::super::Credentials::SecHandle, phcontext: *const super::super::Credentials::SecHandle, pinput: *const SecBufferDesc, fcontextreq: ACCEPT_SECURITY_CONTEXT_CONTEXT_REQ, targetdatarep: u32, phnewcontext: *mut super::super::Credentials::SecHandle, poutput: *mut SecBufferDesc, pfcontextattr: *mut u32, ptsexpiry: *mut i64) -> i32;
166         }
167         ::std::mem::transmute(AcceptSecurityContext(
168             ::std::mem::transmute(phcredential),
169             ::std::mem::transmute(phcontext),
170             ::std::mem::transmute(pinput),
171             ::std::mem::transmute(fcontextreq),
172             ::std::mem::transmute(targetdatarep),
173             ::std::mem::transmute(phnewcontext),
174             ::std::mem::transmute(poutput),
175             ::std::mem::transmute(pfcontextattr),
176             ::std::mem::transmute(ptsexpiry),
177         ))
178     }
179     #[cfg(not(windows))]
180     unimplemented!("Unsupported target OS");
181 }
182 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
183 #[inline]
184 pub unsafe fn AcquireCredentialsHandleA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSTR>>(
185     pszprincipal: Param0,
186     pszpackage: Param1,
187     fcredentialuse: SECPKG_CRED,
188     pvlogonid: *const ::std::ffi::c_void,
189     pauthdata: *const ::std::ffi::c_void,
190     pgetkeyfn: ::std::option::Option<SEC_GET_KEY_FN>,
191     pvgetkeyargument: *const ::std::ffi::c_void,
192     phcredential: *mut super::super::Credentials::SecHandle,
193     ptsexpiry: *mut i64,
194 ) -> i32 {
195     #[cfg(windows)]
196     {
197         #[link(name = "windows")]
198         extern "system" {
199             fn AcquireCredentialsHandleA(pszprincipal: super::super::super::Foundation::PSTR, pszpackage: super::super::super::Foundation::PSTR, fcredentialuse: SECPKG_CRED, pvlogonid: *const ::std::ffi::c_void, pauthdata: *const ::std::ffi::c_void, pgetkeyfn: ::windows::runtime::RawPtr, pvgetkeyargument: *const ::std::ffi::c_void, phcredential: *mut super::super::Credentials::SecHandle, ptsexpiry: *mut i64) -> i32;
200         }
201         ::std::mem::transmute(AcquireCredentialsHandleA(
202             pszprincipal.into_param().abi(),
203             pszpackage.into_param().abi(),
204             ::std::mem::transmute(fcredentialuse),
205             ::std::mem::transmute(pvlogonid),
206             ::std::mem::transmute(pauthdata),
207             ::std::mem::transmute(pgetkeyfn),
208             ::std::mem::transmute(pvgetkeyargument),
209             ::std::mem::transmute(phcredential),
210             ::std::mem::transmute(ptsexpiry),
211         ))
212     }
213     #[cfg(not(windows))]
214     unimplemented!("Unsupported target OS");
215 }
216 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
217 #[inline]
218 pub unsafe fn AcquireCredentialsHandleW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(
219     pszprincipal: Param0,
220     pszpackage: Param1,
221     fcredentialuse: SECPKG_CRED,
222     pvlogonid: *const ::std::ffi::c_void,
223     pauthdata: *const ::std::ffi::c_void,
224     pgetkeyfn: ::std::option::Option<SEC_GET_KEY_FN>,
225     pvgetkeyargument: *const ::std::ffi::c_void,
226     phcredential: *mut super::super::Credentials::SecHandle,
227     ptsexpiry: *mut i64,
228 ) -> i32 {
229     #[cfg(windows)]
230     {
231         #[link(name = "windows")]
232         extern "system" {
233             fn AcquireCredentialsHandleW(pszprincipal: super::super::super::Foundation::PWSTR, pszpackage: super::super::super::Foundation::PWSTR, fcredentialuse: SECPKG_CRED, pvlogonid: *const ::std::ffi::c_void, pauthdata: *const ::std::ffi::c_void, pgetkeyfn: ::windows::runtime::RawPtr, pvgetkeyargument: *const ::std::ffi::c_void, phcredential: *mut super::super::Credentials::SecHandle, ptsexpiry: *mut i64) -> i32;
234         }
235         ::std::mem::transmute(AcquireCredentialsHandleW(
236             pszprincipal.into_param().abi(),
237             pszpackage.into_param().abi(),
238             ::std::mem::transmute(fcredentialuse),
239             ::std::mem::transmute(pvlogonid),
240             ::std::mem::transmute(pauthdata),
241             ::std::mem::transmute(pgetkeyfn),
242             ::std::mem::transmute(pvgetkeyargument),
243             ::std::mem::transmute(phcredential),
244             ::std::mem::transmute(ptsexpiry),
245         ))
246     }
247     #[cfg(not(windows))]
248     unimplemented!("Unsupported target OS");
249 }
250 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
251 #[inline]
252 pub unsafe fn AddCredentialsA<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSTR>>(hcredentials: *const super::super::Credentials::SecHandle, pszprincipal: Param1, pszpackage: Param2, fcredentialuse: u32, pauthdata: *const ::std::ffi::c_void, pgetkeyfn: ::std::option::Option<SEC_GET_KEY_FN>, pvgetkeyargument: *const ::std::ffi::c_void, ptsexpiry: *mut i64) -> i32 {
253     #[cfg(windows)]
254     {
255         #[link(name = "windows")]
256         extern "system" {
257             fn AddCredentialsA(hcredentials: *const super::super::Credentials::SecHandle, pszprincipal: super::super::super::Foundation::PSTR, pszpackage: super::super::super::Foundation::PSTR, fcredentialuse: u32, pauthdata: *const ::std::ffi::c_void, pgetkeyfn: ::windows::runtime::RawPtr, pvgetkeyargument: *const ::std::ffi::c_void, ptsexpiry: *mut i64) -> i32;
258         }
259         ::std::mem::transmute(AddCredentialsA(::std::mem::transmute(hcredentials), pszprincipal.into_param().abi(), pszpackage.into_param().abi(), ::std::mem::transmute(fcredentialuse), ::std::mem::transmute(pauthdata), ::std::mem::transmute(pgetkeyfn), ::std::mem::transmute(pvgetkeyargument), ::std::mem::transmute(ptsexpiry)))
260     }
261     #[cfg(not(windows))]
262     unimplemented!("Unsupported target OS");
263 }
264 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
265 #[inline]
266 pub unsafe fn AddCredentialsW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hcredentials: *const super::super::Credentials::SecHandle, pszprincipal: Param1, pszpackage: Param2, fcredentialuse: u32, pauthdata: *const ::std::ffi::c_void, pgetkeyfn: ::std::option::Option<SEC_GET_KEY_FN>, pvgetkeyargument: *const ::std::ffi::c_void, ptsexpiry: *mut i64) -> i32 {
267     #[cfg(windows)]
268     {
269         #[link(name = "windows")]
270         extern "system" {
271             fn AddCredentialsW(hcredentials: *const super::super::Credentials::SecHandle, pszprincipal: super::super::super::Foundation::PWSTR, pszpackage: super::super::super::Foundation::PWSTR, fcredentialuse: u32, pauthdata: *const ::std::ffi::c_void, pgetkeyfn: ::windows::runtime::RawPtr, pvgetkeyargument: *const ::std::ffi::c_void, ptsexpiry: *mut i64) -> i32;
272         }
273         ::std::mem::transmute(AddCredentialsW(::std::mem::transmute(hcredentials), pszprincipal.into_param().abi(), pszpackage.into_param().abi(), ::std::mem::transmute(fcredentialuse), ::std::mem::transmute(pauthdata), ::std::mem::transmute(pgetkeyfn), ::std::mem::transmute(pvgetkeyargument), ::std::mem::transmute(ptsexpiry)))
274     }
275     #[cfg(not(windows))]
276     unimplemented!("Unsupported target OS");
277 }
278 #[cfg(feature = "Win32_Foundation")]
279 #[inline]
280 pub unsafe fn AddSecurityPackageA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSTR>>(pszpackagename: Param0, poptions: *const SECURITY_PACKAGE_OPTIONS) -> i32 {
281     #[cfg(windows)]
282     {
283         #[link(name = "windows")]
284         extern "system" {
285             fn AddSecurityPackageA(pszpackagename: super::super::super::Foundation::PSTR, poptions: *const SECURITY_PACKAGE_OPTIONS) -> i32;
286         }
287         ::std::mem::transmute(AddSecurityPackageA(pszpackagename.into_param().abi(), ::std::mem::transmute(poptions)))
288     }
289     #[cfg(not(windows))]
290     unimplemented!("Unsupported target OS");
291 }
292 #[cfg(feature = "Win32_Foundation")]
293 #[inline]
294 pub unsafe fn AddSecurityPackageW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pszpackagename: Param0, poptions: *const SECURITY_PACKAGE_OPTIONS) -> i32 {
295     #[cfg(windows)]
296     {
297         #[link(name = "windows")]
298         extern "system" {
299             fn AddSecurityPackageW(pszpackagename: super::super::super::Foundation::PWSTR, poptions: *const SECURITY_PACKAGE_OPTIONS) -> i32;
300         }
301         ::std::mem::transmute(AddSecurityPackageW(pszpackagename.into_param().abi(), ::std::mem::transmute(poptions)))
302     }
303     #[cfg(not(windows))]
304     unimplemented!("Unsupported target OS");
305 }
306 #[cfg(feature = "Win32_Security_Credentials")]
307 #[inline]
308 pub unsafe fn ApplyControlToken(phcontext: *const super::super::Credentials::SecHandle, pinput: *const SecBufferDesc) -> i32 {
309     #[cfg(windows)]
310     {
311         #[link(name = "windows")]
312         extern "system" {
313             fn ApplyControlToken(phcontext: *const super::super::Credentials::SecHandle, pinput: *const SecBufferDesc) -> i32;
314         }
315         ::std::mem::transmute(ApplyControlToken(::std::mem::transmute(phcontext), ::std::mem::transmute(pinput)))
316     }
317     #[cfg(not(windows))]
318     unimplemented!("Unsupported target OS");
319 }
320 #[cfg(feature = "Win32_Foundation")]
321 #[inline]
322 pub unsafe fn AuditComputeEffectivePolicyBySid<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSID>>(psid: Param0, psubcategoryguids: *const ::windows::runtime::GUID, dwpolicycount: u32, ppauditpolicy: *mut *mut AUDIT_POLICY_INFORMATION) -> super::super::super::Foundation::BOOLEAN {
323     #[cfg(windows)]
324     {
325         #[link(name = "windows")]
326         extern "system" {
327             fn AuditComputeEffectivePolicyBySid(psid: super::super::super::Foundation::PSID, psubcategoryguids: *const ::windows::runtime::GUID, dwpolicycount: u32, ppauditpolicy: *mut *mut AUDIT_POLICY_INFORMATION) -> super::super::super::Foundation::BOOLEAN;
328         }
329         ::std::mem::transmute(AuditComputeEffectivePolicyBySid(psid.into_param().abi(), ::std::mem::transmute(psubcategoryguids), ::std::mem::transmute(dwpolicycount), ::std::mem::transmute(ppauditpolicy)))
330     }
331     #[cfg(not(windows))]
332     unimplemented!("Unsupported target OS");
333 }
334 #[cfg(feature = "Win32_Foundation")]
335 #[inline]
336 pub unsafe fn AuditComputeEffectivePolicyByToken<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HANDLE>>(htokenhandle: Param0, psubcategoryguids: *const ::windows::runtime::GUID, dwpolicycount: u32, ppauditpolicy: *mut *mut AUDIT_POLICY_INFORMATION) -> super::super::super::Foundation::BOOLEAN {
337     #[cfg(windows)]
338     {
339         #[link(name = "windows")]
340         extern "system" {
341             fn AuditComputeEffectivePolicyByToken(htokenhandle: super::super::super::Foundation::HANDLE, psubcategoryguids: *const ::windows::runtime::GUID, dwpolicycount: u32, ppauditpolicy: *mut *mut AUDIT_POLICY_INFORMATION) -> super::super::super::Foundation::BOOLEAN;
342         }
343         ::std::mem::transmute(AuditComputeEffectivePolicyByToken(htokenhandle.into_param().abi(), ::std::mem::transmute(psubcategoryguids), ::std::mem::transmute(dwpolicycount), ::std::mem::transmute(ppauditpolicy)))
344     }
345     #[cfg(not(windows))]
346     unimplemented!("Unsupported target OS");
347 }
348 #[cfg(feature = "Win32_Foundation")]
349 #[inline]
350 pub unsafe fn AuditEnumerateCategories(ppauditcategoriesarray: *mut *mut ::windows::runtime::GUID, pdwcountreturned: *mut u32) -> super::super::super::Foundation::BOOLEAN {
351     #[cfg(windows)]
352     {
353         #[link(name = "windows")]
354         extern "system" {
355             fn AuditEnumerateCategories(ppauditcategoriesarray: *mut *mut ::windows::runtime::GUID, pdwcountreturned: *mut u32) -> super::super::super::Foundation::BOOLEAN;
356         }
357         ::std::mem::transmute(AuditEnumerateCategories(::std::mem::transmute(ppauditcategoriesarray), ::std::mem::transmute(pdwcountreturned)))
358     }
359     #[cfg(not(windows))]
360     unimplemented!("Unsupported target OS");
361 }
362 #[cfg(feature = "Win32_Foundation")]
363 #[inline]
364 pub unsafe fn AuditEnumeratePerUserPolicy(ppauditsidarray: *mut *mut POLICY_AUDIT_SID_ARRAY) -> super::super::super::Foundation::BOOLEAN {
365     #[cfg(windows)]
366     {
367         #[link(name = "windows")]
368         extern "system" {
369             fn AuditEnumeratePerUserPolicy(ppauditsidarray: *mut *mut POLICY_AUDIT_SID_ARRAY) -> super::super::super::Foundation::BOOLEAN;
370         }
371         ::std::mem::transmute(AuditEnumeratePerUserPolicy(::std::mem::transmute(ppauditsidarray)))
372     }
373     #[cfg(not(windows))]
374     unimplemented!("Unsupported target OS");
375 }
376 #[cfg(feature = "Win32_Foundation")]
377 #[inline]
378 pub unsafe fn AuditEnumerateSubCategories<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOLEAN>>(pauditcategoryguid: *const ::windows::runtime::GUID, bretrieveallsubcategories: Param1, ppauditsubcategoriesarray: *mut *mut ::windows::runtime::GUID, pdwcountreturned: *mut u32) -> super::super::super::Foundation::BOOLEAN {
379     #[cfg(windows)]
380     {
381         #[link(name = "windows")]
382         extern "system" {
383             fn AuditEnumerateSubCategories(pauditcategoryguid: *const ::windows::runtime::GUID, bretrieveallsubcategories: super::super::super::Foundation::BOOLEAN, ppauditsubcategoriesarray: *mut *mut ::windows::runtime::GUID, pdwcountreturned: *mut u32) -> super::super::super::Foundation::BOOLEAN;
384         }
385         ::std::mem::transmute(AuditEnumerateSubCategories(::std::mem::transmute(pauditcategoryguid), bretrieveallsubcategories.into_param().abi(), ::std::mem::transmute(ppauditsubcategoriesarray), ::std::mem::transmute(pdwcountreturned)))
386     }
387     #[cfg(not(windows))]
388     unimplemented!("Unsupported target OS");
389 }
390 #[inline]
391 pub unsafe fn AuditFree(buffer: *const ::std::ffi::c_void) {
392     #[cfg(windows)]
393     {
394         #[link(name = "windows")]
395         extern "system" {
396             fn AuditFree(buffer: *const ::std::ffi::c_void);
397         }
398         ::std::mem::transmute(AuditFree(::std::mem::transmute(buffer)))
399     }
400     #[cfg(not(windows))]
401     unimplemented!("Unsupported target OS");
402 }
403 #[cfg(feature = "Win32_Foundation")]
404 #[inline]
405 pub unsafe fn AuditLookupCategoryGuidFromCategoryId(auditcategoryid: POLICY_AUDIT_EVENT_TYPE, pauditcategoryguid: *mut ::windows::runtime::GUID) -> super::super::super::Foundation::BOOLEAN {
406     #[cfg(windows)]
407     {
408         #[link(name = "windows")]
409         extern "system" {
410             fn AuditLookupCategoryGuidFromCategoryId(auditcategoryid: POLICY_AUDIT_EVENT_TYPE, pauditcategoryguid: *mut ::windows::runtime::GUID) -> super::super::super::Foundation::BOOLEAN;
411         }
412         ::std::mem::transmute(AuditLookupCategoryGuidFromCategoryId(::std::mem::transmute(auditcategoryid), ::std::mem::transmute(pauditcategoryguid)))
413     }
414     #[cfg(not(windows))]
415     unimplemented!("Unsupported target OS");
416 }
417 #[cfg(feature = "Win32_Foundation")]
418 #[inline]
419 pub unsafe fn AuditLookupCategoryIdFromCategoryGuid(pauditcategoryguid: *const ::windows::runtime::GUID, pauditcategoryid: *mut POLICY_AUDIT_EVENT_TYPE) -> super::super::super::Foundation::BOOLEAN {
420     #[cfg(windows)]
421     {
422         #[link(name = "windows")]
423         extern "system" {
424             fn AuditLookupCategoryIdFromCategoryGuid(pauditcategoryguid: *const ::windows::runtime::GUID, pauditcategoryid: *mut POLICY_AUDIT_EVENT_TYPE) -> super::super::super::Foundation::BOOLEAN;
425         }
426         ::std::mem::transmute(AuditLookupCategoryIdFromCategoryGuid(::std::mem::transmute(pauditcategoryguid), ::std::mem::transmute(pauditcategoryid)))
427     }
428     #[cfg(not(windows))]
429     unimplemented!("Unsupported target OS");
430 }
431 #[cfg(feature = "Win32_Foundation")]
432 #[inline]
433 pub unsafe fn AuditLookupCategoryNameA(pauditcategoryguid: *const ::windows::runtime::GUID, ppszcategoryname: *mut super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOLEAN {
434     #[cfg(windows)]
435     {
436         #[link(name = "windows")]
437         extern "system" {
438             fn AuditLookupCategoryNameA(pauditcategoryguid: *const ::windows::runtime::GUID, ppszcategoryname: *mut super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOLEAN;
439         }
440         ::std::mem::transmute(AuditLookupCategoryNameA(::std::mem::transmute(pauditcategoryguid), ::std::mem::transmute(ppszcategoryname)))
441     }
442     #[cfg(not(windows))]
443     unimplemented!("Unsupported target OS");
444 }
445 #[cfg(feature = "Win32_Foundation")]
446 #[inline]
447 pub unsafe fn AuditLookupCategoryNameW(pauditcategoryguid: *const ::windows::runtime::GUID, ppszcategoryname: *mut super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOLEAN {
448     #[cfg(windows)]
449     {
450         #[link(name = "windows")]
451         extern "system" {
452             fn AuditLookupCategoryNameW(pauditcategoryguid: *const ::windows::runtime::GUID, ppszcategoryname: *mut super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOLEAN;
453         }
454         ::std::mem::transmute(AuditLookupCategoryNameW(::std::mem::transmute(pauditcategoryguid), ::std::mem::transmute(ppszcategoryname)))
455     }
456     #[cfg(not(windows))]
457     unimplemented!("Unsupported target OS");
458 }
459 #[cfg(feature = "Win32_Foundation")]
460 #[inline]
461 pub unsafe fn AuditLookupSubCategoryNameA(pauditsubcategoryguid: *const ::windows::runtime::GUID, ppszsubcategoryname: *mut super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOLEAN {
462     #[cfg(windows)]
463     {
464         #[link(name = "windows")]
465         extern "system" {
466             fn AuditLookupSubCategoryNameA(pauditsubcategoryguid: *const ::windows::runtime::GUID, ppszsubcategoryname: *mut super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOLEAN;
467         }
468         ::std::mem::transmute(AuditLookupSubCategoryNameA(::std::mem::transmute(pauditsubcategoryguid), ::std::mem::transmute(ppszsubcategoryname)))
469     }
470     #[cfg(not(windows))]
471     unimplemented!("Unsupported target OS");
472 }
473 #[cfg(feature = "Win32_Foundation")]
474 #[inline]
475 pub unsafe fn AuditLookupSubCategoryNameW(pauditsubcategoryguid: *const ::windows::runtime::GUID, ppszsubcategoryname: *mut super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOLEAN {
476     #[cfg(windows)]
477     {
478         #[link(name = "windows")]
479         extern "system" {
480             fn AuditLookupSubCategoryNameW(pauditsubcategoryguid: *const ::windows::runtime::GUID, ppszsubcategoryname: *mut super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOLEAN;
481         }
482         ::std::mem::transmute(AuditLookupSubCategoryNameW(::std::mem::transmute(pauditsubcategoryguid), ::std::mem::transmute(ppszsubcategoryname)))
483     }
484     #[cfg(not(windows))]
485     unimplemented!("Unsupported target OS");
486 }
487 #[cfg(feature = "Win32_Foundation")]
488 #[inline]
489 pub unsafe fn AuditQueryGlobalSaclA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSTR>>(objecttypename: Param0, acl: *mut *mut super::super::ACL) -> super::super::super::Foundation::BOOLEAN {
490     #[cfg(windows)]
491     {
492         #[link(name = "windows")]
493         extern "system" {
494             fn AuditQueryGlobalSaclA(objecttypename: super::super::super::Foundation::PSTR, acl: *mut *mut super::super::ACL) -> super::super::super::Foundation::BOOLEAN;
495         }
496         ::std::mem::transmute(AuditQueryGlobalSaclA(objecttypename.into_param().abi(), ::std::mem::transmute(acl)))
497     }
498     #[cfg(not(windows))]
499     unimplemented!("Unsupported target OS");
500 }
501 #[cfg(feature = "Win32_Foundation")]
502 #[inline]
503 pub unsafe fn AuditQueryGlobalSaclW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(objecttypename: Param0, acl: *mut *mut super::super::ACL) -> super::super::super::Foundation::BOOLEAN {
504     #[cfg(windows)]
505     {
506         #[link(name = "windows")]
507         extern "system" {
508             fn AuditQueryGlobalSaclW(objecttypename: super::super::super::Foundation::PWSTR, acl: *mut *mut super::super::ACL) -> super::super::super::Foundation::BOOLEAN;
509         }
510         ::std::mem::transmute(AuditQueryGlobalSaclW(objecttypename.into_param().abi(), ::std::mem::transmute(acl)))
511     }
512     #[cfg(not(windows))]
513     unimplemented!("Unsupported target OS");
514 }
515 #[cfg(feature = "Win32_Foundation")]
516 #[inline]
517 pub unsafe fn AuditQueryPerUserPolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSID>>(psid: Param0, psubcategoryguids: *const ::windows::runtime::GUID, dwpolicycount: u32, ppauditpolicy: *mut *mut AUDIT_POLICY_INFORMATION) -> super::super::super::Foundation::BOOLEAN {
518     #[cfg(windows)]
519     {
520         #[link(name = "windows")]
521         extern "system" {
522             fn AuditQueryPerUserPolicy(psid: super::super::super::Foundation::PSID, psubcategoryguids: *const ::windows::runtime::GUID, dwpolicycount: u32, ppauditpolicy: *mut *mut AUDIT_POLICY_INFORMATION) -> super::super::super::Foundation::BOOLEAN;
523         }
524         ::std::mem::transmute(AuditQueryPerUserPolicy(psid.into_param().abi(), ::std::mem::transmute(psubcategoryguids), ::std::mem::transmute(dwpolicycount), ::std::mem::transmute(ppauditpolicy)))
525     }
526     #[cfg(not(windows))]
527     unimplemented!("Unsupported target OS");
528 }
529 #[cfg(feature = "Win32_Foundation")]
530 #[inline]
531 pub unsafe fn AuditQuerySecurity(securityinformation: u32, ppsecuritydescriptor: *mut *mut super::super::SECURITY_DESCRIPTOR) -> super::super::super::Foundation::BOOLEAN {
532     #[cfg(windows)]
533     {
534         #[link(name = "windows")]
535         extern "system" {
536             fn AuditQuerySecurity(securityinformation: u32, ppsecuritydescriptor: *mut *mut super::super::SECURITY_DESCRIPTOR) -> super::super::super::Foundation::BOOLEAN;
537         }
538         ::std::mem::transmute(AuditQuerySecurity(::std::mem::transmute(securityinformation), ::std::mem::transmute(ppsecuritydescriptor)))
539     }
540     #[cfg(not(windows))]
541     unimplemented!("Unsupported target OS");
542 }
543 #[cfg(feature = "Win32_Foundation")]
544 #[inline]
545 pub unsafe fn AuditQuerySystemPolicy(psubcategoryguids: *const ::windows::runtime::GUID, dwpolicycount: u32, ppauditpolicy: *mut *mut AUDIT_POLICY_INFORMATION) -> super::super::super::Foundation::BOOLEAN {
546     #[cfg(windows)]
547     {
548         #[link(name = "windows")]
549         extern "system" {
550             fn AuditQuerySystemPolicy(psubcategoryguids: *const ::windows::runtime::GUID, dwpolicycount: u32, ppauditpolicy: *mut *mut AUDIT_POLICY_INFORMATION) -> super::super::super::Foundation::BOOLEAN;
551         }
552         ::std::mem::transmute(AuditQuerySystemPolicy(::std::mem::transmute(psubcategoryguids), ::std::mem::transmute(dwpolicycount), ::std::mem::transmute(ppauditpolicy)))
553     }
554     #[cfg(not(windows))]
555     unimplemented!("Unsupported target OS");
556 }
557 #[cfg(feature = "Win32_Foundation")]
558 #[inline]
559 pub unsafe fn AuditSetGlobalSaclA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSTR>>(objecttypename: Param0, acl: *const super::super::ACL) -> super::super::super::Foundation::BOOLEAN {
560     #[cfg(windows)]
561     {
562         #[link(name = "windows")]
563         extern "system" {
564             fn AuditSetGlobalSaclA(objecttypename: super::super::super::Foundation::PSTR, acl: *const super::super::ACL) -> super::super::super::Foundation::BOOLEAN;
565         }
566         ::std::mem::transmute(AuditSetGlobalSaclA(objecttypename.into_param().abi(), ::std::mem::transmute(acl)))
567     }
568     #[cfg(not(windows))]
569     unimplemented!("Unsupported target OS");
570 }
571 #[cfg(feature = "Win32_Foundation")]
572 #[inline]
573 pub unsafe fn AuditSetGlobalSaclW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(objecttypename: Param0, acl: *const super::super::ACL) -> super::super::super::Foundation::BOOLEAN {
574     #[cfg(windows)]
575     {
576         #[link(name = "windows")]
577         extern "system" {
578             fn AuditSetGlobalSaclW(objecttypename: super::super::super::Foundation::PWSTR, acl: *const super::super::ACL) -> super::super::super::Foundation::BOOLEAN;
579         }
580         ::std::mem::transmute(AuditSetGlobalSaclW(objecttypename.into_param().abi(), ::std::mem::transmute(acl)))
581     }
582     #[cfg(not(windows))]
583     unimplemented!("Unsupported target OS");
584 }
585 #[cfg(feature = "Win32_Foundation")]
586 #[inline]
587 pub unsafe fn AuditSetPerUserPolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSID>>(psid: Param0, pauditpolicy: *const AUDIT_POLICY_INFORMATION, dwpolicycount: u32) -> super::super::super::Foundation::BOOLEAN {
588     #[cfg(windows)]
589     {
590         #[link(name = "windows")]
591         extern "system" {
592             fn AuditSetPerUserPolicy(psid: super::super::super::Foundation::PSID, pauditpolicy: *const AUDIT_POLICY_INFORMATION, dwpolicycount: u32) -> super::super::super::Foundation::BOOLEAN;
593         }
594         ::std::mem::transmute(AuditSetPerUserPolicy(psid.into_param().abi(), ::std::mem::transmute(pauditpolicy), ::std::mem::transmute(dwpolicycount)))
595     }
596     #[cfg(not(windows))]
597     unimplemented!("Unsupported target OS");
598 }
599 #[cfg(feature = "Win32_Foundation")]
600 #[inline]
601 pub unsafe fn AuditSetSecurity(securityinformation: u32, psecuritydescriptor: *const super::super::SECURITY_DESCRIPTOR) -> super::super::super::Foundation::BOOLEAN {
602     #[cfg(windows)]
603     {
604         #[link(name = "windows")]
605         extern "system" {
606             fn AuditSetSecurity(securityinformation: u32, psecuritydescriptor: *const super::super::SECURITY_DESCRIPTOR) -> super::super::super::Foundation::BOOLEAN;
607         }
608         ::std::mem::transmute(AuditSetSecurity(::std::mem::transmute(securityinformation), ::std::mem::transmute(psecuritydescriptor)))
609     }
610     #[cfg(not(windows))]
611     unimplemented!("Unsupported target OS");
612 }
613 #[cfg(feature = "Win32_Foundation")]
614 #[inline]
615 pub unsafe fn AuditSetSystemPolicy(pauditpolicy: *const AUDIT_POLICY_INFORMATION, dwpolicycount: u32) -> super::super::super::Foundation::BOOLEAN {
616     #[cfg(windows)]
617     {
618         #[link(name = "windows")]
619         extern "system" {
620             fn AuditSetSystemPolicy(pauditpolicy: *const AUDIT_POLICY_INFORMATION, dwpolicycount: u32) -> super::super::super::Foundation::BOOLEAN;
621         }
622         ::std::mem::transmute(AuditSetSystemPolicy(::std::mem::transmute(pauditpolicy), ::std::mem::transmute(dwpolicycount)))
623     }
624     #[cfg(not(windows))]
625     unimplemented!("Unsupported target OS");
626 }
627 pub const Audit_AccountLogon: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1771542608, 31098, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
628 pub const Audit_AccountLogon_CredentialValidation: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864447, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
629 pub const Audit_AccountLogon_KerbCredentialValidation: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864450, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
630 pub const Audit_AccountLogon_Kerberos: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864448, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
631 pub const Audit_AccountLogon_Others: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864449, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
632 pub const Audit_AccountManagement: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1771542606, 31098, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
633 pub const Audit_AccountManagement_ApplicationGroup: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864441, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
634 pub const Audit_AccountManagement_ComputerAccount: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864438, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
635 pub const Audit_AccountManagement_DistributionGroup: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864440, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
636 pub const Audit_AccountManagement_Others: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864442, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
637 pub const Audit_AccountManagement_SecurityGroup: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864439, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
638 pub const Audit_AccountManagement_UserAccount: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864437, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
639 pub const Audit_DSAccess_DSAccess: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864443, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
640 pub const Audit_DetailedTracking: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1771542604, 31098, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
641 pub const Audit_DetailedTracking_DpapiActivity: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864429, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
642 pub const Audit_DetailedTracking_PnpActivity: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864456, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
643 pub const Audit_DetailedTracking_ProcessCreation: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864427, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
644 pub const Audit_DetailedTracking_ProcessTermination: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864428, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
645 pub const Audit_DetailedTracking_RpcCall: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864430, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
646 pub const Audit_DetailedTracking_TokenRightAdjusted: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864458, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
647 pub const Audit_DirectoryServiceAccess: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1771542607, 31098, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
648 pub const Audit_DsAccess_AdAuditChanges: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864444, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
649 pub const Audit_Ds_DetailedReplication: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864446, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
650 pub const Audit_Ds_Replication: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864445, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
651 pub const Audit_Logon: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1771542601, 31098, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
652 pub const Audit_Logon_AccountLockout: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864407, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
653 pub const Audit_Logon_Claims: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864455, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
654 pub const Audit_Logon_Groups: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864457, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
655 pub const Audit_Logon_IPSecMainMode: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864408, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
656 pub const Audit_Logon_IPSecQuickMode: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864409, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
657 pub const Audit_Logon_IPSecUserMode: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864410, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
658 pub const Audit_Logon_Logoff: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864406, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
659 pub const Audit_Logon_Logon: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864405, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
660 pub const Audit_Logon_NPS: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864451, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
661 pub const Audit_Logon_Others: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864412, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
662 pub const Audit_Logon_SpecialLogon: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864411, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
663 pub const Audit_ObjectAccess: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1771542602, 31098, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
664 pub const Audit_ObjectAccess_ApplicationGenerated: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864418, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
665 pub const Audit_ObjectAccess_CbacStaging: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864454, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
666 pub const Audit_ObjectAccess_CertificationServices: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864417, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
667 pub const Audit_ObjectAccess_DetailedFileShare: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864452, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
668 pub const Audit_ObjectAccess_FileSystem: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864413, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
669 pub const Audit_ObjectAccess_FirewallConnection: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864422, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
670 pub const Audit_ObjectAccess_FirewallPacketDrops: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864421, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
671 pub const Audit_ObjectAccess_Handle: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864419, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
672 pub const Audit_ObjectAccess_Kernel: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864415, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
673 pub const Audit_ObjectAccess_Other: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864423, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
674 pub const Audit_ObjectAccess_Registry: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864414, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
675 pub const Audit_ObjectAccess_RemovableStorage: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864453, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
676 pub const Audit_ObjectAccess_Sam: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864416, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
677 pub const Audit_ObjectAccess_Share: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864420, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
678 pub const Audit_PolicyChange: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1771542605, 31098, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
679 pub const Audit_PolicyChange_AuditPolicy: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864431, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
680 pub const Audit_PolicyChange_AuthenticationPolicy: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864432, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
681 pub const Audit_PolicyChange_AuthorizationPolicy: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864433, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
682 pub const Audit_PolicyChange_MpsscvRulePolicy: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864434, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
683 pub const Audit_PolicyChange_Others: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864436, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
684 pub const Audit_PolicyChange_WfpIPSecPolicy: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864435, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
685 pub const Audit_PrivilegeUse: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1771542603, 31098, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
686 pub const Audit_PrivilegeUse_NonSensitive: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864425, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
687 pub const Audit_PrivilegeUse_Others: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864426, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
688 pub const Audit_PrivilegeUse_Sensitive: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864424, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
689 pub const Audit_System: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1771542600, 31098, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
690 pub const Audit_System_IPSecDriverEvents: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864403, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
691 pub const Audit_System_Integrity: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864402, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
692 pub const Audit_System_Others: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864404, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
693 pub const Audit_System_SecurityStateChange: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864400, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
694 pub const Audit_System_SecuritySubsystemExtension: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(214864401, 27054, 4569, [190, 211, 80, 80, 84, 80, 48, 48]);
695 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
696 #[repr(C)]
697 #[cfg(feature = "Win32_Foundation")]
698 pub struct CENTRAL_ACCESS_POLICY {
699     pub CAPID: super::super::super::Foundation::PSID,
700     pub Name: super::super::super::Foundation::UNICODE_STRING,
701     pub Description: super::super::super::Foundation::UNICODE_STRING,
702     pub ChangeId: super::super::super::Foundation::UNICODE_STRING,
703     pub Flags: u32,
704     pub CAPECount: u32,
705     pub CAPEs: *mut *mut CENTRAL_ACCESS_POLICY_ENTRY,
706 }
707 #[cfg(feature = "Win32_Foundation")]
708 impl CENTRAL_ACCESS_POLICY {}
709 #[cfg(feature = "Win32_Foundation")]
710 impl ::std::default::Default for CENTRAL_ACCESS_POLICY {
711     fn default() -> Self {
712         unsafe { ::std::mem::zeroed() }
713     }
714 }
715 #[cfg(feature = "Win32_Foundation")]
716 impl ::std::fmt::Debug for CENTRAL_ACCESS_POLICY {
717     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
718         fmt.debug_struct("CENTRAL_ACCESS_POLICY").field("CAPID", &self.CAPID).field("Name", &self.Name).field("Description", &self.Description).field("ChangeId", &self.ChangeId).field("Flags", &self.Flags).field("CAPECount", &self.CAPECount).field("CAPEs", &self.CAPEs).finish()
719     }
720 }
721 #[cfg(feature = "Win32_Foundation")]
722 impl ::std::cmp::PartialEq for CENTRAL_ACCESS_POLICY {
723     fn eq(&self, other: &Self) -> bool {
724         self.CAPID == other.CAPID && self.Name == other.Name && self.Description == other.Description && self.ChangeId == other.ChangeId && self.Flags == other.Flags && self.CAPECount == other.CAPECount && self.CAPEs == other.CAPEs
725     }
726 }
727 #[cfg(feature = "Win32_Foundation")]
728 impl ::std::cmp::Eq for CENTRAL_ACCESS_POLICY {}
729 #[cfg(feature = "Win32_Foundation")]
730 unsafe impl ::windows::runtime::Abi for CENTRAL_ACCESS_POLICY {
731     type Abi = Self;
732     type DefaultType = Self;
733 }
734 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
735 #[repr(C)]
736 #[cfg(feature = "Win32_Foundation")]
737 pub struct CENTRAL_ACCESS_POLICY_ENTRY {
738     pub Name: super::super::super::Foundation::UNICODE_STRING,
739     pub Description: super::super::super::Foundation::UNICODE_STRING,
740     pub ChangeId: super::super::super::Foundation::UNICODE_STRING,
741     pub LengthAppliesTo: u32,
742     pub AppliesTo: *mut u8,
743     pub LengthSD: u32,
744     pub SD: *mut super::super::SECURITY_DESCRIPTOR,
745     pub LengthStagedSD: u32,
746     pub StagedSD: *mut super::super::SECURITY_DESCRIPTOR,
747     pub Flags: u32,
748 }
749 #[cfg(feature = "Win32_Foundation")]
750 impl CENTRAL_ACCESS_POLICY_ENTRY {}
751 #[cfg(feature = "Win32_Foundation")]
752 impl ::std::default::Default for CENTRAL_ACCESS_POLICY_ENTRY {
753     fn default() -> Self {
754         unsafe { ::std::mem::zeroed() }
755     }
756 }
757 #[cfg(feature = "Win32_Foundation")]
758 impl ::std::fmt::Debug for CENTRAL_ACCESS_POLICY_ENTRY {
759     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
760         fmt.debug_struct("CENTRAL_ACCESS_POLICY_ENTRY")
761             .field("Name", &self.Name)
762             .field("Description", &self.Description)
763             .field("ChangeId", &self.ChangeId)
764             .field("LengthAppliesTo", &self.LengthAppliesTo)
765             .field("AppliesTo", &self.AppliesTo)
766             .field("LengthSD", &self.LengthSD)
767             .field("SD", &self.SD)
768             .field("LengthStagedSD", &self.LengthStagedSD)
769             .field("StagedSD", &self.StagedSD)
770             .field("Flags", &self.Flags)
771             .finish()
772     }
773 }
774 #[cfg(feature = "Win32_Foundation")]
775 impl ::std::cmp::PartialEq for CENTRAL_ACCESS_POLICY_ENTRY {
776     fn eq(&self, other: &Self) -> bool {
777         self.Name == other.Name && self.Description == other.Description && self.ChangeId == other.ChangeId && self.LengthAppliesTo == other.LengthAppliesTo && self.AppliesTo == other.AppliesTo && self.LengthSD == other.LengthSD && self.SD == other.SD && self.LengthStagedSD == other.LengthStagedSD && self.StagedSD == other.StagedSD && self.Flags == other.Flags
778     }
779 }
780 #[cfg(feature = "Win32_Foundation")]
781 impl ::std::cmp::Eq for CENTRAL_ACCESS_POLICY_ENTRY {}
782 #[cfg(feature = "Win32_Foundation")]
783 unsafe impl ::windows::runtime::Abi for CENTRAL_ACCESS_POLICY_ENTRY {
784     type Abi = Self;
785     type DefaultType = Self;
786 }
787 pub const CENTRAL_ACCESS_POLICY_OWNER_RIGHTS_PRESENT_FLAG: u32 = 1u32;
788 pub const CENTRAL_ACCESS_POLICY_STAGED_FLAG: u32 = 65536u32;
789 pub const CENTRAL_ACCESS_POLICY_STAGED_OWNER_RIGHTS_PRESENT_FLAG: u32 = 256u32;
790 #[cfg(feature = "Win32_Foundation")]
791 pub type CHANGE_PASSWORD_FN_A = unsafe extern "system" fn(param0: *mut i8, param1: *mut i8, param2: *mut i8, param3: *mut i8, param4: *mut i8, param5: super::super::super::Foundation::BOOLEAN, param6: u32, param7: *mut SecBufferDesc) -> i32;
792 #[cfg(feature = "Win32_Foundation")]
793 pub type CHANGE_PASSWORD_FN_W = unsafe extern "system" fn(param0: *mut u16, param1: *mut u16, param2: *mut u16, param3: *mut u16, param4: *mut u16, param5: super::super::super::Foundation::BOOLEAN, param6: u32, param7: *mut SecBufferDesc) -> i32;
794 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
795 #[repr(C)]
796 #[cfg(feature = "Win32_Foundation")]
797 pub struct CLEAR_BLOCK {
798     pub data: [super::super::super::Foundation::CHAR; 8],
799 }
800 #[cfg(feature = "Win32_Foundation")]
801 impl CLEAR_BLOCK {}
802 #[cfg(feature = "Win32_Foundation")]
803 impl ::std::default::Default for CLEAR_BLOCK {
804     fn default() -> Self {
805         unsafe { ::std::mem::zeroed() }
806     }
807 }
808 #[cfg(feature = "Win32_Foundation")]
809 impl ::std::fmt::Debug for CLEAR_BLOCK {
810     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
811         fmt.debug_struct("CLEAR_BLOCK").field("data", &self.data).finish()
812     }
813 }
814 #[cfg(feature = "Win32_Foundation")]
815 impl ::std::cmp::PartialEq for CLEAR_BLOCK {
816     fn eq(&self, other: &Self) -> bool {
817         self.data == other.data
818     }
819 }
820 #[cfg(feature = "Win32_Foundation")]
821 impl ::std::cmp::Eq for CLEAR_BLOCK {}
822 #[cfg(feature = "Win32_Foundation")]
823 unsafe impl ::windows::runtime::Abi for CLEAR_BLOCK {
824     type Abi = Self;
825     type DefaultType = Self;
826 }
827 pub const CLEAR_BLOCK_LENGTH: u32 = 8u32;
828 #[cfg(feature = "Win32_Security_Credentials")]
829 pub type COMPLETE_AUTH_TOKEN_FN = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: *mut SecBufferDesc) -> i32;
830 pub const CREDP_FLAGS_CLEAR_PASSWORD: u32 = 8u32;
831 pub const CREDP_FLAGS_DONT_CACHE_TI: u32 = 4u32;
832 pub const CREDP_FLAGS_IN_PROCESS: u32 = 1u32;
833 pub const CREDP_FLAGS_TRUSTED_CALLER: u32 = 32u32;
834 pub const CREDP_FLAGS_USER_ENCRYPTED_PASSWORD: u32 = 16u32;
835 pub const CREDP_FLAGS_USE_MIDL_HEAP: u32 = 2u32;
836 pub const CREDP_FLAGS_VALIDATE_PROXY_TARGET: u32 = 64u32;
837 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
838 #[repr(transparent)]
839 pub struct CRED_FETCH(pub i32);
840 pub const CredFetchDefault: CRED_FETCH = CRED_FETCH(0i32);
841 pub const CredFetchDPAPI: CRED_FETCH = CRED_FETCH(1i32);
842 pub const CredFetchForced: CRED_FETCH = CRED_FETCH(2i32);
843 impl ::std::convert::From<i32> for CRED_FETCH {
844     fn from(value: i32) -> Self {
845         Self(value)
846     }
847 }
848 unsafe impl ::windows::runtime::Abi for CRED_FETCH {
849     type Abi = Self;
850     type DefaultType = Self;
851 }
852 pub const CRED_MARSHALED_TI_SIZE_SIZE: u32 = 12u32;
853 pub const CYPHER_BLOCK_LENGTH: u32 = 8u32;
854 #[cfg(feature = "Win32_Foundation")]
855 #[inline]
856 pub unsafe fn ChangeAccountPasswordA<'a, Param5: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOLEAN>>(pszpackagename: *const i8, pszdomainname: *const i8, pszaccountname: *const i8, pszoldpassword: *const i8, psznewpassword: *const i8, bimpersonating: Param5, dwreserved: u32, poutput: *mut SecBufferDesc) -> i32 {
857     #[cfg(windows)]
858     {
859         #[link(name = "windows")]
860         extern "system" {
861             fn ChangeAccountPasswordA(pszpackagename: *const i8, pszdomainname: *const i8, pszaccountname: *const i8, pszoldpassword: *const i8, psznewpassword: *const i8, bimpersonating: super::super::super::Foundation::BOOLEAN, dwreserved: u32, poutput: *mut SecBufferDesc) -> i32;
862         }
863         ::std::mem::transmute(ChangeAccountPasswordA(
864             ::std::mem::transmute(pszpackagename),
865             ::std::mem::transmute(pszdomainname),
866             ::std::mem::transmute(pszaccountname),
867             ::std::mem::transmute(pszoldpassword),
868             ::std::mem::transmute(psznewpassword),
869             bimpersonating.into_param().abi(),
870             ::std::mem::transmute(dwreserved),
871             ::std::mem::transmute(poutput),
872         ))
873     }
874     #[cfg(not(windows))]
875     unimplemented!("Unsupported target OS");
876 }
877 #[cfg(feature = "Win32_Foundation")]
878 #[inline]
879 pub unsafe fn ChangeAccountPasswordW<'a, Param5: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOLEAN>>(pszpackagename: *const u16, pszdomainname: *const u16, pszaccountname: *const u16, pszoldpassword: *const u16, psznewpassword: *const u16, bimpersonating: Param5, dwreserved: u32, poutput: *mut SecBufferDesc) -> i32 {
880     #[cfg(windows)]
881     {
882         #[link(name = "windows")]
883         extern "system" {
884             fn ChangeAccountPasswordW(pszpackagename: *const u16, pszdomainname: *const u16, pszaccountname: *const u16, pszoldpassword: *const u16, psznewpassword: *const u16, bimpersonating: super::super::super::Foundation::BOOLEAN, dwreserved: u32, poutput: *mut SecBufferDesc) -> i32;
885         }
886         ::std::mem::transmute(ChangeAccountPasswordW(
887             ::std::mem::transmute(pszpackagename),
888             ::std::mem::transmute(pszdomainname),
889             ::std::mem::transmute(pszaccountname),
890             ::std::mem::transmute(pszoldpassword),
891             ::std::mem::transmute(psznewpassword),
892             bimpersonating.into_param().abi(),
893             ::std::mem::transmute(dwreserved),
894             ::std::mem::transmute(poutput),
895         ))
896     }
897     #[cfg(not(windows))]
898     unimplemented!("Unsupported target OS");
899 }
900 #[cfg(feature = "Win32_Security_Credentials")]
901 #[inline]
902 pub unsafe fn CompleteAuthToken(phcontext: *const super::super::Credentials::SecHandle, ptoken: *const SecBufferDesc) -> i32 {
903     #[cfg(windows)]
904     {
905         #[link(name = "windows")]
906         extern "system" {
907             fn CompleteAuthToken(phcontext: *const super::super::Credentials::SecHandle, ptoken: *const SecBufferDesc) -> i32;
908         }
909         ::std::mem::transmute(CompleteAuthToken(::std::mem::transmute(phcontext), ::std::mem::transmute(ptoken)))
910     }
911     #[cfg(not(windows))]
912     unimplemented!("Unsupported target OS");
913 }
914 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
915 pub type CredFreeCredentialsFn = unsafe extern "system" fn(count: u32, credentials: *mut *mut ENCRYPTED_CREDENTIALW);
916 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
917 #[inline]
918 pub unsafe fn CredMarshalTargetInfo(intargetinfo: *const super::super::Credentials::CREDENTIAL_TARGET_INFORMATIONW, buffer: *mut *mut u16, buffersize: *mut u32) -> ::windows::runtime::Result<()> {
919     #[cfg(windows)]
920     {
921         #[link(name = "windows")]
922         extern "system" {
923             fn CredMarshalTargetInfo(intargetinfo: *const super::super::Credentials::CREDENTIAL_TARGET_INFORMATIONW, buffer: *mut *mut u16, buffersize: *mut u32) -> super::super::super::Foundation::NTSTATUS;
924         }
925         CredMarshalTargetInfo(::std::mem::transmute(intargetinfo), ::std::mem::transmute(buffer), ::std::mem::transmute(buffersize)).ok()
926     }
927     #[cfg(not(windows))]
928     unimplemented!("Unsupported target OS");
929 }
930 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
931 pub type CredReadDomainCredentialsFn = unsafe extern "system" fn(logonid: *const super::super::super::Foundation::LUID, credflags: u32, targetinfo: *const super::super::Credentials::CREDENTIAL_TARGET_INFORMATIONW, flags: u32, count: *mut u32, credential: *mut *mut *mut ENCRYPTED_CREDENTIALW) -> super::super::super::Foundation::NTSTATUS;
932 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
933 pub type CredReadFn = unsafe extern "system" fn(logonid: *const super::super::super::Foundation::LUID, credflags: u32, targetname: super::super::super::Foundation::PWSTR, r#type: u32, flags: u32, credential: *mut *mut ENCRYPTED_CREDENTIALW) -> super::super::super::Foundation::NTSTATUS;
934 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
935 #[inline]
936 pub unsafe fn CredUnmarshalTargetInfo(buffer: *const u16, buffersize: u32, rettargetinfo: *mut *mut super::super::Credentials::CREDENTIAL_TARGET_INFORMATIONW, retactualsize: *mut u32) -> ::windows::runtime::Result<()> {
937     #[cfg(windows)]
938     {
939         #[link(name = "windows")]
940         extern "system" {
941             fn CredUnmarshalTargetInfo(buffer: *const u16, buffersize: u32, rettargetinfo: *mut *mut super::super::Credentials::CREDENTIAL_TARGET_INFORMATIONW, retactualsize: *mut u32) -> super::super::super::Foundation::NTSTATUS;
942         }
943         CredUnmarshalTargetInfo(::std::mem::transmute(buffer), ::std::mem::transmute(buffersize), ::std::mem::transmute(rettargetinfo), ::std::mem::transmute(retactualsize)).ok()
944     }
945     #[cfg(not(windows))]
946     unimplemented!("Unsupported target OS");
947 }
948 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
949 pub type CredWriteFn = unsafe extern "system" fn(logonid: *const super::super::super::Foundation::LUID, credflags: u32, credential: *const ENCRYPTED_CREDENTIALW, flags: u32) -> super::super::super::Foundation::NTSTATUS;
950 #[cfg(feature = "Win32_Foundation")]
951 pub type CrediUnmarshalandDecodeStringFn = unsafe extern "system" fn(marshaledstring: super::super::super::Foundation::PWSTR, blob: *mut *mut u8, blobsize: *mut u32, isfailurefatal: *mut u8) -> super::super::super::Foundation::NTSTATUS;
952 #[cfg(feature = "Win32_Security_Credentials")]
953 pub type DECRYPT_MESSAGE_FN = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: *mut SecBufferDesc, param2: u32, param3: *mut u32) -> i32;
954 #[cfg(feature = "Win32_Security_Credentials")]
955 pub type DELETE_SECURITY_CONTEXT_FN = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle) -> i32;
956 pub const DOMAIN_NO_LM_OWF_CHANGE: i32 = 64i32;
957 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
958 #[repr(C)]
959 pub struct DOMAIN_PASSWORD_INFORMATION {
960     pub MinPasswordLength: u16,
961     pub PasswordHistoryLength: u16,
962     pub PasswordProperties: DOMAIN_PASSWORD_PROPERTIES,
963     pub MaxPasswordAge: i64,
964     pub MinPasswordAge: i64,
965 }
966 impl DOMAIN_PASSWORD_INFORMATION {}
967 impl ::std::default::Default for DOMAIN_PASSWORD_INFORMATION {
968     fn default() -> Self {
969         unsafe { ::std::mem::zeroed() }
970     }
971 }
972 impl ::std::fmt::Debug for DOMAIN_PASSWORD_INFORMATION {
973     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
974         fmt.debug_struct("DOMAIN_PASSWORD_INFORMATION")
975             .field("MinPasswordLength", &self.MinPasswordLength)
976             .field("PasswordHistoryLength", &self.PasswordHistoryLength)
977             .field("PasswordProperties", &self.PasswordProperties)
978             .field("MaxPasswordAge", &self.MaxPasswordAge)
979             .field("MinPasswordAge", &self.MinPasswordAge)
980             .finish()
981     }
982 }
983 impl ::std::cmp::PartialEq for DOMAIN_PASSWORD_INFORMATION {
984     fn eq(&self, other: &Self) -> bool {
985         self.MinPasswordLength == other.MinPasswordLength && self.PasswordHistoryLength == other.PasswordHistoryLength && self.PasswordProperties == other.PasswordProperties && self.MaxPasswordAge == other.MaxPasswordAge && self.MinPasswordAge == other.MinPasswordAge
986     }
987 }
988 impl ::std::cmp::Eq for DOMAIN_PASSWORD_INFORMATION {}
989 unsafe impl ::windows::runtime::Abi for DOMAIN_PASSWORD_INFORMATION {
990     type Abi = Self;
991     type DefaultType = Self;
992 }
993 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
994 #[repr(transparent)]
995 pub struct DOMAIN_PASSWORD_PROPERTIES(pub u32);
996 pub const DOMAIN_PASSWORD_COMPLEX: DOMAIN_PASSWORD_PROPERTIES = DOMAIN_PASSWORD_PROPERTIES(1u32);
997 pub const DOMAIN_PASSWORD_NO_ANON_CHANGE: DOMAIN_PASSWORD_PROPERTIES = DOMAIN_PASSWORD_PROPERTIES(2u32);
998 pub const DOMAIN_PASSWORD_NO_CLEAR_CHANGE: DOMAIN_PASSWORD_PROPERTIES = DOMAIN_PASSWORD_PROPERTIES(4u32);
999 pub const DOMAIN_LOCKOUT_ADMINS: DOMAIN_PASSWORD_PROPERTIES = DOMAIN_PASSWORD_PROPERTIES(8u32);
1000 pub const DOMAIN_PASSWORD_STORE_CLEARTEXT: DOMAIN_PASSWORD_PROPERTIES = DOMAIN_PASSWORD_PROPERTIES(16u32);
1001 pub const DOMAIN_REFUSE_PASSWORD_CHANGE: DOMAIN_PASSWORD_PROPERTIES = DOMAIN_PASSWORD_PROPERTIES(32u32);
1002 impl ::std::convert::From<u32> for DOMAIN_PASSWORD_PROPERTIES {
1003     fn from(value: u32) -> Self {
1004         Self(value)
1005     }
1006 }
1007 unsafe impl ::windows::runtime::Abi for DOMAIN_PASSWORD_PROPERTIES {
1008     type Abi = Self;
1009     type DefaultType = Self;
1010 }
1011 impl ::std::ops::BitOr for DOMAIN_PASSWORD_PROPERTIES {
1012     type Output = Self;
1013     fn bitor(self, rhs: Self) -> Self {
1014         Self(self.0 | rhs.0)
1015     }
1016 }
1017 impl ::std::ops::BitAnd for DOMAIN_PASSWORD_PROPERTIES {
1018     type Output = Self;
1019     fn bitand(self, rhs: Self) -> Self {
1020         Self(self.0 & rhs.0)
1021     }
1022 }
1023 impl ::std::ops::BitOrAssign for DOMAIN_PASSWORD_PROPERTIES {
1024     fn bitor_assign(&mut self, rhs: Self) {
1025         self.0.bitor_assign(rhs.0)
1026     }
1027 }
1028 impl ::std::ops::BitAndAssign for DOMAIN_PASSWORD_PROPERTIES {
1029     fn bitand_assign(&mut self, rhs: Self) {
1030         self.0.bitand_assign(rhs.0)
1031     }
1032 }
1033 impl ::std::ops::Not for DOMAIN_PASSWORD_PROPERTIES {
1034     type Output = Self;
1035     fn not(self) -> Self {
1036         Self(self.0.not())
1037     }
1038 }
1039 pub const DS_UNKNOWN_ADDRESS_TYPE: u32 = 0u32;
1040 #[cfg(feature = "Win32_Security_Credentials")]
1041 #[inline]
1042 pub unsafe fn DecryptMessage(phcontext: *const super::super::Credentials::SecHandle, pmessage: *const SecBufferDesc, messageseqno: u32, pfqop: *mut u32) -> i32 {
1043     #[cfg(windows)]
1044     {
1045         #[link(name = "windows")]
1046         extern "system" {
1047             fn DecryptMessage(phcontext: *const super::super::Credentials::SecHandle, pmessage: *const SecBufferDesc, messageseqno: u32, pfqop: *mut u32) -> i32;
1048         }
1049         ::std::mem::transmute(DecryptMessage(::std::mem::transmute(phcontext), ::std::mem::transmute(pmessage), ::std::mem::transmute(messageseqno), ::std::mem::transmute(pfqop)))
1050     }
1051     #[cfg(not(windows))]
1052     unimplemented!("Unsupported target OS");
1053 }
1054 #[cfg(feature = "Win32_Security_Credentials")]
1055 #[inline]
1056 pub unsafe fn DeleteSecurityContext(phcontext: *const super::super::Credentials::SecHandle) -> i32 {
1057     #[cfg(windows)]
1058     {
1059         #[link(name = "windows")]
1060         extern "system" {
1061             fn DeleteSecurityContext(phcontext: *const super::super::Credentials::SecHandle) -> i32;
1062         }
1063         ::std::mem::transmute(DeleteSecurityContext(::std::mem::transmute(phcontext)))
1064     }
1065     #[cfg(not(windows))]
1066     unimplemented!("Unsupported target OS");
1067 }
1068 #[cfg(feature = "Win32_Foundation")]
1069 #[inline]
1070 pub unsafe fn DeleteSecurityPackageA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSTR>>(pszpackagename: Param0) -> i32 {
1071     #[cfg(windows)]
1072     {
1073         #[link(name = "windows")]
1074         extern "system" {
1075             fn DeleteSecurityPackageA(pszpackagename: super::super::super::Foundation::PSTR) -> i32;
1076         }
1077         ::std::mem::transmute(DeleteSecurityPackageA(pszpackagename.into_param().abi()))
1078     }
1079     #[cfg(not(windows))]
1080     unimplemented!("Unsupported target OS");
1081 }
1082 #[cfg(feature = "Win32_Foundation")]
1083 #[inline]
1084 pub unsafe fn DeleteSecurityPackageW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pszpackagename: Param0) -> i32 {
1085     #[cfg(windows)]
1086     {
1087         #[link(name = "windows")]
1088         extern "system" {
1089             fn DeleteSecurityPackageW(pszpackagename: super::super::super::Foundation::PWSTR) -> i32;
1090         }
1091         ::std::mem::transmute(DeleteSecurityPackageW(pszpackagename.into_param().abi()))
1092     }
1093     #[cfg(not(windows))]
1094     unimplemented!("Unsupported target OS");
1095 }
1096 pub const ENABLE_TLS_CLIENT_EARLY_START: u32 = 1u32;
1097 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1098 #[repr(C)]
1099 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
1100 pub struct ENCRYPTED_CREDENTIALW {
1101     pub Cred: super::super::Credentials::CREDENTIALW,
1102     pub ClearCredentialBlobSize: u32,
1103 }
1104 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
1105 impl ENCRYPTED_CREDENTIALW {}
1106 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
1107 impl ::std::default::Default for ENCRYPTED_CREDENTIALW {
1108     fn default() -> Self {
1109         unsafe { ::std::mem::zeroed() }
1110     }
1111 }
1112 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
1113 impl ::std::fmt::Debug for ENCRYPTED_CREDENTIALW {
1114     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1115         fmt.debug_struct("ENCRYPTED_CREDENTIALW").field("Cred", &self.Cred).field("ClearCredentialBlobSize", &self.ClearCredentialBlobSize).finish()
1116     }
1117 }
1118 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
1119 impl ::std::cmp::PartialEq for ENCRYPTED_CREDENTIALW {
1120     fn eq(&self, other: &Self) -> bool {
1121         self.Cred == other.Cred && self.ClearCredentialBlobSize == other.ClearCredentialBlobSize
1122     }
1123 }
1124 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
1125 impl ::std::cmp::Eq for ENCRYPTED_CREDENTIALW {}
1126 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
1127 unsafe impl ::windows::runtime::Abi for ENCRYPTED_CREDENTIALW {
1128     type Abi = Self;
1129     type DefaultType = Self;
1130 }
1131 #[cfg(feature = "Win32_Security_Credentials")]
1132 pub type ENCRYPT_MESSAGE_FN = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: u32, param2: *mut SecBufferDesc, param3: u32) -> i32;
1133 pub type ENUMERATE_SECURITY_PACKAGES_FN_A = unsafe extern "system" fn(param0: *mut u32, param1: *mut *mut SecPkgInfoA) -> i32;
1134 pub type ENUMERATE_SECURITY_PACKAGES_FN_W = unsafe extern "system" fn(param0: *mut u32, param1: *mut *mut SecPkgInfoW) -> i32;
1135 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1136 #[repr(transparent)]
1137 pub struct EXPORT_SECURITY_CONTEXT_FLAGS(pub u32);
1138 pub const SECPKG_CONTEXT_EXPORT_RESET_NEW: EXPORT_SECURITY_CONTEXT_FLAGS = EXPORT_SECURITY_CONTEXT_FLAGS(1u32);
1139 pub const SECPKG_CONTEXT_EXPORT_DELETE_OLD: EXPORT_SECURITY_CONTEXT_FLAGS = EXPORT_SECURITY_CONTEXT_FLAGS(2u32);
1140 pub const SECPKG_CONTEXT_EXPORT_TO_KERNEL: EXPORT_SECURITY_CONTEXT_FLAGS = EXPORT_SECURITY_CONTEXT_FLAGS(4u32);
1141 impl ::std::convert::From<u32> for EXPORT_SECURITY_CONTEXT_FLAGS {
1142     fn from(value: u32) -> Self {
1143         Self(value)
1144     }
1145 }
1146 unsafe impl ::windows::runtime::Abi for EXPORT_SECURITY_CONTEXT_FLAGS {
1147     type Abi = Self;
1148     type DefaultType = Self;
1149 }
1150 impl ::std::ops::BitOr for EXPORT_SECURITY_CONTEXT_FLAGS {
1151     type Output = Self;
1152     fn bitor(self, rhs: Self) -> Self {
1153         Self(self.0 | rhs.0)
1154     }
1155 }
1156 impl ::std::ops::BitAnd for EXPORT_SECURITY_CONTEXT_FLAGS {
1157     type Output = Self;
1158     fn bitand(self, rhs: Self) -> Self {
1159         Self(self.0 & rhs.0)
1160     }
1161 }
1162 impl ::std::ops::BitOrAssign for EXPORT_SECURITY_CONTEXT_FLAGS {
1163     fn bitor_assign(&mut self, rhs: Self) {
1164         self.0.bitor_assign(rhs.0)
1165     }
1166 }
1167 impl ::std::ops::BitAndAssign for EXPORT_SECURITY_CONTEXT_FLAGS {
1168     fn bitand_assign(&mut self, rhs: Self) {
1169         self.0.bitand_assign(rhs.0)
1170     }
1171 }
1172 impl ::std::ops::Not for EXPORT_SECURITY_CONTEXT_FLAGS {
1173     type Output = Self;
1174     fn not(self) -> Self {
1175         Self(self.0.not())
1176     }
1177 }
1178 #[cfg(feature = "Win32_Security_Credentials")]
1179 pub type EXPORT_SECURITY_CONTEXT_FN = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: u32, param2: *mut SecBuffer, param3: *mut *mut ::std::ffi::c_void) -> i32;
1180 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1181 #[repr(transparent)]
1182 pub struct EXTENDED_NAME_FORMAT(pub i32);
1183 pub const NameUnknown: EXTENDED_NAME_FORMAT = EXTENDED_NAME_FORMAT(0i32);
1184 pub const NameFullyQualifiedDN: EXTENDED_NAME_FORMAT = EXTENDED_NAME_FORMAT(1i32);
1185 pub const NameSamCompatible: EXTENDED_NAME_FORMAT = EXTENDED_NAME_FORMAT(2i32);
1186 pub const NameDisplay: EXTENDED_NAME_FORMAT = EXTENDED_NAME_FORMAT(3i32);
1187 pub const NameUniqueId: EXTENDED_NAME_FORMAT = EXTENDED_NAME_FORMAT(6i32);
1188 pub const NameCanonical: EXTENDED_NAME_FORMAT = EXTENDED_NAME_FORMAT(7i32);
1189 pub const NameUserPrincipal: EXTENDED_NAME_FORMAT = EXTENDED_NAME_FORMAT(8i32);
1190 pub const NameCanonicalEx: EXTENDED_NAME_FORMAT = EXTENDED_NAME_FORMAT(9i32);
1191 pub const NameServicePrincipal: EXTENDED_NAME_FORMAT = EXTENDED_NAME_FORMAT(10i32);
1192 pub const NameDnsDomain: EXTENDED_NAME_FORMAT = EXTENDED_NAME_FORMAT(12i32);
1193 pub const NameGivenName: EXTENDED_NAME_FORMAT = EXTENDED_NAME_FORMAT(13i32);
1194 pub const NameSurname: EXTENDED_NAME_FORMAT = EXTENDED_NAME_FORMAT(14i32);
1195 impl ::std::convert::From<i32> for EXTENDED_NAME_FORMAT {
1196     fn from(value: i32) -> Self {
1197         Self(value)
1198     }
1199 }
1200 unsafe impl ::windows::runtime::Abi for EXTENDED_NAME_FORMAT {
1201     type Abi = Self;
1202     type DefaultType = Self;
1203 }
1204 pub const E_RM_UNKNOWN_ERROR: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073415165i32 as _);
1205 #[cfg(feature = "Win32_Security_Credentials")]
1206 #[inline]
1207 pub unsafe fn EncryptMessage(phcontext: *const super::super::Credentials::SecHandle, fqop: u32, pmessage: *const SecBufferDesc, messageseqno: u32) -> i32 {
1208     #[cfg(windows)]
1209     {
1210         #[link(name = "windows")]
1211         extern "system" {
1212             fn EncryptMessage(phcontext: *const super::super::Credentials::SecHandle, fqop: u32, pmessage: *const SecBufferDesc, messageseqno: u32) -> i32;
1213         }
1214         ::std::mem::transmute(EncryptMessage(::std::mem::transmute(phcontext), ::std::mem::transmute(fqop), ::std::mem::transmute(pmessage), ::std::mem::transmute(messageseqno)))
1215     }
1216     #[cfg(not(windows))]
1217     unimplemented!("Unsupported target OS");
1218 }
1219 #[inline]
1220 pub unsafe fn EnumerateSecurityPackagesA(pcpackages: *mut u32, pppackageinfo: *mut *mut SecPkgInfoA) -> i32 {
1221     #[cfg(windows)]
1222     {
1223         #[link(name = "windows")]
1224         extern "system" {
1225             fn EnumerateSecurityPackagesA(pcpackages: *mut u32, pppackageinfo: *mut *mut SecPkgInfoA) -> i32;
1226         }
1227         ::std::mem::transmute(EnumerateSecurityPackagesA(::std::mem::transmute(pcpackages), ::std::mem::transmute(pppackageinfo)))
1228     }
1229     #[cfg(not(windows))]
1230     unimplemented!("Unsupported target OS");
1231 }
1232 #[inline]
1233 pub unsafe fn EnumerateSecurityPackagesW(pcpackages: *mut u32, pppackageinfo: *mut *mut SecPkgInfoW) -> i32 {
1234     #[cfg(windows)]
1235     {
1236         #[link(name = "windows")]
1237         extern "system" {
1238             fn EnumerateSecurityPackagesW(pcpackages: *mut u32, pppackageinfo: *mut *mut SecPkgInfoW) -> i32;
1239         }
1240         ::std::mem::transmute(EnumerateSecurityPackagesW(::std::mem::transmute(pcpackages), ::std::mem::transmute(pppackageinfo)))
1241     }
1242     #[cfg(not(windows))]
1243     unimplemented!("Unsupported target OS");
1244 }
1245 #[cfg(feature = "Win32_Security_Credentials")]
1246 #[inline]
1247 pub unsafe fn ExportSecurityContext(phcontext: *const super::super::Credentials::SecHandle, fflags: EXPORT_SECURITY_CONTEXT_FLAGS, ppackedcontext: *mut SecBuffer, ptoken: *mut *mut ::std::ffi::c_void) -> i32 {
1248     #[cfg(windows)]
1249     {
1250         #[link(name = "windows")]
1251         extern "system" {
1252             fn ExportSecurityContext(phcontext: *const super::super::Credentials::SecHandle, fflags: EXPORT_SECURITY_CONTEXT_FLAGS, ppackedcontext: *mut SecBuffer, ptoken: *mut *mut ::std::ffi::c_void) -> i32;
1253         }
1254         ::std::mem::transmute(ExportSecurityContext(::std::mem::transmute(phcontext), ::std::mem::transmute(fflags), ::std::mem::transmute(ppackedcontext), ::std::mem::transmute(ptoken)))
1255     }
1256     #[cfg(not(windows))]
1257     unimplemented!("Unsupported target OS");
1258 }
1259 pub const FACILITY_SL_ITF: u32 = 4u32;
1260 pub type FREE_CONTEXT_BUFFER_FN = unsafe extern "system" fn(param0: *mut ::std::ffi::c_void) -> i32;
1261 #[cfg(feature = "Win32_Security_Credentials")]
1262 pub type FREE_CREDENTIALS_HANDLE_FN = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle) -> i32;
1263 #[inline]
1264 pub unsafe fn FreeContextBuffer(pvcontextbuffer: *mut ::std::ffi::c_void) -> i32 {
1265     #[cfg(windows)]
1266     {
1267         #[link(name = "windows")]
1268         extern "system" {
1269             fn FreeContextBuffer(pvcontextbuffer: *mut ::std::ffi::c_void) -> i32;
1270         }
1271         ::std::mem::transmute(FreeContextBuffer(::std::mem::transmute(pvcontextbuffer)))
1272     }
1273     #[cfg(not(windows))]
1274     unimplemented!("Unsupported target OS");
1275 }
1276 #[cfg(feature = "Win32_Security_Credentials")]
1277 #[inline]
1278 pub unsafe fn FreeCredentialsHandle(phcredential: *const super::super::Credentials::SecHandle) -> i32 {
1279     #[cfg(windows)]
1280     {
1281         #[link(name = "windows")]
1282         extern "system" {
1283             fn FreeCredentialsHandle(phcredential: *const super::super::Credentials::SecHandle) -> i32;
1284         }
1285         ::std::mem::transmute(FreeCredentialsHandle(::std::mem::transmute(phcredential)))
1286     }
1287     #[cfg(not(windows))]
1288     unimplemented!("Unsupported target OS");
1289 }
1290 #[cfg(feature = "Win32_Foundation")]
1291 #[inline]
1292 pub unsafe fn GetComputerObjectNameA(nameformat: EXTENDED_NAME_FORMAT, lpnamebuffer: super::super::super::Foundation::PSTR, nsize: *mut u32) -> super::super::super::Foundation::BOOLEAN {
1293     #[cfg(windows)]
1294     {
1295         #[link(name = "windows")]
1296         extern "system" {
1297             fn GetComputerObjectNameA(nameformat: EXTENDED_NAME_FORMAT, lpnamebuffer: super::super::super::Foundation::PSTR, nsize: *mut u32) -> super::super::super::Foundation::BOOLEAN;
1298         }
1299         ::std::mem::transmute(GetComputerObjectNameA(::std::mem::transmute(nameformat), ::std::mem::transmute(lpnamebuffer), ::std::mem::transmute(nsize)))
1300     }
1301     #[cfg(not(windows))]
1302     unimplemented!("Unsupported target OS");
1303 }
1304 #[cfg(feature = "Win32_Foundation")]
1305 #[inline]
1306 pub unsafe fn GetComputerObjectNameW(nameformat: EXTENDED_NAME_FORMAT, lpnamebuffer: super::super::super::Foundation::PWSTR, nsize: *mut u32) -> super::super::super::Foundation::BOOLEAN {
1307     #[cfg(windows)]
1308     {
1309         #[link(name = "windows")]
1310         extern "system" {
1311             fn GetComputerObjectNameW(nameformat: EXTENDED_NAME_FORMAT, lpnamebuffer: super::super::super::Foundation::PWSTR, nsize: *mut u32) -> super::super::super::Foundation::BOOLEAN;
1312         }
1313         ::std::mem::transmute(GetComputerObjectNameW(::std::mem::transmute(nameformat), ::std::mem::transmute(lpnamebuffer), ::std::mem::transmute(nsize)))
1314     }
1315     #[cfg(not(windows))]
1316     unimplemented!("Unsupported target OS");
1317 }
1318 #[cfg(feature = "Win32_Foundation")]
1319 #[inline]
1320 pub unsafe fn GetUserNameExA(nameformat: EXTENDED_NAME_FORMAT, lpnamebuffer: super::super::super::Foundation::PSTR, nsize: *mut u32) -> super::super::super::Foundation::BOOLEAN {
1321     #[cfg(windows)]
1322     {
1323         #[link(name = "windows")]
1324         extern "system" {
1325             fn GetUserNameExA(nameformat: EXTENDED_NAME_FORMAT, lpnamebuffer: super::super::super::Foundation::PSTR, nsize: *mut u32) -> super::super::super::Foundation::BOOLEAN;
1326         }
1327         ::std::mem::transmute(GetUserNameExA(::std::mem::transmute(nameformat), ::std::mem::transmute(lpnamebuffer), ::std::mem::transmute(nsize)))
1328     }
1329     #[cfg(not(windows))]
1330     unimplemented!("Unsupported target OS");
1331 }
1332 #[cfg(feature = "Win32_Foundation")]
1333 #[inline]
1334 pub unsafe fn GetUserNameExW(nameformat: EXTENDED_NAME_FORMAT, lpnamebuffer: super::super::super::Foundation::PWSTR, nsize: *mut u32) -> super::super::super::Foundation::BOOLEAN {
1335     #[cfg(windows)]
1336     {
1337         #[link(name = "windows")]
1338         extern "system" {
1339             fn GetUserNameExW(nameformat: EXTENDED_NAME_FORMAT, lpnamebuffer: super::super::super::Foundation::PWSTR, nsize: *mut u32) -> super::super::super::Foundation::BOOLEAN;
1340         }
1341         ::std::mem::transmute(GetUserNameExW(::std::mem::transmute(nameformat), ::std::mem::transmute(lpnamebuffer), ::std::mem::transmute(nsize)))
1342     }
1343     #[cfg(not(windows))]
1344     unimplemented!("Unsupported target OS");
1345 }
1346 #[repr(transparent)]
1347 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
1348 pub struct ICcgDomainAuthCredentials(::windows::runtime::IUnknown);
1349 impl ICcgDomainAuthCredentials {
1350     #[cfg(feature = "Win32_Foundation")]
1351     pub unsafe fn GetPasswordCredentials<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, plugininput: Param0, domainname: *mut super::super::super::Foundation::PWSTR, username: *mut super::super::super::Foundation::PWSTR, password: *mut super::super::super::Foundation::PWSTR) -> ::windows::runtime::Result<()> {
1352         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), plugininput.into_param().abi(), ::std::mem::transmute(domainname), ::std::mem::transmute(username), ::std::mem::transmute(password)).ok()
1353     }
1354 }
1355 unsafe impl ::windows::runtime::Interface for ICcgDomainAuthCredentials {
1356     type Vtable = ICcgDomainAuthCredentials_abi;
1357     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1858970904, 8208, 17463, [139, 195, 70, 231, 82, 183, 177, 114]);
1358 }
1359 impl ::std::convert::From<ICcgDomainAuthCredentials> for ::windows::runtime::IUnknown {
1360     fn from(value: ICcgDomainAuthCredentials) -> Self {
1361         unsafe { ::std::mem::transmute(value) }
1362     }
1363 }
1364 impl ::std::convert::From<&ICcgDomainAuthCredentials> for ::windows::runtime::IUnknown {
1365     fn from(value: &ICcgDomainAuthCredentials) -> Self {
1366         ::std::convert::From::from(::std::clone::Clone::clone(value))
1367     }
1368 }
1369 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for ICcgDomainAuthCredentials {
1370     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1371         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
1372     }
1373 }
1374 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &ICcgDomainAuthCredentials {
1375     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
1376         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
1377     }
1378 }
1379 #[repr(C)]
1380 #[doc(hidden)]
1381 pub struct ICcgDomainAuthCredentials_abi(
1382     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
1383     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1384     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
1385     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, plugininput: super::super::super::Foundation::PWSTR, domainname: *mut super::super::super::Foundation::PWSTR, username: *mut super::super::super::Foundation::PWSTR, password: *mut super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
1386     #[cfg(not(feature = "Win32_Foundation"))] usize,
1387 );
1388 #[cfg(feature = "Win32_Security_Credentials")]
1389 pub type IMPERSONATE_SECURITY_CONTEXT_FN = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle) -> i32;
1390 #[cfg(feature = "Win32_Security_Credentials")]
1391 pub type IMPORT_SECURITY_CONTEXT_FN_A = unsafe extern "system" fn(param0: *mut i8, param1: *mut SecBuffer, param2: *mut ::std::ffi::c_void, param3: *mut super::super::Credentials::SecHandle) -> i32;
1392 #[cfg(feature = "Win32_Security_Credentials")]
1393 pub type IMPORT_SECURITY_CONTEXT_FN_W = unsafe extern "system" fn(param0: *mut u16, param1: *mut SecBuffer, param2: *mut ::std::ffi::c_void, param3: *mut super::super::Credentials::SecHandle) -> i32;
1394 #[cfg(feature = "Win32_Security_Credentials")]
1395 pub type INITIALIZE_SECURITY_CONTEXT_FN_A = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: *mut super::super::Credentials::SecHandle, param2: *mut i8, param3: u32, param4: u32, param5: u32, param6: *mut SecBufferDesc, param7: u32, param8: *mut super::super::Credentials::SecHandle, param9: *mut SecBufferDesc, param10: *mut u32, param11: *mut i64) -> i32;
1396 #[cfg(feature = "Win32_Security_Credentials")]
1397 pub type INITIALIZE_SECURITY_CONTEXT_FN_W = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: *mut super::super::Credentials::SecHandle, param2: *mut u16, param3: u32, param4: u32, param5: u32, param6: *mut SecBufferDesc, param7: u32, param8: *mut super::super::Credentials::SecHandle, param9: *mut SecBufferDesc, param10: *mut u32, param11: *mut i64) -> i32;
1398 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
1399 pub type INIT_SECURITY_INTERFACE_A = unsafe extern "system" fn() -> *mut SecurityFunctionTableA;
1400 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
1401 pub type INIT_SECURITY_INTERFACE_W = unsafe extern "system" fn() -> *mut SecurityFunctionTableW;
1402 pub const ISC_REQ_ALLOCATE_MEMORY: u32 = 256u32;
1403 pub const ISC_REQ_CALL_LEVEL: u32 = 4096u32;
1404 pub const ISC_REQ_CONFIDENTIALITY: u32 = 16u32;
1405 pub const ISC_REQ_CONFIDENTIALITY_ONLY: u32 = 1073741824u32;
1406 pub const ISC_REQ_CONNECTION: u32 = 2048u32;
1407 pub const ISC_REQ_DATAGRAM: u32 = 1024u32;
1408 pub const ISC_REQ_DEFERRED_CRED_VALIDATION: u64 = 8589934592u64;
1409 pub const ISC_REQ_DELEGATE: u32 = 1u32;
1410 pub const ISC_REQ_EXTENDED_ERROR: u32 = 16384u32;
1411 pub const ISC_REQ_FORWARD_CREDENTIALS: u32 = 4194304u32;
1412 pub const ISC_REQ_FRAGMENT_SUPPLIED: u32 = 8192u32;
1413 pub const ISC_REQ_FRAGMENT_TO_FIT: u32 = 2097152u32;
1414 pub const ISC_REQ_IDENTIFY: u32 = 131072u32;
1415 pub const ISC_REQ_INTEGRITY: u32 = 65536u32;
1416 pub const ISC_REQ_MANUAL_CRED_VALIDATION: u32 = 524288u32;
1417 pub const ISC_REQ_MESSAGES: u64 = 4294967296u64;
1418 pub const ISC_REQ_MUTUAL_AUTH: u32 = 2u32;
1419 pub const ISC_REQ_NO_INTEGRITY: u32 = 8388608u32;
1420 pub const ISC_REQ_NULL_SESSION: u32 = 262144u32;
1421 pub const ISC_REQ_PROMPT_FOR_CREDS: u32 = 64u32;
1422 pub const ISC_REQ_REPLAY_DETECT: u32 = 4u32;
1423 pub const ISC_REQ_RESERVED1: u32 = 1048576u32;
1424 pub const ISC_REQ_SEQUENCE_DETECT: u32 = 8u32;
1425 pub const ISC_REQ_STREAM: u32 = 32768u32;
1426 pub const ISC_REQ_UNVERIFIED_TARGET_NAME: u32 = 536870912u32;
1427 pub const ISC_REQ_USE_DCE_STYLE: u32 = 512u32;
1428 pub const ISC_REQ_USE_HTTP_STYLE: u32 = 16777216u32;
1429 pub const ISC_REQ_USE_SESSION_KEY: u32 = 32u32;
1430 pub const ISC_REQ_USE_SUPPLIED_CREDS: u32 = 128u32;
1431 pub const ISC_RET_ALLOCATED_MEMORY: u32 = 256u32;
1432 pub const ISC_RET_CALL_LEVEL: u32 = 8192u32;
1433 pub const ISC_RET_CONFIDENTIALITY: u32 = 16u32;
1434 pub const ISC_RET_CONFIDENTIALITY_ONLY: u32 = 1073741824u32;
1435 pub const ISC_RET_CONNECTION: u32 = 2048u32;
1436 pub const ISC_RET_DATAGRAM: u32 = 1024u32;
1437 pub const ISC_RET_DEFERRED_CRED_VALIDATION: u64 = 8589934592u64;
1438 pub const ISC_RET_DELEGATE: u32 = 1u32;
1439 pub const ISC_RET_EXTENDED_ERROR: u32 = 16384u32;
1440 pub const ISC_RET_FORWARD_CREDENTIALS: u32 = 4194304u32;
1441 pub const ISC_RET_FRAGMENT_ONLY: u32 = 2097152u32;
1442 pub const ISC_RET_IDENTIFY: u32 = 131072u32;
1443 pub const ISC_RET_INTEGRITY: u32 = 65536u32;
1444 pub const ISC_RET_INTERMEDIATE_RETURN: u32 = 4096u32;
1445 pub const ISC_RET_MANUAL_CRED_VALIDATION: u32 = 524288u32;
1446 pub const ISC_RET_MESSAGES: u64 = 4294967296u64;
1447 pub const ISC_RET_MUTUAL_AUTH: u32 = 2u32;
1448 pub const ISC_RET_NO_ADDITIONAL_TOKEN: u32 = 33554432u32;
1449 pub const ISC_RET_NULL_SESSION: u32 = 262144u32;
1450 pub const ISC_RET_REAUTHENTICATION: u32 = 134217728u32;
1451 pub const ISC_RET_REPLAY_DETECT: u32 = 4u32;
1452 pub const ISC_RET_RESERVED1: u32 = 1048576u32;
1453 pub const ISC_RET_SEQUENCE_DETECT: u32 = 8u32;
1454 pub const ISC_RET_STREAM: u32 = 32768u32;
1455 pub const ISC_RET_USED_COLLECTED_CREDS: u32 = 64u32;
1456 pub const ISC_RET_USED_DCE_STYLE: u32 = 512u32;
1457 pub const ISC_RET_USED_HTTP_STYLE: u32 = 16777216u32;
1458 pub const ISC_RET_USED_SUPPLIED_CREDS: u32 = 128u32;
1459 pub const ISC_RET_USE_SESSION_KEY: u32 = 32u32;
1460 pub const ISSP_LEVEL: u32 = 32u32;
1461 pub const ISSP_MODE: u32 = 1u32;
1462 #[cfg(feature = "Win32_Security_Credentials")]
1463 #[inline]
1464 pub unsafe fn ImpersonateSecurityContext(phcontext: *const super::super::Credentials::SecHandle) -> i32 {
1465     #[cfg(windows)]
1466     {
1467         #[link(name = "windows")]
1468         extern "system" {
1469             fn ImpersonateSecurityContext(phcontext: *const super::super::Credentials::SecHandle) -> i32;
1470         }
1471         ::std::mem::transmute(ImpersonateSecurityContext(::std::mem::transmute(phcontext)))
1472     }
1473     #[cfg(not(windows))]
1474     unimplemented!("Unsupported target OS");
1475 }
1476 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
1477 #[inline]
1478 pub unsafe fn ImportSecurityContextA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSTR>>(pszpackage: Param0, ppackedcontext: *const SecBuffer, token: *const ::std::ffi::c_void, phcontext: *mut super::super::Credentials::SecHandle) -> i32 {
1479     #[cfg(windows)]
1480     {
1481         #[link(name = "windows")]
1482         extern "system" {
1483             fn ImportSecurityContextA(pszpackage: super::super::super::Foundation::PSTR, ppackedcontext: *const SecBuffer, token: *const ::std::ffi::c_void, phcontext: *mut super::super::Credentials::SecHandle) -> i32;
1484         }
1485         ::std::mem::transmute(ImportSecurityContextA(pszpackage.into_param().abi(), ::std::mem::transmute(ppackedcontext), ::std::mem::transmute(token), ::std::mem::transmute(phcontext)))
1486     }
1487     #[cfg(not(windows))]
1488     unimplemented!("Unsupported target OS");
1489 }
1490 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
1491 #[inline]
1492 pub unsafe fn ImportSecurityContextW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pszpackage: Param0, ppackedcontext: *const SecBuffer, token: *const ::std::ffi::c_void, phcontext: *mut super::super::Credentials::SecHandle) -> i32 {
1493     #[cfg(windows)]
1494     {
1495         #[link(name = "windows")]
1496         extern "system" {
1497             fn ImportSecurityContextW(pszpackage: super::super::super::Foundation::PWSTR, ppackedcontext: *const SecBuffer, token: *const ::std::ffi::c_void, phcontext: *mut super::super::Credentials::SecHandle) -> i32;
1498         }
1499         ::std::mem::transmute(ImportSecurityContextW(pszpackage.into_param().abi(), ::std::mem::transmute(ppackedcontext), ::std::mem::transmute(token), ::std::mem::transmute(phcontext)))
1500     }
1501     #[cfg(not(windows))]
1502     unimplemented!("Unsupported target OS");
1503 }
1504 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
1505 #[inline]
1506 pub unsafe fn InitSecurityInterfaceA() -> *mut SecurityFunctionTableA {
1507     #[cfg(windows)]
1508     {
1509         #[link(name = "windows")]
1510         extern "system" {
1511             fn InitSecurityInterfaceA() -> *mut SecurityFunctionTableA;
1512         }
1513         ::std::mem::transmute(InitSecurityInterfaceA())
1514     }
1515     #[cfg(not(windows))]
1516     unimplemented!("Unsupported target OS");
1517 }
1518 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
1519 #[inline]
1520 pub unsafe fn InitSecurityInterfaceW() -> *mut SecurityFunctionTableW {
1521     #[cfg(windows)]
1522     {
1523         #[link(name = "windows")]
1524         extern "system" {
1525             fn InitSecurityInterfaceW() -> *mut SecurityFunctionTableW;
1526         }
1527         ::std::mem::transmute(InitSecurityInterfaceW())
1528     }
1529     #[cfg(not(windows))]
1530     unimplemented!("Unsupported target OS");
1531 }
1532 #[cfg(feature = "Win32_Security_Credentials")]
1533 #[inline]
1534 pub unsafe fn InitializeSecurityContextA(phcredential: *const super::super::Credentials::SecHandle, phcontext: *const super::super::Credentials::SecHandle, psztargetname: *const i8, fcontextreq: u32, reserved1: u32, targetdatarep: u32, pinput: *const SecBufferDesc, reserved2: u32, phnewcontext: *mut super::super::Credentials::SecHandle, poutput: *mut SecBufferDesc, pfcontextattr: *mut u32, ptsexpiry: *mut i64) -> i32 {
1535     #[cfg(windows)]
1536     {
1537         #[link(name = "windows")]
1538         extern "system" {
1539             fn InitializeSecurityContextA(phcredential: *const super::super::Credentials::SecHandle, phcontext: *const super::super::Credentials::SecHandle, psztargetname: *const i8, fcontextreq: u32, reserved1: u32, targetdatarep: u32, pinput: *const SecBufferDesc, reserved2: u32, phnewcontext: *mut super::super::Credentials::SecHandle, poutput: *mut SecBufferDesc, pfcontextattr: *mut u32, ptsexpiry: *mut i64) -> i32;
1540         }
1541         ::std::mem::transmute(InitializeSecurityContextA(
1542             ::std::mem::transmute(phcredential),
1543             ::std::mem::transmute(phcontext),
1544             ::std::mem::transmute(psztargetname),
1545             ::std::mem::transmute(fcontextreq),
1546             ::std::mem::transmute(reserved1),
1547             ::std::mem::transmute(targetdatarep),
1548             ::std::mem::transmute(pinput),
1549             ::std::mem::transmute(reserved2),
1550             ::std::mem::transmute(phnewcontext),
1551             ::std::mem::transmute(poutput),
1552             ::std::mem::transmute(pfcontextattr),
1553             ::std::mem::transmute(ptsexpiry),
1554         ))
1555     }
1556     #[cfg(not(windows))]
1557     unimplemented!("Unsupported target OS");
1558 }
1559 #[cfg(feature = "Win32_Security_Credentials")]
1560 #[inline]
1561 pub unsafe fn InitializeSecurityContextW(phcredential: *const super::super::Credentials::SecHandle, phcontext: *const super::super::Credentials::SecHandle, psztargetname: *const u16, fcontextreq: u32, reserved1: u32, targetdatarep: u32, pinput: *const SecBufferDesc, reserved2: u32, phnewcontext: *mut super::super::Credentials::SecHandle, poutput: *mut SecBufferDesc, pfcontextattr: *mut u32, ptsexpiry: *mut i64) -> i32 {
1562     #[cfg(windows)]
1563     {
1564         #[link(name = "windows")]
1565         extern "system" {
1566             fn InitializeSecurityContextW(phcredential: *const super::super::Credentials::SecHandle, phcontext: *const super::super::Credentials::SecHandle, psztargetname: *const u16, fcontextreq: u32, reserved1: u32, targetdatarep: u32, pinput: *const SecBufferDesc, reserved2: u32, phnewcontext: *mut super::super::Credentials::SecHandle, poutput: *mut SecBufferDesc, pfcontextattr: *mut u32, ptsexpiry: *mut i64) -> i32;
1567         }
1568         ::std::mem::transmute(InitializeSecurityContextW(
1569             ::std::mem::transmute(phcredential),
1570             ::std::mem::transmute(phcontext),
1571             ::std::mem::transmute(psztargetname),
1572             ::std::mem::transmute(fcontextreq),
1573             ::std::mem::transmute(reserved1),
1574             ::std::mem::transmute(targetdatarep),
1575             ::std::mem::transmute(pinput),
1576             ::std::mem::transmute(reserved2),
1577             ::std::mem::transmute(phnewcontext),
1578             ::std::mem::transmute(poutput),
1579             ::std::mem::transmute(pfcontextattr),
1580             ::std::mem::transmute(ptsexpiry),
1581         ))
1582     }
1583     #[cfg(not(windows))]
1584     unimplemented!("Unsupported target OS");
1585 }
1586 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1587 #[repr(C)]
1588 #[cfg(feature = "Win32_Foundation")]
1589 pub struct KDC_PROXY_CACHE_ENTRY_DATA {
1590     pub SinceLastUsed: u64,
1591     pub DomainName: super::super::super::Foundation::UNICODE_STRING,
1592     pub ProxyServerName: super::super::super::Foundation::UNICODE_STRING,
1593     pub ProxyServerVdir: super::super::super::Foundation::UNICODE_STRING,
1594     pub ProxyServerPort: u16,
1595     pub LogonId: super::super::super::Foundation::LUID,
1596     pub CredUserName: super::super::super::Foundation::UNICODE_STRING,
1597     pub CredDomainName: super::super::super::Foundation::UNICODE_STRING,
1598     pub GlobalCache: super::super::super::Foundation::BOOLEAN,
1599 }
1600 #[cfg(feature = "Win32_Foundation")]
1601 impl KDC_PROXY_CACHE_ENTRY_DATA {}
1602 #[cfg(feature = "Win32_Foundation")]
1603 impl ::std::default::Default for KDC_PROXY_CACHE_ENTRY_DATA {
1604     fn default() -> Self {
1605         unsafe { ::std::mem::zeroed() }
1606     }
1607 }
1608 #[cfg(feature = "Win32_Foundation")]
1609 impl ::std::fmt::Debug for KDC_PROXY_CACHE_ENTRY_DATA {
1610     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1611         fmt.debug_struct("KDC_PROXY_CACHE_ENTRY_DATA")
1612             .field("SinceLastUsed", &self.SinceLastUsed)
1613             .field("DomainName", &self.DomainName)
1614             .field("ProxyServerName", &self.ProxyServerName)
1615             .field("ProxyServerVdir", &self.ProxyServerVdir)
1616             .field("ProxyServerPort", &self.ProxyServerPort)
1617             .field("LogonId", &self.LogonId)
1618             .field("CredUserName", &self.CredUserName)
1619             .field("CredDomainName", &self.CredDomainName)
1620             .field("GlobalCache", &self.GlobalCache)
1621             .finish()
1622     }
1623 }
1624 #[cfg(feature = "Win32_Foundation")]
1625 impl ::std::cmp::PartialEq for KDC_PROXY_CACHE_ENTRY_DATA {
1626     fn eq(&self, other: &Self) -> bool {
1627         self.SinceLastUsed == other.SinceLastUsed && self.DomainName == other.DomainName && self.ProxyServerName == other.ProxyServerName && self.ProxyServerVdir == other.ProxyServerVdir && self.ProxyServerPort == other.ProxyServerPort && self.LogonId == other.LogonId && self.CredUserName == other.CredUserName && self.CredDomainName == other.CredDomainName && self.GlobalCache == other.GlobalCache
1628     }
1629 }
1630 #[cfg(feature = "Win32_Foundation")]
1631 impl ::std::cmp::Eq for KDC_PROXY_CACHE_ENTRY_DATA {}
1632 #[cfg(feature = "Win32_Foundation")]
1633 unsafe impl ::windows::runtime::Abi for KDC_PROXY_CACHE_ENTRY_DATA {
1634     type Abi = Self;
1635     type DefaultType = Self;
1636 }
1637 pub const KDC_PROXY_SETTINGS_FLAGS_FORCEPROXY: u32 = 1u32;
1638 pub const KDC_PROXY_SETTINGS_V1: u32 = 1u32;
1639 pub const KERBEROS_REVISION: u32 = 6u32;
1640 pub const KERBEROS_VERSION: u32 = 5u32;
1641 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1642 #[repr(transparent)]
1643 pub struct KERB_ADDRESS_TYPE(pub u32);
1644 pub const DS_INET_ADDRESS: KERB_ADDRESS_TYPE = KERB_ADDRESS_TYPE(1u32);
1645 pub const DS_NETBIOS_ADDRESS: KERB_ADDRESS_TYPE = KERB_ADDRESS_TYPE(2u32);
1646 impl ::std::convert::From<u32> for KERB_ADDRESS_TYPE {
1647     fn from(value: u32) -> Self {
1648         Self(value)
1649     }
1650 }
1651 unsafe impl ::windows::runtime::Abi for KERB_ADDRESS_TYPE {
1652     type Abi = Self;
1653     type DefaultType = Self;
1654 }
1655 impl ::std::ops::BitOr for KERB_ADDRESS_TYPE {
1656     type Output = Self;
1657     fn bitor(self, rhs: Self) -> Self {
1658         Self(self.0 | rhs.0)
1659     }
1660 }
1661 impl ::std::ops::BitAnd for KERB_ADDRESS_TYPE {
1662     type Output = Self;
1663     fn bitand(self, rhs: Self) -> Self {
1664         Self(self.0 & rhs.0)
1665     }
1666 }
1667 impl ::std::ops::BitOrAssign for KERB_ADDRESS_TYPE {
1668     fn bitor_assign(&mut self, rhs: Self) {
1669         self.0.bitor_assign(rhs.0)
1670     }
1671 }
1672 impl ::std::ops::BitAndAssign for KERB_ADDRESS_TYPE {
1673     fn bitand_assign(&mut self, rhs: Self) {
1674         self.0.bitand_assign(rhs.0)
1675     }
1676 }
1677 impl ::std::ops::Not for KERB_ADDRESS_TYPE {
1678     type Output = Self;
1679     fn not(self) -> Self {
1680         Self(self.0.not())
1681     }
1682 }
1683 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1684 #[repr(C)]
1685 #[cfg(feature = "Win32_Foundation")]
1686 pub struct KERB_ADD_BINDING_CACHE_ENTRY_EX_REQUEST {
1687     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
1688     pub RealmName: super::super::super::Foundation::UNICODE_STRING,
1689     pub KdcAddress: super::super::super::Foundation::UNICODE_STRING,
1690     pub AddressType: KERB_ADDRESS_TYPE,
1691     pub DcFlags: u32,
1692 }
1693 #[cfg(feature = "Win32_Foundation")]
1694 impl KERB_ADD_BINDING_CACHE_ENTRY_EX_REQUEST {}
1695 #[cfg(feature = "Win32_Foundation")]
1696 impl ::std::default::Default for KERB_ADD_BINDING_CACHE_ENTRY_EX_REQUEST {
1697     fn default() -> Self {
1698         unsafe { ::std::mem::zeroed() }
1699     }
1700 }
1701 #[cfg(feature = "Win32_Foundation")]
1702 impl ::std::fmt::Debug for KERB_ADD_BINDING_CACHE_ENTRY_EX_REQUEST {
1703     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1704         fmt.debug_struct("KERB_ADD_BINDING_CACHE_ENTRY_EX_REQUEST").field("MessageType", &self.MessageType).field("RealmName", &self.RealmName).field("KdcAddress", &self.KdcAddress).field("AddressType", &self.AddressType).field("DcFlags", &self.DcFlags).finish()
1705     }
1706 }
1707 #[cfg(feature = "Win32_Foundation")]
1708 impl ::std::cmp::PartialEq for KERB_ADD_BINDING_CACHE_ENTRY_EX_REQUEST {
1709     fn eq(&self, other: &Self) -> bool {
1710         self.MessageType == other.MessageType && self.RealmName == other.RealmName && self.KdcAddress == other.KdcAddress && self.AddressType == other.AddressType && self.DcFlags == other.DcFlags
1711     }
1712 }
1713 #[cfg(feature = "Win32_Foundation")]
1714 impl ::std::cmp::Eq for KERB_ADD_BINDING_CACHE_ENTRY_EX_REQUEST {}
1715 #[cfg(feature = "Win32_Foundation")]
1716 unsafe impl ::windows::runtime::Abi for KERB_ADD_BINDING_CACHE_ENTRY_EX_REQUEST {
1717     type Abi = Self;
1718     type DefaultType = Self;
1719 }
1720 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1721 #[repr(C)]
1722 #[cfg(feature = "Win32_Foundation")]
1723 pub struct KERB_ADD_BINDING_CACHE_ENTRY_REQUEST {
1724     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
1725     pub RealmName: super::super::super::Foundation::UNICODE_STRING,
1726     pub KdcAddress: super::super::super::Foundation::UNICODE_STRING,
1727     pub AddressType: KERB_ADDRESS_TYPE,
1728 }
1729 #[cfg(feature = "Win32_Foundation")]
1730 impl KERB_ADD_BINDING_CACHE_ENTRY_REQUEST {}
1731 #[cfg(feature = "Win32_Foundation")]
1732 impl ::std::default::Default for KERB_ADD_BINDING_CACHE_ENTRY_REQUEST {
1733     fn default() -> Self {
1734         unsafe { ::std::mem::zeroed() }
1735     }
1736 }
1737 #[cfg(feature = "Win32_Foundation")]
1738 impl ::std::fmt::Debug for KERB_ADD_BINDING_CACHE_ENTRY_REQUEST {
1739     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1740         fmt.debug_struct("KERB_ADD_BINDING_CACHE_ENTRY_REQUEST").field("MessageType", &self.MessageType).field("RealmName", &self.RealmName).field("KdcAddress", &self.KdcAddress).field("AddressType", &self.AddressType).finish()
1741     }
1742 }
1743 #[cfg(feature = "Win32_Foundation")]
1744 impl ::std::cmp::PartialEq for KERB_ADD_BINDING_CACHE_ENTRY_REQUEST {
1745     fn eq(&self, other: &Self) -> bool {
1746         self.MessageType == other.MessageType && self.RealmName == other.RealmName && self.KdcAddress == other.KdcAddress && self.AddressType == other.AddressType
1747     }
1748 }
1749 #[cfg(feature = "Win32_Foundation")]
1750 impl ::std::cmp::Eq for KERB_ADD_BINDING_CACHE_ENTRY_REQUEST {}
1751 #[cfg(feature = "Win32_Foundation")]
1752 unsafe impl ::windows::runtime::Abi for KERB_ADD_BINDING_CACHE_ENTRY_REQUEST {
1753     type Abi = Self;
1754     type DefaultType = Self;
1755 }
1756 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1757 #[repr(C)]
1758 #[cfg(feature = "Win32_Foundation")]
1759 pub struct KERB_ADD_CREDENTIALS_REQUEST {
1760     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
1761     pub UserName: super::super::super::Foundation::UNICODE_STRING,
1762     pub DomainName: super::super::super::Foundation::UNICODE_STRING,
1763     pub Password: super::super::super::Foundation::UNICODE_STRING,
1764     pub LogonId: super::super::super::Foundation::LUID,
1765     pub Flags: KERB_REQUEST_FLAGS,
1766 }
1767 #[cfg(feature = "Win32_Foundation")]
1768 impl KERB_ADD_CREDENTIALS_REQUEST {}
1769 #[cfg(feature = "Win32_Foundation")]
1770 impl ::std::default::Default for KERB_ADD_CREDENTIALS_REQUEST {
1771     fn default() -> Self {
1772         unsafe { ::std::mem::zeroed() }
1773     }
1774 }
1775 #[cfg(feature = "Win32_Foundation")]
1776 impl ::std::fmt::Debug for KERB_ADD_CREDENTIALS_REQUEST {
1777     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1778         fmt.debug_struct("KERB_ADD_CREDENTIALS_REQUEST").field("MessageType", &self.MessageType).field("UserName", &self.UserName).field("DomainName", &self.DomainName).field("Password", &self.Password).field("LogonId", &self.LogonId).field("Flags", &self.Flags).finish()
1779     }
1780 }
1781 #[cfg(feature = "Win32_Foundation")]
1782 impl ::std::cmp::PartialEq for KERB_ADD_CREDENTIALS_REQUEST {
1783     fn eq(&self, other: &Self) -> bool {
1784         self.MessageType == other.MessageType && self.UserName == other.UserName && self.DomainName == other.DomainName && self.Password == other.Password && self.LogonId == other.LogonId && self.Flags == other.Flags
1785     }
1786 }
1787 #[cfg(feature = "Win32_Foundation")]
1788 impl ::std::cmp::Eq for KERB_ADD_CREDENTIALS_REQUEST {}
1789 #[cfg(feature = "Win32_Foundation")]
1790 unsafe impl ::windows::runtime::Abi for KERB_ADD_CREDENTIALS_REQUEST {
1791     type Abi = Self;
1792     type DefaultType = Self;
1793 }
1794 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1795 #[repr(C)]
1796 #[cfg(feature = "Win32_Foundation")]
1797 pub struct KERB_ADD_CREDENTIALS_REQUEST_EX {
1798     pub Credentials: KERB_ADD_CREDENTIALS_REQUEST,
1799     pub PrincipalNameCount: u32,
1800     pub PrincipalNames: [super::super::super::Foundation::UNICODE_STRING; 1],
1801 }
1802 #[cfg(feature = "Win32_Foundation")]
1803 impl KERB_ADD_CREDENTIALS_REQUEST_EX {}
1804 #[cfg(feature = "Win32_Foundation")]
1805 impl ::std::default::Default for KERB_ADD_CREDENTIALS_REQUEST_EX {
1806     fn default() -> Self {
1807         unsafe { ::std::mem::zeroed() }
1808     }
1809 }
1810 #[cfg(feature = "Win32_Foundation")]
1811 impl ::std::fmt::Debug for KERB_ADD_CREDENTIALS_REQUEST_EX {
1812     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1813         fmt.debug_struct("KERB_ADD_CREDENTIALS_REQUEST_EX").field("Credentials", &self.Credentials).field("PrincipalNameCount", &self.PrincipalNameCount).field("PrincipalNames", &self.PrincipalNames).finish()
1814     }
1815 }
1816 #[cfg(feature = "Win32_Foundation")]
1817 impl ::std::cmp::PartialEq for KERB_ADD_CREDENTIALS_REQUEST_EX {
1818     fn eq(&self, other: &Self) -> bool {
1819         self.Credentials == other.Credentials && self.PrincipalNameCount == other.PrincipalNameCount && self.PrincipalNames == other.PrincipalNames
1820     }
1821 }
1822 #[cfg(feature = "Win32_Foundation")]
1823 impl ::std::cmp::Eq for KERB_ADD_CREDENTIALS_REQUEST_EX {}
1824 #[cfg(feature = "Win32_Foundation")]
1825 unsafe impl ::windows::runtime::Abi for KERB_ADD_CREDENTIALS_REQUEST_EX {
1826     type Abi = Self;
1827     type DefaultType = Self;
1828 }
1829 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1830 #[repr(C)]
1831 pub struct KERB_AUTH_DATA {
1832     pub Type: u32,
1833     pub Length: u32,
1834     pub Data: *mut u8,
1835 }
1836 impl KERB_AUTH_DATA {}
1837 impl ::std::default::Default for KERB_AUTH_DATA {
1838     fn default() -> Self {
1839         unsafe { ::std::mem::zeroed() }
1840     }
1841 }
1842 impl ::std::fmt::Debug for KERB_AUTH_DATA {
1843     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1844         fmt.debug_struct("KERB_AUTH_DATA").field("Type", &self.Type).field("Length", &self.Length).field("Data", &self.Data).finish()
1845     }
1846 }
1847 impl ::std::cmp::PartialEq for KERB_AUTH_DATA {
1848     fn eq(&self, other: &Self) -> bool {
1849         self.Type == other.Type && self.Length == other.Length && self.Data == other.Data
1850     }
1851 }
1852 impl ::std::cmp::Eq for KERB_AUTH_DATA {}
1853 unsafe impl ::windows::runtime::Abi for KERB_AUTH_DATA {
1854     type Abi = Self;
1855     type DefaultType = Self;
1856 }
1857 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1858 #[repr(C)]
1859 #[cfg(feature = "Win32_Foundation")]
1860 pub struct KERB_BINDING_CACHE_ENTRY_DATA {
1861     pub DiscoveryTime: u64,
1862     pub RealmName: super::super::super::Foundation::UNICODE_STRING,
1863     pub KdcAddress: super::super::super::Foundation::UNICODE_STRING,
1864     pub AddressType: KERB_ADDRESS_TYPE,
1865     pub Flags: u32,
1866     pub DcFlags: u32,
1867     pub CacheFlags: u32,
1868     pub KdcName: super::super::super::Foundation::UNICODE_STRING,
1869 }
1870 #[cfg(feature = "Win32_Foundation")]
1871 impl KERB_BINDING_CACHE_ENTRY_DATA {}
1872 #[cfg(feature = "Win32_Foundation")]
1873 impl ::std::default::Default for KERB_BINDING_CACHE_ENTRY_DATA {
1874     fn default() -> Self {
1875         unsafe { ::std::mem::zeroed() }
1876     }
1877 }
1878 #[cfg(feature = "Win32_Foundation")]
1879 impl ::std::fmt::Debug for KERB_BINDING_CACHE_ENTRY_DATA {
1880     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1881         fmt.debug_struct("KERB_BINDING_CACHE_ENTRY_DATA")
1882             .field("DiscoveryTime", &self.DiscoveryTime)
1883             .field("RealmName", &self.RealmName)
1884             .field("KdcAddress", &self.KdcAddress)
1885             .field("AddressType", &self.AddressType)
1886             .field("Flags", &self.Flags)
1887             .field("DcFlags", &self.DcFlags)
1888             .field("CacheFlags", &self.CacheFlags)
1889             .field("KdcName", &self.KdcName)
1890             .finish()
1891     }
1892 }
1893 #[cfg(feature = "Win32_Foundation")]
1894 impl ::std::cmp::PartialEq for KERB_BINDING_CACHE_ENTRY_DATA {
1895     fn eq(&self, other: &Self) -> bool {
1896         self.DiscoveryTime == other.DiscoveryTime && self.RealmName == other.RealmName && self.KdcAddress == other.KdcAddress && self.AddressType == other.AddressType && self.Flags == other.Flags && self.DcFlags == other.DcFlags && self.CacheFlags == other.CacheFlags && self.KdcName == other.KdcName
1897     }
1898 }
1899 #[cfg(feature = "Win32_Foundation")]
1900 impl ::std::cmp::Eq for KERB_BINDING_CACHE_ENTRY_DATA {}
1901 #[cfg(feature = "Win32_Foundation")]
1902 unsafe impl ::windows::runtime::Abi for KERB_BINDING_CACHE_ENTRY_DATA {
1903     type Abi = Self;
1904     type DefaultType = Self;
1905 }
1906 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1907 #[repr(C)]
1908 pub struct KERB_CERTIFICATE_HASHINFO {
1909     pub StoreNameLength: u16,
1910     pub HashLength: u16,
1911 }
1912 impl KERB_CERTIFICATE_HASHINFO {}
1913 impl ::std::default::Default for KERB_CERTIFICATE_HASHINFO {
1914     fn default() -> Self {
1915         unsafe { ::std::mem::zeroed() }
1916     }
1917 }
1918 impl ::std::fmt::Debug for KERB_CERTIFICATE_HASHINFO {
1919     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1920         fmt.debug_struct("KERB_CERTIFICATE_HASHINFO").field("StoreNameLength", &self.StoreNameLength).field("HashLength", &self.HashLength).finish()
1921     }
1922 }
1923 impl ::std::cmp::PartialEq for KERB_CERTIFICATE_HASHINFO {
1924     fn eq(&self, other: &Self) -> bool {
1925         self.StoreNameLength == other.StoreNameLength && self.HashLength == other.HashLength
1926     }
1927 }
1928 impl ::std::cmp::Eq for KERB_CERTIFICATE_HASHINFO {}
1929 unsafe impl ::windows::runtime::Abi for KERB_CERTIFICATE_HASHINFO {
1930     type Abi = Self;
1931     type DefaultType = Self;
1932 }
1933 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1934 #[repr(C)]
1935 pub struct KERB_CERTIFICATE_INFO {
1936     pub CertInfoSize: u32,
1937     pub InfoType: u32,
1938 }
1939 impl KERB_CERTIFICATE_INFO {}
1940 impl ::std::default::Default for KERB_CERTIFICATE_INFO {
1941     fn default() -> Self {
1942         unsafe { ::std::mem::zeroed() }
1943     }
1944 }
1945 impl ::std::fmt::Debug for KERB_CERTIFICATE_INFO {
1946     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1947         fmt.debug_struct("KERB_CERTIFICATE_INFO").field("CertInfoSize", &self.CertInfoSize).field("InfoType", &self.InfoType).finish()
1948     }
1949 }
1950 impl ::std::cmp::PartialEq for KERB_CERTIFICATE_INFO {
1951     fn eq(&self, other: &Self) -> bool {
1952         self.CertInfoSize == other.CertInfoSize && self.InfoType == other.InfoType
1953     }
1954 }
1955 impl ::std::cmp::Eq for KERB_CERTIFICATE_INFO {}
1956 unsafe impl ::windows::runtime::Abi for KERB_CERTIFICATE_INFO {
1957     type Abi = Self;
1958     type DefaultType = Self;
1959 }
1960 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1961 #[repr(transparent)]
1962 pub struct KERB_CERTIFICATE_INFO_TYPE(pub i32);
1963 pub const CertHashInfo: KERB_CERTIFICATE_INFO_TYPE = KERB_CERTIFICATE_INFO_TYPE(1i32);
1964 impl ::std::convert::From<i32> for KERB_CERTIFICATE_INFO_TYPE {
1965     fn from(value: i32) -> Self {
1966         Self(value)
1967     }
1968 }
1969 unsafe impl ::windows::runtime::Abi for KERB_CERTIFICATE_INFO_TYPE {
1970     type Abi = Self;
1971     type DefaultType = Self;
1972 }
1973 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1974 #[repr(C)]
1975 #[cfg(feature = "Win32_Foundation")]
1976 pub struct KERB_CERTIFICATE_LOGON {
1977     pub MessageType: KERB_LOGON_SUBMIT_TYPE,
1978     pub DomainName: super::super::super::Foundation::UNICODE_STRING,
1979     pub UserName: super::super::super::Foundation::UNICODE_STRING,
1980     pub Pin: super::super::super::Foundation::UNICODE_STRING,
1981     pub Flags: u32,
1982     pub CspDataLength: u32,
1983     pub CspData: *mut u8,
1984 }
1985 #[cfg(feature = "Win32_Foundation")]
1986 impl KERB_CERTIFICATE_LOGON {}
1987 #[cfg(feature = "Win32_Foundation")]
1988 impl ::std::default::Default for KERB_CERTIFICATE_LOGON {
1989     fn default() -> Self {
1990         unsafe { ::std::mem::zeroed() }
1991     }
1992 }
1993 #[cfg(feature = "Win32_Foundation")]
1994 impl ::std::fmt::Debug for KERB_CERTIFICATE_LOGON {
1995     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1996         fmt.debug_struct("KERB_CERTIFICATE_LOGON").field("MessageType", &self.MessageType).field("DomainName", &self.DomainName).field("UserName", &self.UserName).field("Pin", &self.Pin).field("Flags", &self.Flags).field("CspDataLength", &self.CspDataLength).field("CspData", &self.CspData).finish()
1997     }
1998 }
1999 #[cfg(feature = "Win32_Foundation")]
2000 impl ::std::cmp::PartialEq for KERB_CERTIFICATE_LOGON {
2001     fn eq(&self, other: &Self) -> bool {
2002         self.MessageType == other.MessageType && self.DomainName == other.DomainName && self.UserName == other.UserName && self.Pin == other.Pin && self.Flags == other.Flags && self.CspDataLength == other.CspDataLength && self.CspData == other.CspData
2003     }
2004 }
2005 #[cfg(feature = "Win32_Foundation")]
2006 impl ::std::cmp::Eq for KERB_CERTIFICATE_LOGON {}
2007 #[cfg(feature = "Win32_Foundation")]
2008 unsafe impl ::windows::runtime::Abi for KERB_CERTIFICATE_LOGON {
2009     type Abi = Self;
2010     type DefaultType = Self;
2011 }
2012 pub const KERB_CERTIFICATE_LOGON_FLAG_CHECK_DUPLICATES: u32 = 1u32;
2013 pub const KERB_CERTIFICATE_LOGON_FLAG_USE_CERTIFICATE_INFO: u32 = 2u32;
2014 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2015 #[repr(C)]
2016 #[cfg(feature = "Win32_Foundation")]
2017 pub struct KERB_CERTIFICATE_S4U_LOGON {
2018     pub MessageType: KERB_LOGON_SUBMIT_TYPE,
2019     pub Flags: u32,
2020     pub UserPrincipalName: super::super::super::Foundation::UNICODE_STRING,
2021     pub DomainName: super::super::super::Foundation::UNICODE_STRING,
2022     pub CertificateLength: u32,
2023     pub Certificate: *mut u8,
2024 }
2025 #[cfg(feature = "Win32_Foundation")]
2026 impl KERB_CERTIFICATE_S4U_LOGON {}
2027 #[cfg(feature = "Win32_Foundation")]
2028 impl ::std::default::Default for KERB_CERTIFICATE_S4U_LOGON {
2029     fn default() -> Self {
2030         unsafe { ::std::mem::zeroed() }
2031     }
2032 }
2033 #[cfg(feature = "Win32_Foundation")]
2034 impl ::std::fmt::Debug for KERB_CERTIFICATE_S4U_LOGON {
2035     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2036         fmt.debug_struct("KERB_CERTIFICATE_S4U_LOGON")
2037             .field("MessageType", &self.MessageType)
2038             .field("Flags", &self.Flags)
2039             .field("UserPrincipalName", &self.UserPrincipalName)
2040             .field("DomainName", &self.DomainName)
2041             .field("CertificateLength", &self.CertificateLength)
2042             .field("Certificate", &self.Certificate)
2043             .finish()
2044     }
2045 }
2046 #[cfg(feature = "Win32_Foundation")]
2047 impl ::std::cmp::PartialEq for KERB_CERTIFICATE_S4U_LOGON {
2048     fn eq(&self, other: &Self) -> bool {
2049         self.MessageType == other.MessageType && self.Flags == other.Flags && self.UserPrincipalName == other.UserPrincipalName && self.DomainName == other.DomainName && self.CertificateLength == other.CertificateLength && self.Certificate == other.Certificate
2050     }
2051 }
2052 #[cfg(feature = "Win32_Foundation")]
2053 impl ::std::cmp::Eq for KERB_CERTIFICATE_S4U_LOGON {}
2054 #[cfg(feature = "Win32_Foundation")]
2055 unsafe impl ::windows::runtime::Abi for KERB_CERTIFICATE_S4U_LOGON {
2056     type Abi = Self;
2057     type DefaultType = Self;
2058 }
2059 pub const KERB_CERTIFICATE_S4U_LOGON_FLAG_CHECK_DUPLICATES: u32 = 1u32;
2060 pub const KERB_CERTIFICATE_S4U_LOGON_FLAG_CHECK_LOGONHOURS: u32 = 2u32;
2061 pub const KERB_CERTIFICATE_S4U_LOGON_FLAG_FAIL_IF_NT_AUTH_POLICY_REQUIRED: u32 = 4u32;
2062 pub const KERB_CERTIFICATE_S4U_LOGON_FLAG_IDENTIFY: u32 = 8u32;
2063 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2064 #[repr(C)]
2065 #[cfg(feature = "Win32_Foundation")]
2066 pub struct KERB_CERTIFICATE_UNLOCK_LOGON {
2067     pub Logon: KERB_CERTIFICATE_LOGON,
2068     pub LogonId: super::super::super::Foundation::LUID,
2069 }
2070 #[cfg(feature = "Win32_Foundation")]
2071 impl KERB_CERTIFICATE_UNLOCK_LOGON {}
2072 #[cfg(feature = "Win32_Foundation")]
2073 impl ::std::default::Default for KERB_CERTIFICATE_UNLOCK_LOGON {
2074     fn default() -> Self {
2075         unsafe { ::std::mem::zeroed() }
2076     }
2077 }
2078 #[cfg(feature = "Win32_Foundation")]
2079 impl ::std::fmt::Debug for KERB_CERTIFICATE_UNLOCK_LOGON {
2080     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2081         fmt.debug_struct("KERB_CERTIFICATE_UNLOCK_LOGON").field("Logon", &self.Logon).field("LogonId", &self.LogonId).finish()
2082     }
2083 }
2084 #[cfg(feature = "Win32_Foundation")]
2085 impl ::std::cmp::PartialEq for KERB_CERTIFICATE_UNLOCK_LOGON {
2086     fn eq(&self, other: &Self) -> bool {
2087         self.Logon == other.Logon && self.LogonId == other.LogonId
2088     }
2089 }
2090 #[cfg(feature = "Win32_Foundation")]
2091 impl ::std::cmp::Eq for KERB_CERTIFICATE_UNLOCK_LOGON {}
2092 #[cfg(feature = "Win32_Foundation")]
2093 unsafe impl ::windows::runtime::Abi for KERB_CERTIFICATE_UNLOCK_LOGON {
2094     type Abi = Self;
2095     type DefaultType = Self;
2096 }
2097 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2098 #[repr(C)]
2099 #[cfg(feature = "Win32_Foundation")]
2100 pub struct KERB_CHANGEPASSWORD_REQUEST {
2101     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
2102     pub DomainName: super::super::super::Foundation::UNICODE_STRING,
2103     pub AccountName: super::super::super::Foundation::UNICODE_STRING,
2104     pub OldPassword: super::super::super::Foundation::UNICODE_STRING,
2105     pub NewPassword: super::super::super::Foundation::UNICODE_STRING,
2106     pub Impersonating: super::super::super::Foundation::BOOLEAN,
2107 }
2108 #[cfg(feature = "Win32_Foundation")]
2109 impl KERB_CHANGEPASSWORD_REQUEST {}
2110 #[cfg(feature = "Win32_Foundation")]
2111 impl ::std::default::Default for KERB_CHANGEPASSWORD_REQUEST {
2112     fn default() -> Self {
2113         unsafe { ::std::mem::zeroed() }
2114     }
2115 }
2116 #[cfg(feature = "Win32_Foundation")]
2117 impl ::std::fmt::Debug for KERB_CHANGEPASSWORD_REQUEST {
2118     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2119         fmt.debug_struct("KERB_CHANGEPASSWORD_REQUEST").field("MessageType", &self.MessageType).field("DomainName", &self.DomainName).field("AccountName", &self.AccountName).field("OldPassword", &self.OldPassword).field("NewPassword", &self.NewPassword).field("Impersonating", &self.Impersonating).finish()
2120     }
2121 }
2122 #[cfg(feature = "Win32_Foundation")]
2123 impl ::std::cmp::PartialEq for KERB_CHANGEPASSWORD_REQUEST {
2124     fn eq(&self, other: &Self) -> bool {
2125         self.MessageType == other.MessageType && self.DomainName == other.DomainName && self.AccountName == other.AccountName && self.OldPassword == other.OldPassword && self.NewPassword == other.NewPassword && self.Impersonating == other.Impersonating
2126     }
2127 }
2128 #[cfg(feature = "Win32_Foundation")]
2129 impl ::std::cmp::Eq for KERB_CHANGEPASSWORD_REQUEST {}
2130 #[cfg(feature = "Win32_Foundation")]
2131 unsafe impl ::windows::runtime::Abi for KERB_CHANGEPASSWORD_REQUEST {
2132     type Abi = Self;
2133     type DefaultType = Self;
2134 }
2135 pub const KERB_CHECKSUM_CRC32: u32 = 1u32;
2136 pub const KERB_CHECKSUM_DES_MAC: i32 = -133i32;
2137 pub const KERB_CHECKSUM_DES_MAC_MD5: i32 = -134i32;
2138 pub const KERB_CHECKSUM_HMAC_MD5: i32 = -138i32;
2139 pub const KERB_CHECKSUM_HMAC_SHA1_96_AES128: u32 = 15u32;
2140 pub const KERB_CHECKSUM_HMAC_SHA1_96_AES128_Ki: i32 = -150i32;
2141 pub const KERB_CHECKSUM_HMAC_SHA1_96_AES256: u32 = 16u32;
2142 pub const KERB_CHECKSUM_HMAC_SHA1_96_AES256_Ki: i32 = -151i32;
2143 pub const KERB_CHECKSUM_KRB_DES_MAC: u32 = 4u32;
2144 pub const KERB_CHECKSUM_KRB_DES_MAC_K: u32 = 5u32;
2145 pub const KERB_CHECKSUM_LM: i32 = -130i32;
2146 pub const KERB_CHECKSUM_MD25: i32 = -135i32;
2147 pub const KERB_CHECKSUM_MD4: u32 = 2u32;
2148 pub const KERB_CHECKSUM_MD5: u32 = 7u32;
2149 pub const KERB_CHECKSUM_MD5_DES: u32 = 8u32;
2150 pub const KERB_CHECKSUM_MD5_HMAC: i32 = -137i32;
2151 pub const KERB_CHECKSUM_NONE: u32 = 0u32;
2152 pub const KERB_CHECKSUM_RC4_MD5: i32 = -136i32;
2153 pub const KERB_CHECKSUM_REAL_CRC32: i32 = -132i32;
2154 pub const KERB_CHECKSUM_SHA1: i32 = -131i32;
2155 pub const KERB_CHECKSUM_SHA1_NEW: u32 = 14u32;
2156 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2157 #[repr(C)]
2158 #[cfg(feature = "Win32_Foundation")]
2159 pub struct KERB_CLEANUP_MACHINE_PKINIT_CREDS_REQUEST {
2160     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
2161     pub LogonId: super::super::super::Foundation::LUID,
2162 }
2163 #[cfg(feature = "Win32_Foundation")]
2164 impl KERB_CLEANUP_MACHINE_PKINIT_CREDS_REQUEST {}
2165 #[cfg(feature = "Win32_Foundation")]
2166 impl ::std::default::Default for KERB_CLEANUP_MACHINE_PKINIT_CREDS_REQUEST {
2167     fn default() -> Self {
2168         unsafe { ::std::mem::zeroed() }
2169     }
2170 }
2171 #[cfg(feature = "Win32_Foundation")]
2172 impl ::std::fmt::Debug for KERB_CLEANUP_MACHINE_PKINIT_CREDS_REQUEST {
2173     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2174         fmt.debug_struct("KERB_CLEANUP_MACHINE_PKINIT_CREDS_REQUEST").field("MessageType", &self.MessageType).field("LogonId", &self.LogonId).finish()
2175     }
2176 }
2177 #[cfg(feature = "Win32_Foundation")]
2178 impl ::std::cmp::PartialEq for KERB_CLEANUP_MACHINE_PKINIT_CREDS_REQUEST {
2179     fn eq(&self, other: &Self) -> bool {
2180         self.MessageType == other.MessageType && self.LogonId == other.LogonId
2181     }
2182 }
2183 #[cfg(feature = "Win32_Foundation")]
2184 impl ::std::cmp::Eq for KERB_CLEANUP_MACHINE_PKINIT_CREDS_REQUEST {}
2185 #[cfg(feature = "Win32_Foundation")]
2186 unsafe impl ::windows::runtime::Abi for KERB_CLEANUP_MACHINE_PKINIT_CREDS_REQUEST {
2187     type Abi = Self;
2188     type DefaultType = Self;
2189 }
2190 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2191 #[repr(C)]
2192 pub struct KERB_CLOUD_KERBEROS_DEBUG_DATA_V0 {
2193     pub _bitfield: i32,
2194 }
2195 impl KERB_CLOUD_KERBEROS_DEBUG_DATA_V0 {}
2196 impl ::std::default::Default for KERB_CLOUD_KERBEROS_DEBUG_DATA_V0 {
2197     fn default() -> Self {
2198         unsafe { ::std::mem::zeroed() }
2199     }
2200 }
2201 impl ::std::fmt::Debug for KERB_CLOUD_KERBEROS_DEBUG_DATA_V0 {
2202     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2203         fmt.debug_struct("KERB_CLOUD_KERBEROS_DEBUG_DATA_V0").field("_bitfield", &self._bitfield).finish()
2204     }
2205 }
2206 impl ::std::cmp::PartialEq for KERB_CLOUD_KERBEROS_DEBUG_DATA_V0 {
2207     fn eq(&self, other: &Self) -> bool {
2208         self._bitfield == other._bitfield
2209     }
2210 }
2211 impl ::std::cmp::Eq for KERB_CLOUD_KERBEROS_DEBUG_DATA_V0 {}
2212 unsafe impl ::windows::runtime::Abi for KERB_CLOUD_KERBEROS_DEBUG_DATA_V0 {
2213     type Abi = Self;
2214     type DefaultType = Self;
2215 }
2216 pub const KERB_CLOUD_KERBEROS_DEBUG_DATA_VERSION: u32 = 0u32;
2217 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2218 #[repr(C)]
2219 #[cfg(feature = "Win32_Foundation")]
2220 pub struct KERB_CLOUD_KERBEROS_DEBUG_REQUEST {
2221     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
2222     pub LogonId: super::super::super::Foundation::LUID,
2223 }
2224 #[cfg(feature = "Win32_Foundation")]
2225 impl KERB_CLOUD_KERBEROS_DEBUG_REQUEST {}
2226 #[cfg(feature = "Win32_Foundation")]
2227 impl ::std::default::Default for KERB_CLOUD_KERBEROS_DEBUG_REQUEST {
2228     fn default() -> Self {
2229         unsafe { ::std::mem::zeroed() }
2230     }
2231 }
2232 #[cfg(feature = "Win32_Foundation")]
2233 impl ::std::fmt::Debug for KERB_CLOUD_KERBEROS_DEBUG_REQUEST {
2234     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2235         fmt.debug_struct("KERB_CLOUD_KERBEROS_DEBUG_REQUEST").field("MessageType", &self.MessageType).field("LogonId", &self.LogonId).finish()
2236     }
2237 }
2238 #[cfg(feature = "Win32_Foundation")]
2239 impl ::std::cmp::PartialEq for KERB_CLOUD_KERBEROS_DEBUG_REQUEST {
2240     fn eq(&self, other: &Self) -> bool {
2241         self.MessageType == other.MessageType && self.LogonId == other.LogonId
2242     }
2243 }
2244 #[cfg(feature = "Win32_Foundation")]
2245 impl ::std::cmp::Eq for KERB_CLOUD_KERBEROS_DEBUG_REQUEST {}
2246 #[cfg(feature = "Win32_Foundation")]
2247 unsafe impl ::windows::runtime::Abi for KERB_CLOUD_KERBEROS_DEBUG_REQUEST {
2248     type Abi = Self;
2249     type DefaultType = Self;
2250 }
2251 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2252 #[repr(C)]
2253 pub struct KERB_CLOUD_KERBEROS_DEBUG_RESPONSE {
2254     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
2255     pub Version: u32,
2256     pub Length: u32,
2257     pub Data: [u32; 1],
2258 }
2259 impl KERB_CLOUD_KERBEROS_DEBUG_RESPONSE {}
2260 impl ::std::default::Default for KERB_CLOUD_KERBEROS_DEBUG_RESPONSE {
2261     fn default() -> Self {
2262         unsafe { ::std::mem::zeroed() }
2263     }
2264 }
2265 impl ::std::fmt::Debug for KERB_CLOUD_KERBEROS_DEBUG_RESPONSE {
2266     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2267         fmt.debug_struct("KERB_CLOUD_KERBEROS_DEBUG_RESPONSE").field("MessageType", &self.MessageType).field("Version", &self.Version).field("Length", &self.Length).field("Data", &self.Data).finish()
2268     }
2269 }
2270 impl ::std::cmp::PartialEq for KERB_CLOUD_KERBEROS_DEBUG_RESPONSE {
2271     fn eq(&self, other: &Self) -> bool {
2272         self.MessageType == other.MessageType && self.Version == other.Version && self.Length == other.Length && self.Data == other.Data
2273     }
2274 }
2275 impl ::std::cmp::Eq for KERB_CLOUD_KERBEROS_DEBUG_RESPONSE {}
2276 unsafe impl ::windows::runtime::Abi for KERB_CLOUD_KERBEROS_DEBUG_RESPONSE {
2277     type Abi = Self;
2278     type DefaultType = Self;
2279 }
2280 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2281 #[repr(C)]
2282 pub struct KERB_CRYPTO_KEY {
2283     pub KeyType: KERB_CRYPTO_KEY_TYPE,
2284     pub Length: u32,
2285     pub Value: *mut u8,
2286 }
2287 impl KERB_CRYPTO_KEY {}
2288 impl ::std::default::Default for KERB_CRYPTO_KEY {
2289     fn default() -> Self {
2290         unsafe { ::std::mem::zeroed() }
2291     }
2292 }
2293 impl ::std::fmt::Debug for KERB_CRYPTO_KEY {
2294     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2295         fmt.debug_struct("KERB_CRYPTO_KEY").field("KeyType", &self.KeyType).field("Length", &self.Length).field("Value", &self.Value).finish()
2296     }
2297 }
2298 impl ::std::cmp::PartialEq for KERB_CRYPTO_KEY {
2299     fn eq(&self, other: &Self) -> bool {
2300         self.KeyType == other.KeyType && self.Length == other.Length && self.Value == other.Value
2301     }
2302 }
2303 impl ::std::cmp::Eq for KERB_CRYPTO_KEY {}
2304 unsafe impl ::windows::runtime::Abi for KERB_CRYPTO_KEY {
2305     type Abi = Self;
2306     type DefaultType = Self;
2307 }
2308 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2309 #[repr(C)]
2310 pub struct KERB_CRYPTO_KEY32 {
2311     pub KeyType: i32,
2312     pub Length: u32,
2313     pub Offset: u32,
2314 }
2315 impl KERB_CRYPTO_KEY32 {}
2316 impl ::std::default::Default for KERB_CRYPTO_KEY32 {
2317     fn default() -> Self {
2318         unsafe { ::std::mem::zeroed() }
2319     }
2320 }
2321 impl ::std::fmt::Debug for KERB_CRYPTO_KEY32 {
2322     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2323         fmt.debug_struct("KERB_CRYPTO_KEY32").field("KeyType", &self.KeyType).field("Length", &self.Length).field("Offset", &self.Offset).finish()
2324     }
2325 }
2326 impl ::std::cmp::PartialEq for KERB_CRYPTO_KEY32 {
2327     fn eq(&self, other: &Self) -> bool {
2328         self.KeyType == other.KeyType && self.Length == other.Length && self.Offset == other.Offset
2329     }
2330 }
2331 impl ::std::cmp::Eq for KERB_CRYPTO_KEY32 {}
2332 unsafe impl ::windows::runtime::Abi for KERB_CRYPTO_KEY32 {
2333     type Abi = Self;
2334     type DefaultType = Self;
2335 }
2336 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2337 #[repr(transparent)]
2338 pub struct KERB_CRYPTO_KEY_TYPE(pub i32);
2339 pub const KERB_ETYPE_DES_CBC_CRC: KERB_CRYPTO_KEY_TYPE = KERB_CRYPTO_KEY_TYPE(1i32);
2340 pub const KERB_ETYPE_DES_CBC_MD4: KERB_CRYPTO_KEY_TYPE = KERB_CRYPTO_KEY_TYPE(2i32);
2341 pub const KERB_ETYPE_DES_CBC_MD5: KERB_CRYPTO_KEY_TYPE = KERB_CRYPTO_KEY_TYPE(3i32);
2342 pub const KERB_ETYPE_NULL: KERB_CRYPTO_KEY_TYPE = KERB_CRYPTO_KEY_TYPE(0i32);
2343 pub const KERB_ETYPE_RC4_HMAC_NT: KERB_CRYPTO_KEY_TYPE = KERB_CRYPTO_KEY_TYPE(23i32);
2344 pub const KERB_ETYPE_RC4_MD4: KERB_CRYPTO_KEY_TYPE = KERB_CRYPTO_KEY_TYPE(-128i32);
2345 impl ::std::convert::From<i32> for KERB_CRYPTO_KEY_TYPE {
2346     fn from(value: i32) -> Self {
2347         Self(value)
2348     }
2349 }
2350 unsafe impl ::windows::runtime::Abi for KERB_CRYPTO_KEY_TYPE {
2351     type Abi = Self;
2352     type DefaultType = Self;
2353 }
2354 pub const KERB_DECRYPT_FLAG_DEFAULT_KEY: u32 = 1u32;
2355 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2356 #[repr(C)]
2357 #[cfg(feature = "Win32_Foundation")]
2358 pub struct KERB_DECRYPT_REQUEST {
2359     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
2360     pub LogonId: super::super::super::Foundation::LUID,
2361     pub Flags: u32,
2362     pub CryptoType: i32,
2363     pub KeyUsage: i32,
2364     pub Key: KERB_CRYPTO_KEY,
2365     pub EncryptedDataSize: u32,
2366     pub InitialVectorSize: u32,
2367     pub InitialVector: *mut u8,
2368     pub EncryptedData: *mut u8,
2369 }
2370 #[cfg(feature = "Win32_Foundation")]
2371 impl KERB_DECRYPT_REQUEST {}
2372 #[cfg(feature = "Win32_Foundation")]
2373 impl ::std::default::Default for KERB_DECRYPT_REQUEST {
2374     fn default() -> Self {
2375         unsafe { ::std::mem::zeroed() }
2376     }
2377 }
2378 #[cfg(feature = "Win32_Foundation")]
2379 impl ::std::fmt::Debug for KERB_DECRYPT_REQUEST {
2380     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2381         fmt.debug_struct("KERB_DECRYPT_REQUEST")
2382             .field("MessageType", &self.MessageType)
2383             .field("LogonId", &self.LogonId)
2384             .field("Flags", &self.Flags)
2385             .field("CryptoType", &self.CryptoType)
2386             .field("KeyUsage", &self.KeyUsage)
2387             .field("Key", &self.Key)
2388             .field("EncryptedDataSize", &self.EncryptedDataSize)
2389             .field("InitialVectorSize", &self.InitialVectorSize)
2390             .field("InitialVector", &self.InitialVector)
2391             .field("EncryptedData", &self.EncryptedData)
2392             .finish()
2393     }
2394 }
2395 #[cfg(feature = "Win32_Foundation")]
2396 impl ::std::cmp::PartialEq for KERB_DECRYPT_REQUEST {
2397     fn eq(&self, other: &Self) -> bool {
2398         self.MessageType == other.MessageType && self.LogonId == other.LogonId && self.Flags == other.Flags && self.CryptoType == other.CryptoType && self.KeyUsage == other.KeyUsage && self.Key == other.Key && self.EncryptedDataSize == other.EncryptedDataSize && self.InitialVectorSize == other.InitialVectorSize && self.InitialVector == other.InitialVector && self.EncryptedData == other.EncryptedData
2399     }
2400 }
2401 #[cfg(feature = "Win32_Foundation")]
2402 impl ::std::cmp::Eq for KERB_DECRYPT_REQUEST {}
2403 #[cfg(feature = "Win32_Foundation")]
2404 unsafe impl ::windows::runtime::Abi for KERB_DECRYPT_REQUEST {
2405     type Abi = Self;
2406     type DefaultType = Self;
2407 }
2408 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2409 #[repr(C)]
2410 pub struct KERB_DECRYPT_RESPONSE {
2411     pub DecryptedData: [u8; 1],
2412 }
2413 impl KERB_DECRYPT_RESPONSE {}
2414 impl ::std::default::Default for KERB_DECRYPT_RESPONSE {
2415     fn default() -> Self {
2416         unsafe { ::std::mem::zeroed() }
2417     }
2418 }
2419 impl ::std::fmt::Debug for KERB_DECRYPT_RESPONSE {
2420     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2421         fmt.debug_struct("KERB_DECRYPT_RESPONSE").field("DecryptedData", &self.DecryptedData).finish()
2422     }
2423 }
2424 impl ::std::cmp::PartialEq for KERB_DECRYPT_RESPONSE {
2425     fn eq(&self, other: &Self) -> bool {
2426         self.DecryptedData == other.DecryptedData
2427     }
2428 }
2429 impl ::std::cmp::Eq for KERB_DECRYPT_RESPONSE {}
2430 unsafe impl ::windows::runtime::Abi for KERB_DECRYPT_RESPONSE {
2431     type Abi = Self;
2432     type DefaultType = Self;
2433 }
2434 pub const KERB_ETYPE_AES128_CTS_HMAC_SHA1_96: u32 = 17u32;
2435 pub const KERB_ETYPE_AES128_CTS_HMAC_SHA1_96_PLAIN: i32 = -148i32;
2436 pub const KERB_ETYPE_AES256_CTS_HMAC_SHA1_96: u32 = 18u32;
2437 pub const KERB_ETYPE_AES256_CTS_HMAC_SHA1_96_PLAIN: i32 = -149i32;
2438 pub const KERB_ETYPE_DEFAULT: u32 = 0u32;
2439 pub const KERB_ETYPE_DES3_CBC_MD5: u32 = 5u32;
2440 pub const KERB_ETYPE_DES3_CBC_SHA1: u32 = 7u32;
2441 pub const KERB_ETYPE_DES3_CBC_SHA1_KD: u32 = 16u32;
2442 pub const KERB_ETYPE_DES_CBC_MD5_NT: u32 = 20u32;
2443 pub const KERB_ETYPE_DES_EDE3_CBC_ENV: u32 = 15u32;
2444 pub const KERB_ETYPE_DES_PLAIN: i32 = -132i32;
2445 pub const KERB_ETYPE_DSA_SHA1_CMS: u32 = 9u32;
2446 pub const KERB_ETYPE_DSA_SIGN: u32 = 8u32;
2447 pub const KERB_ETYPE_PKCS7_PUB: u32 = 13u32;
2448 pub const KERB_ETYPE_RC2_CBC_ENV: u32 = 12u32;
2449 pub const KERB_ETYPE_RC4_HMAC_NT_EXP: u32 = 24u32;
2450 pub const KERB_ETYPE_RC4_HMAC_OLD: i32 = -133i32;
2451 pub const KERB_ETYPE_RC4_HMAC_OLD_EXP: i32 = -135i32;
2452 pub const KERB_ETYPE_RC4_LM: i32 = -130i32;
2453 pub const KERB_ETYPE_RC4_PLAIN: i32 = -140i32;
2454 pub const KERB_ETYPE_RC4_PLAIN2: i32 = -129i32;
2455 pub const KERB_ETYPE_RC4_PLAIN_EXP: i32 = -141i32;
2456 pub const KERB_ETYPE_RC4_PLAIN_OLD: i32 = -134i32;
2457 pub const KERB_ETYPE_RC4_PLAIN_OLD_EXP: i32 = -136i32;
2458 pub const KERB_ETYPE_RC4_SHA: i32 = -131i32;
2459 pub const KERB_ETYPE_RSA_ENV: u32 = 13u32;
2460 pub const KERB_ETYPE_RSA_ES_OEAP_ENV: u32 = 14u32;
2461 pub const KERB_ETYPE_RSA_MD5_CMS: u32 = 10u32;
2462 pub const KERB_ETYPE_RSA_PRIV: u32 = 9u32;
2463 pub const KERB_ETYPE_RSA_PUB: u32 = 10u32;
2464 pub const KERB_ETYPE_RSA_PUB_MD5: u32 = 11u32;
2465 pub const KERB_ETYPE_RSA_PUB_SHA1: u32 = 12u32;
2466 pub const KERB_ETYPE_RSA_SHA1_CMS: u32 = 11u32;
2467 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2468 #[repr(C)]
2469 #[cfg(feature = "Win32_Foundation")]
2470 pub struct KERB_EXTERNAL_NAME {
2471     pub NameType: i16,
2472     pub NameCount: u16,
2473     pub Names: [super::super::super::Foundation::UNICODE_STRING; 1],
2474 }
2475 #[cfg(feature = "Win32_Foundation")]
2476 impl KERB_EXTERNAL_NAME {}
2477 #[cfg(feature = "Win32_Foundation")]
2478 impl ::std::default::Default for KERB_EXTERNAL_NAME {
2479     fn default() -> Self {
2480         unsafe { ::std::mem::zeroed() }
2481     }
2482 }
2483 #[cfg(feature = "Win32_Foundation")]
2484 impl ::std::fmt::Debug for KERB_EXTERNAL_NAME {
2485     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2486         fmt.debug_struct("KERB_EXTERNAL_NAME").field("NameType", &self.NameType).field("NameCount", &self.NameCount).field("Names", &self.Names).finish()
2487     }
2488 }
2489 #[cfg(feature = "Win32_Foundation")]
2490 impl ::std::cmp::PartialEq for KERB_EXTERNAL_NAME {
2491     fn eq(&self, other: &Self) -> bool {
2492         self.NameType == other.NameType && self.NameCount == other.NameCount && self.Names == other.Names
2493     }
2494 }
2495 #[cfg(feature = "Win32_Foundation")]
2496 impl ::std::cmp::Eq for KERB_EXTERNAL_NAME {}
2497 #[cfg(feature = "Win32_Foundation")]
2498 unsafe impl ::windows::runtime::Abi for KERB_EXTERNAL_NAME {
2499     type Abi = Self;
2500     type DefaultType = Self;
2501 }
2502 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2503 #[repr(C)]
2504 #[cfg(feature = "Win32_Foundation")]
2505 pub struct KERB_EXTERNAL_TICKET {
2506     pub ServiceName: *mut KERB_EXTERNAL_NAME,
2507     pub TargetName: *mut KERB_EXTERNAL_NAME,
2508     pub ClientName: *mut KERB_EXTERNAL_NAME,
2509     pub DomainName: super::super::super::Foundation::UNICODE_STRING,
2510     pub TargetDomainName: super::super::super::Foundation::UNICODE_STRING,
2511     pub AltTargetDomainName: super::super::super::Foundation::UNICODE_STRING,
2512     pub SessionKey: KERB_CRYPTO_KEY,
2513     pub TicketFlags: KERB_TICKET_FLAGS,
2514     pub Flags: u32,
2515     pub KeyExpirationTime: i64,
2516     pub StartTime: i64,
2517     pub EndTime: i64,
2518     pub RenewUntil: i64,
2519     pub TimeSkew: i64,
2520     pub EncodedTicketSize: u32,
2521     pub EncodedTicket: *mut u8,
2522 }
2523 #[cfg(feature = "Win32_Foundation")]
2524 impl KERB_EXTERNAL_TICKET {}
2525 #[cfg(feature = "Win32_Foundation")]
2526 impl ::std::default::Default for KERB_EXTERNAL_TICKET {
2527     fn default() -> Self {
2528         unsafe { ::std::mem::zeroed() }
2529     }
2530 }
2531 #[cfg(feature = "Win32_Foundation")]
2532 impl ::std::fmt::Debug for KERB_EXTERNAL_TICKET {
2533     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2534         fmt.debug_struct("KERB_EXTERNAL_TICKET")
2535             .field("ServiceName", &self.ServiceName)
2536             .field("TargetName", &self.TargetName)
2537             .field("ClientName", &self.ClientName)
2538             .field("DomainName", &self.DomainName)
2539             .field("TargetDomainName", &self.TargetDomainName)
2540             .field("AltTargetDomainName", &self.AltTargetDomainName)
2541             .field("SessionKey", &self.SessionKey)
2542             .field("TicketFlags", &self.TicketFlags)
2543             .field("Flags", &self.Flags)
2544             .field("KeyExpirationTime", &self.KeyExpirationTime)
2545             .field("StartTime", &self.StartTime)
2546             .field("EndTime", &self.EndTime)
2547             .field("RenewUntil", &self.RenewUntil)
2548             .field("TimeSkew", &self.TimeSkew)
2549             .field("EncodedTicketSize", &self.EncodedTicketSize)
2550             .field("EncodedTicket", &self.EncodedTicket)
2551             .finish()
2552     }
2553 }
2554 #[cfg(feature = "Win32_Foundation")]
2555 impl ::std::cmp::PartialEq for KERB_EXTERNAL_TICKET {
2556     fn eq(&self, other: &Self) -> bool {
2557         self.ServiceName == other.ServiceName
2558             && self.TargetName == other.TargetName
2559             && self.ClientName == other.ClientName
2560             && self.DomainName == other.DomainName
2561             && self.TargetDomainName == other.TargetDomainName
2562             && self.AltTargetDomainName == other.AltTargetDomainName
2563             && self.SessionKey == other.SessionKey
2564             && self.TicketFlags == other.TicketFlags
2565             && self.Flags == other.Flags
2566             && self.KeyExpirationTime == other.KeyExpirationTime
2567             && self.StartTime == other.StartTime
2568             && self.EndTime == other.EndTime
2569             && self.RenewUntil == other.RenewUntil
2570             && self.TimeSkew == other.TimeSkew
2571             && self.EncodedTicketSize == other.EncodedTicketSize
2572             && self.EncodedTicket == other.EncodedTicket
2573     }
2574 }
2575 #[cfg(feature = "Win32_Foundation")]
2576 impl ::std::cmp::Eq for KERB_EXTERNAL_TICKET {}
2577 #[cfg(feature = "Win32_Foundation")]
2578 unsafe impl ::windows::runtime::Abi for KERB_EXTERNAL_TICKET {
2579     type Abi = Self;
2580     type DefaultType = Self;
2581 }
2582 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2583 #[repr(C)]
2584 #[cfg(feature = "Win32_Foundation")]
2585 pub struct KERB_INTERACTIVE_LOGON {
2586     pub MessageType: KERB_LOGON_SUBMIT_TYPE,
2587     pub LogonDomainName: super::super::super::Foundation::UNICODE_STRING,
2588     pub UserName: super::super::super::Foundation::UNICODE_STRING,
2589     pub Password: super::super::super::Foundation::UNICODE_STRING,
2590 }
2591 #[cfg(feature = "Win32_Foundation")]
2592 impl KERB_INTERACTIVE_LOGON {}
2593 #[cfg(feature = "Win32_Foundation")]
2594 impl ::std::default::Default for KERB_INTERACTIVE_LOGON {
2595     fn default() -> Self {
2596         unsafe { ::std::mem::zeroed() }
2597     }
2598 }
2599 #[cfg(feature = "Win32_Foundation")]
2600 impl ::std::fmt::Debug for KERB_INTERACTIVE_LOGON {
2601     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2602         fmt.debug_struct("KERB_INTERACTIVE_LOGON").field("MessageType", &self.MessageType).field("LogonDomainName", &self.LogonDomainName).field("UserName", &self.UserName).field("Password", &self.Password).finish()
2603     }
2604 }
2605 #[cfg(feature = "Win32_Foundation")]
2606 impl ::std::cmp::PartialEq for KERB_INTERACTIVE_LOGON {
2607     fn eq(&self, other: &Self) -> bool {
2608         self.MessageType == other.MessageType && self.LogonDomainName == other.LogonDomainName && self.UserName == other.UserName && self.Password == other.Password
2609     }
2610 }
2611 #[cfg(feature = "Win32_Foundation")]
2612 impl ::std::cmp::Eq for KERB_INTERACTIVE_LOGON {}
2613 #[cfg(feature = "Win32_Foundation")]
2614 unsafe impl ::windows::runtime::Abi for KERB_INTERACTIVE_LOGON {
2615     type Abi = Self;
2616     type DefaultType = Self;
2617 }
2618 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2619 #[repr(C)]
2620 #[cfg(feature = "Win32_Foundation")]
2621 pub struct KERB_INTERACTIVE_PROFILE {
2622     pub MessageType: KERB_PROFILE_BUFFER_TYPE,
2623     pub LogonCount: u16,
2624     pub BadPasswordCount: u16,
2625     pub LogonTime: i64,
2626     pub LogoffTime: i64,
2627     pub KickOffTime: i64,
2628     pub PasswordLastSet: i64,
2629     pub PasswordCanChange: i64,
2630     pub PasswordMustChange: i64,
2631     pub LogonScript: super::super::super::Foundation::UNICODE_STRING,
2632     pub HomeDirectory: super::super::super::Foundation::UNICODE_STRING,
2633     pub FullName: super::super::super::Foundation::UNICODE_STRING,
2634     pub ProfilePath: super::super::super::Foundation::UNICODE_STRING,
2635     pub HomeDirectoryDrive: super::super::super::Foundation::UNICODE_STRING,
2636     pub LogonServer: super::super::super::Foundation::UNICODE_STRING,
2637     pub UserFlags: u32,
2638 }
2639 #[cfg(feature = "Win32_Foundation")]
2640 impl KERB_INTERACTIVE_PROFILE {}
2641 #[cfg(feature = "Win32_Foundation")]
2642 impl ::std::default::Default for KERB_INTERACTIVE_PROFILE {
2643     fn default() -> Self {
2644         unsafe { ::std::mem::zeroed() }
2645     }
2646 }
2647 #[cfg(feature = "Win32_Foundation")]
2648 impl ::std::fmt::Debug for KERB_INTERACTIVE_PROFILE {
2649     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2650         fmt.debug_struct("KERB_INTERACTIVE_PROFILE")
2651             .field("MessageType", &self.MessageType)
2652             .field("LogonCount", &self.LogonCount)
2653             .field("BadPasswordCount", &self.BadPasswordCount)
2654             .field("LogonTime", &self.LogonTime)
2655             .field("LogoffTime", &self.LogoffTime)
2656             .field("KickOffTime", &self.KickOffTime)
2657             .field("PasswordLastSet", &self.PasswordLastSet)
2658             .field("PasswordCanChange", &self.PasswordCanChange)
2659             .field("PasswordMustChange", &self.PasswordMustChange)
2660             .field("LogonScript", &self.LogonScript)
2661             .field("HomeDirectory", &self.HomeDirectory)
2662             .field("FullName", &self.FullName)
2663             .field("ProfilePath", &self.ProfilePath)
2664             .field("HomeDirectoryDrive", &self.HomeDirectoryDrive)
2665             .field("LogonServer", &self.LogonServer)
2666             .field("UserFlags", &self.UserFlags)
2667             .finish()
2668     }
2669 }
2670 #[cfg(feature = "Win32_Foundation")]
2671 impl ::std::cmp::PartialEq for KERB_INTERACTIVE_PROFILE {
2672     fn eq(&self, other: &Self) -> bool {
2673         self.MessageType == other.MessageType
2674             && self.LogonCount == other.LogonCount
2675             && self.BadPasswordCount == other.BadPasswordCount
2676             && self.LogonTime == other.LogonTime
2677             && self.LogoffTime == other.LogoffTime
2678             && self.KickOffTime == other.KickOffTime
2679             && self.PasswordLastSet == other.PasswordLastSet
2680             && self.PasswordCanChange == other.PasswordCanChange
2681             && self.PasswordMustChange == other.PasswordMustChange
2682             && self.LogonScript == other.LogonScript
2683             && self.HomeDirectory == other.HomeDirectory
2684             && self.FullName == other.FullName
2685             && self.ProfilePath == other.ProfilePath
2686             && self.HomeDirectoryDrive == other.HomeDirectoryDrive
2687             && self.LogonServer == other.LogonServer
2688             && self.UserFlags == other.UserFlags
2689     }
2690 }
2691 #[cfg(feature = "Win32_Foundation")]
2692 impl ::std::cmp::Eq for KERB_INTERACTIVE_PROFILE {}
2693 #[cfg(feature = "Win32_Foundation")]
2694 unsafe impl ::windows::runtime::Abi for KERB_INTERACTIVE_PROFILE {
2695     type Abi = Self;
2696     type DefaultType = Self;
2697 }
2698 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2699 #[repr(C)]
2700 #[cfg(feature = "Win32_Foundation")]
2701 pub struct KERB_INTERACTIVE_UNLOCK_LOGON {
2702     pub Logon: KERB_INTERACTIVE_LOGON,
2703     pub LogonId: super::super::super::Foundation::LUID,
2704 }
2705 #[cfg(feature = "Win32_Foundation")]
2706 impl KERB_INTERACTIVE_UNLOCK_LOGON {}
2707 #[cfg(feature = "Win32_Foundation")]
2708 impl ::std::default::Default for KERB_INTERACTIVE_UNLOCK_LOGON {
2709     fn default() -> Self {
2710         unsafe { ::std::mem::zeroed() }
2711     }
2712 }
2713 #[cfg(feature = "Win32_Foundation")]
2714 impl ::std::fmt::Debug for KERB_INTERACTIVE_UNLOCK_LOGON {
2715     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2716         fmt.debug_struct("KERB_INTERACTIVE_UNLOCK_LOGON").field("Logon", &self.Logon).field("LogonId", &self.LogonId).finish()
2717     }
2718 }
2719 #[cfg(feature = "Win32_Foundation")]
2720 impl ::std::cmp::PartialEq for KERB_INTERACTIVE_UNLOCK_LOGON {
2721     fn eq(&self, other: &Self) -> bool {
2722         self.Logon == other.Logon && self.LogonId == other.LogonId
2723     }
2724 }
2725 #[cfg(feature = "Win32_Foundation")]
2726 impl ::std::cmp::Eq for KERB_INTERACTIVE_UNLOCK_LOGON {}
2727 #[cfg(feature = "Win32_Foundation")]
2728 unsafe impl ::windows::runtime::Abi for KERB_INTERACTIVE_UNLOCK_LOGON {
2729     type Abi = Self;
2730     type DefaultType = Self;
2731 }
2732 pub const KERB_LOGON_FLAG_ALLOW_EXPIRED_TICKET: u32 = 1u32;
2733 pub const KERB_LOGON_FLAG_REDIRECTED: u32 = 2u32;
2734 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2735 #[repr(transparent)]
2736 pub struct KERB_LOGON_SUBMIT_TYPE(pub i32);
2737 pub const KerbInteractiveLogon: KERB_LOGON_SUBMIT_TYPE = KERB_LOGON_SUBMIT_TYPE(2i32);
2738 pub const KerbSmartCardLogon: KERB_LOGON_SUBMIT_TYPE = KERB_LOGON_SUBMIT_TYPE(6i32);
2739 pub const KerbWorkstationUnlockLogon: KERB_LOGON_SUBMIT_TYPE = KERB_LOGON_SUBMIT_TYPE(7i32);
2740 pub const KerbSmartCardUnlockLogon: KERB_LOGON_SUBMIT_TYPE = KERB_LOGON_SUBMIT_TYPE(8i32);
2741 pub const KerbProxyLogon: KERB_LOGON_SUBMIT_TYPE = KERB_LOGON_SUBMIT_TYPE(9i32);
2742 pub const KerbTicketLogon: KERB_LOGON_SUBMIT_TYPE = KERB_LOGON_SUBMIT_TYPE(10i32);
2743 pub const KerbTicketUnlockLogon: KERB_LOGON_SUBMIT_TYPE = KERB_LOGON_SUBMIT_TYPE(11i32);
2744 pub const KerbS4ULogon: KERB_LOGON_SUBMIT_TYPE = KERB_LOGON_SUBMIT_TYPE(12i32);
2745 pub const KerbCertificateLogon: KERB_LOGON_SUBMIT_TYPE = KERB_LOGON_SUBMIT_TYPE(13i32);
2746 pub const KerbCertificateS4ULogon: KERB_LOGON_SUBMIT_TYPE = KERB_LOGON_SUBMIT_TYPE(14i32);
2747 pub const KerbCertificateUnlockLogon: KERB_LOGON_SUBMIT_TYPE = KERB_LOGON_SUBMIT_TYPE(15i32);
2748 pub const KerbNoElevationLogon: KERB_LOGON_SUBMIT_TYPE = KERB_LOGON_SUBMIT_TYPE(83i32);
2749 pub const KerbLuidLogon: KERB_LOGON_SUBMIT_TYPE = KERB_LOGON_SUBMIT_TYPE(84i32);
2750 impl ::std::convert::From<i32> for KERB_LOGON_SUBMIT_TYPE {
2751     fn from(value: i32) -> Self {
2752         Self(value)
2753     }
2754 }
2755 unsafe impl ::windows::runtime::Abi for KERB_LOGON_SUBMIT_TYPE {
2756     type Abi = Self;
2757     type DefaultType = Self;
2758 }
2759 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2760 #[repr(C)]
2761 #[cfg(feature = "Win32_Foundation")]
2762 pub struct KERB_NET_ADDRESS {
2763     pub Family: u32,
2764     pub Length: u32,
2765     pub Address: super::super::super::Foundation::PSTR,
2766 }
2767 #[cfg(feature = "Win32_Foundation")]
2768 impl KERB_NET_ADDRESS {}
2769 #[cfg(feature = "Win32_Foundation")]
2770 impl ::std::default::Default for KERB_NET_ADDRESS {
2771     fn default() -> Self {
2772         unsafe { ::std::mem::zeroed() }
2773     }
2774 }
2775 #[cfg(feature = "Win32_Foundation")]
2776 impl ::std::fmt::Debug for KERB_NET_ADDRESS {
2777     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2778         fmt.debug_struct("KERB_NET_ADDRESS").field("Family", &self.Family).field("Length", &self.Length).field("Address", &self.Address).finish()
2779     }
2780 }
2781 #[cfg(feature = "Win32_Foundation")]
2782 impl ::std::cmp::PartialEq for KERB_NET_ADDRESS {
2783     fn eq(&self, other: &Self) -> bool {
2784         self.Family == other.Family && self.Length == other.Length && self.Address == other.Address
2785     }
2786 }
2787 #[cfg(feature = "Win32_Foundation")]
2788 impl ::std::cmp::Eq for KERB_NET_ADDRESS {}
2789 #[cfg(feature = "Win32_Foundation")]
2790 unsafe impl ::windows::runtime::Abi for KERB_NET_ADDRESS {
2791     type Abi = Self;
2792     type DefaultType = Self;
2793 }
2794 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2795 #[repr(C)]
2796 #[cfg(feature = "Win32_Foundation")]
2797 pub struct KERB_NET_ADDRESSES {
2798     pub Number: u32,
2799     pub Addresses: [KERB_NET_ADDRESS; 1],
2800 }
2801 #[cfg(feature = "Win32_Foundation")]
2802 impl KERB_NET_ADDRESSES {}
2803 #[cfg(feature = "Win32_Foundation")]
2804 impl ::std::default::Default for KERB_NET_ADDRESSES {
2805     fn default() -> Self {
2806         unsafe { ::std::mem::zeroed() }
2807     }
2808 }
2809 #[cfg(feature = "Win32_Foundation")]
2810 impl ::std::fmt::Debug for KERB_NET_ADDRESSES {
2811     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2812         fmt.debug_struct("KERB_NET_ADDRESSES").field("Number", &self.Number).field("Addresses", &self.Addresses).finish()
2813     }
2814 }
2815 #[cfg(feature = "Win32_Foundation")]
2816 impl ::std::cmp::PartialEq for KERB_NET_ADDRESSES {
2817     fn eq(&self, other: &Self) -> bool {
2818         self.Number == other.Number && self.Addresses == other.Addresses
2819     }
2820 }
2821 #[cfg(feature = "Win32_Foundation")]
2822 impl ::std::cmp::Eq for KERB_NET_ADDRESSES {}
2823 #[cfg(feature = "Win32_Foundation")]
2824 unsafe impl ::windows::runtime::Abi for KERB_NET_ADDRESSES {
2825     type Abi = Self;
2826     type DefaultType = Self;
2827 }
2828 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2829 #[repr(transparent)]
2830 pub struct KERB_PROFILE_BUFFER_TYPE(pub i32);
2831 pub const KerbInteractiveProfile: KERB_PROFILE_BUFFER_TYPE = KERB_PROFILE_BUFFER_TYPE(2i32);
2832 pub const KerbSmartCardProfile: KERB_PROFILE_BUFFER_TYPE = KERB_PROFILE_BUFFER_TYPE(4i32);
2833 pub const KerbTicketProfile: KERB_PROFILE_BUFFER_TYPE = KERB_PROFILE_BUFFER_TYPE(6i32);
2834 impl ::std::convert::From<i32> for KERB_PROFILE_BUFFER_TYPE {
2835     fn from(value: i32) -> Self {
2836         Self(value)
2837     }
2838 }
2839 unsafe impl ::windows::runtime::Abi for KERB_PROFILE_BUFFER_TYPE {
2840     type Abi = Self;
2841     type DefaultType = Self;
2842 }
2843 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2844 #[repr(transparent)]
2845 pub struct KERB_PROTOCOL_MESSAGE_TYPE(pub i32);
2846 pub const KerbDebugRequestMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(0i32);
2847 pub const KerbQueryTicketCacheMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(1i32);
2848 pub const KerbChangeMachinePasswordMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(2i32);
2849 pub const KerbVerifyPacMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(3i32);
2850 pub const KerbRetrieveTicketMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(4i32);
2851 pub const KerbUpdateAddressesMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(5i32);
2852 pub const KerbPurgeTicketCacheMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(6i32);
2853 pub const KerbChangePasswordMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(7i32);
2854 pub const KerbRetrieveEncodedTicketMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(8i32);
2855 pub const KerbDecryptDataMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(9i32);
2856 pub const KerbAddBindingCacheEntryMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(10i32);
2857 pub const KerbSetPasswordMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(11i32);
2858 pub const KerbSetPasswordExMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(12i32);
2859 pub const KerbVerifyCredentialsMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(13i32);
2860 pub const KerbQueryTicketCacheExMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(14i32);
2861 pub const KerbPurgeTicketCacheExMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(15i32);
2862 pub const KerbRefreshSmartcardCredentialsMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(16i32);
2863 pub const KerbAddExtraCredentialsMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(17i32);
2864 pub const KerbQuerySupplementalCredentialsMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(18i32);
2865 pub const KerbTransferCredentialsMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(19i32);
2866 pub const KerbQueryTicketCacheEx2Message: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(20i32);
2867 pub const KerbSubmitTicketMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(21i32);
2868 pub const KerbAddExtraCredentialsExMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(22i32);
2869 pub const KerbQueryKdcProxyCacheMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(23i32);
2870 pub const KerbPurgeKdcProxyCacheMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(24i32);
2871 pub const KerbQueryTicketCacheEx3Message: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(25i32);
2872 pub const KerbCleanupMachinePkinitCredsMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(26i32);
2873 pub const KerbAddBindingCacheEntryExMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(27i32);
2874 pub const KerbQueryBindingCacheMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(28i32);
2875 pub const KerbPurgeBindingCacheMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(29i32);
2876 pub const KerbPinKdcMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(30i32);
2877 pub const KerbUnpinAllKdcsMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(31i32);
2878 pub const KerbQueryDomainExtendedPoliciesMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(32i32);
2879 pub const KerbQueryS4U2ProxyCacheMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(33i32);
2880 pub const KerbRetrieveKeyTabMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(34i32);
2881 pub const KerbRefreshPolicyMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(35i32);
2882 pub const KerbPrintCloudKerberosDebugMessage: KERB_PROTOCOL_MESSAGE_TYPE = KERB_PROTOCOL_MESSAGE_TYPE(36i32);
2883 impl ::std::convert::From<i32> for KERB_PROTOCOL_MESSAGE_TYPE {
2884     fn from(value: i32) -> Self {
2885         Self(value)
2886     }
2887 }
2888 unsafe impl ::windows::runtime::Abi for KERB_PROTOCOL_MESSAGE_TYPE {
2889     type Abi = Self;
2890     type DefaultType = Self;
2891 }
2892 pub const KERB_PURGE_ALL_TICKETS: u32 = 1u32;
2893 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2894 #[repr(C)]
2895 pub struct KERB_PURGE_BINDING_CACHE_REQUEST {
2896     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
2897 }
2898 impl KERB_PURGE_BINDING_CACHE_REQUEST {}
2899 impl ::std::default::Default for KERB_PURGE_BINDING_CACHE_REQUEST {
2900     fn default() -> Self {
2901         unsafe { ::std::mem::zeroed() }
2902     }
2903 }
2904 impl ::std::fmt::Debug for KERB_PURGE_BINDING_CACHE_REQUEST {
2905     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2906         fmt.debug_struct("KERB_PURGE_BINDING_CACHE_REQUEST").field("MessageType", &self.MessageType).finish()
2907     }
2908 }
2909 impl ::std::cmp::PartialEq for KERB_PURGE_BINDING_CACHE_REQUEST {
2910     fn eq(&self, other: &Self) -> bool {
2911         self.MessageType == other.MessageType
2912     }
2913 }
2914 impl ::std::cmp::Eq for KERB_PURGE_BINDING_CACHE_REQUEST {}
2915 unsafe impl ::windows::runtime::Abi for KERB_PURGE_BINDING_CACHE_REQUEST {
2916     type Abi = Self;
2917     type DefaultType = Self;
2918 }
2919 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2920 #[repr(C)]
2921 #[cfg(feature = "Win32_Foundation")]
2922 pub struct KERB_PURGE_KDC_PROXY_CACHE_REQUEST {
2923     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
2924     pub Flags: u32,
2925     pub LogonId: super::super::super::Foundation::LUID,
2926 }
2927 #[cfg(feature = "Win32_Foundation")]
2928 impl KERB_PURGE_KDC_PROXY_CACHE_REQUEST {}
2929 #[cfg(feature = "Win32_Foundation")]
2930 impl ::std::default::Default for KERB_PURGE_KDC_PROXY_CACHE_REQUEST {
2931     fn default() -> Self {
2932         unsafe { ::std::mem::zeroed() }
2933     }
2934 }
2935 #[cfg(feature = "Win32_Foundation")]
2936 impl ::std::fmt::Debug for KERB_PURGE_KDC_PROXY_CACHE_REQUEST {
2937     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2938         fmt.debug_struct("KERB_PURGE_KDC_PROXY_CACHE_REQUEST").field("MessageType", &self.MessageType).field("Flags", &self.Flags).field("LogonId", &self.LogonId).finish()
2939     }
2940 }
2941 #[cfg(feature = "Win32_Foundation")]
2942 impl ::std::cmp::PartialEq for KERB_PURGE_KDC_PROXY_CACHE_REQUEST {
2943     fn eq(&self, other: &Self) -> bool {
2944         self.MessageType == other.MessageType && self.Flags == other.Flags && self.LogonId == other.LogonId
2945     }
2946 }
2947 #[cfg(feature = "Win32_Foundation")]
2948 impl ::std::cmp::Eq for KERB_PURGE_KDC_PROXY_CACHE_REQUEST {}
2949 #[cfg(feature = "Win32_Foundation")]
2950 unsafe impl ::windows::runtime::Abi for KERB_PURGE_KDC_PROXY_CACHE_REQUEST {
2951     type Abi = Self;
2952     type DefaultType = Self;
2953 }
2954 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2955 #[repr(C)]
2956 pub struct KERB_PURGE_KDC_PROXY_CACHE_RESPONSE {
2957     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
2958     pub CountOfPurged: u32,
2959 }
2960 impl KERB_PURGE_KDC_PROXY_CACHE_RESPONSE {}
2961 impl ::std::default::Default for KERB_PURGE_KDC_PROXY_CACHE_RESPONSE {
2962     fn default() -> Self {
2963         unsafe { ::std::mem::zeroed() }
2964     }
2965 }
2966 impl ::std::fmt::Debug for KERB_PURGE_KDC_PROXY_CACHE_RESPONSE {
2967     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2968         fmt.debug_struct("KERB_PURGE_KDC_PROXY_CACHE_RESPONSE").field("MessageType", &self.MessageType).field("CountOfPurged", &self.CountOfPurged).finish()
2969     }
2970 }
2971 impl ::std::cmp::PartialEq for KERB_PURGE_KDC_PROXY_CACHE_RESPONSE {
2972     fn eq(&self, other: &Self) -> bool {
2973         self.MessageType == other.MessageType && self.CountOfPurged == other.CountOfPurged
2974     }
2975 }
2976 impl ::std::cmp::Eq for KERB_PURGE_KDC_PROXY_CACHE_RESPONSE {}
2977 unsafe impl ::windows::runtime::Abi for KERB_PURGE_KDC_PROXY_CACHE_RESPONSE {
2978     type Abi = Self;
2979     type DefaultType = Self;
2980 }
2981 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2982 #[repr(C)]
2983 #[cfg(feature = "Win32_Foundation")]
2984 pub struct KERB_PURGE_TKT_CACHE_EX_REQUEST {
2985     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
2986     pub LogonId: super::super::super::Foundation::LUID,
2987     pub Flags: u32,
2988     pub TicketTemplate: KERB_TICKET_CACHE_INFO_EX,
2989 }
2990 #[cfg(feature = "Win32_Foundation")]
2991 impl KERB_PURGE_TKT_CACHE_EX_REQUEST {}
2992 #[cfg(feature = "Win32_Foundation")]
2993 impl ::std::default::Default for KERB_PURGE_TKT_CACHE_EX_REQUEST {
2994     fn default() -> Self {
2995         unsafe { ::std::mem::zeroed() }
2996     }
2997 }
2998 #[cfg(feature = "Win32_Foundation")]
2999 impl ::std::fmt::Debug for KERB_PURGE_TKT_CACHE_EX_REQUEST {
3000     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3001         fmt.debug_struct("KERB_PURGE_TKT_CACHE_EX_REQUEST").field("MessageType", &self.MessageType).field("LogonId", &self.LogonId).field("Flags", &self.Flags).field("TicketTemplate", &self.TicketTemplate).finish()
3002     }
3003 }
3004 #[cfg(feature = "Win32_Foundation")]
3005 impl ::std::cmp::PartialEq for KERB_PURGE_TKT_CACHE_EX_REQUEST {
3006     fn eq(&self, other: &Self) -> bool {
3007         self.MessageType == other.MessageType && self.LogonId == other.LogonId && self.Flags == other.Flags && self.TicketTemplate == other.TicketTemplate
3008     }
3009 }
3010 #[cfg(feature = "Win32_Foundation")]
3011 impl ::std::cmp::Eq for KERB_PURGE_TKT_CACHE_EX_REQUEST {}
3012 #[cfg(feature = "Win32_Foundation")]
3013 unsafe impl ::windows::runtime::Abi for KERB_PURGE_TKT_CACHE_EX_REQUEST {
3014     type Abi = Self;
3015     type DefaultType = Self;
3016 }
3017 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3018 #[repr(C)]
3019 #[cfg(feature = "Win32_Foundation")]
3020 pub struct KERB_PURGE_TKT_CACHE_REQUEST {
3021     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3022     pub LogonId: super::super::super::Foundation::LUID,
3023     pub ServerName: super::super::super::Foundation::UNICODE_STRING,
3024     pub RealmName: super::super::super::Foundation::UNICODE_STRING,
3025 }
3026 #[cfg(feature = "Win32_Foundation")]
3027 impl KERB_PURGE_TKT_CACHE_REQUEST {}
3028 #[cfg(feature = "Win32_Foundation")]
3029 impl ::std::default::Default for KERB_PURGE_TKT_CACHE_REQUEST {
3030     fn default() -> Self {
3031         unsafe { ::std::mem::zeroed() }
3032     }
3033 }
3034 #[cfg(feature = "Win32_Foundation")]
3035 impl ::std::fmt::Debug for KERB_PURGE_TKT_CACHE_REQUEST {
3036     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3037         fmt.debug_struct("KERB_PURGE_TKT_CACHE_REQUEST").field("MessageType", &self.MessageType).field("LogonId", &self.LogonId).field("ServerName", &self.ServerName).field("RealmName", &self.RealmName).finish()
3038     }
3039 }
3040 #[cfg(feature = "Win32_Foundation")]
3041 impl ::std::cmp::PartialEq for KERB_PURGE_TKT_CACHE_REQUEST {
3042     fn eq(&self, other: &Self) -> bool {
3043         self.MessageType == other.MessageType && self.LogonId == other.LogonId && self.ServerName == other.ServerName && self.RealmName == other.RealmName
3044     }
3045 }
3046 #[cfg(feature = "Win32_Foundation")]
3047 impl ::std::cmp::Eq for KERB_PURGE_TKT_CACHE_REQUEST {}
3048 #[cfg(feature = "Win32_Foundation")]
3049 unsafe impl ::windows::runtime::Abi for KERB_PURGE_TKT_CACHE_REQUEST {
3050     type Abi = Self;
3051     type DefaultType = Self;
3052 }
3053 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3054 #[repr(C)]
3055 pub struct KERB_QUERY_BINDING_CACHE_REQUEST {
3056     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3057 }
3058 impl KERB_QUERY_BINDING_CACHE_REQUEST {}
3059 impl ::std::default::Default for KERB_QUERY_BINDING_CACHE_REQUEST {
3060     fn default() -> Self {
3061         unsafe { ::std::mem::zeroed() }
3062     }
3063 }
3064 impl ::std::fmt::Debug for KERB_QUERY_BINDING_CACHE_REQUEST {
3065     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3066         fmt.debug_struct("KERB_QUERY_BINDING_CACHE_REQUEST").field("MessageType", &self.MessageType).finish()
3067     }
3068 }
3069 impl ::std::cmp::PartialEq for KERB_QUERY_BINDING_CACHE_REQUEST {
3070     fn eq(&self, other: &Self) -> bool {
3071         self.MessageType == other.MessageType
3072     }
3073 }
3074 impl ::std::cmp::Eq for KERB_QUERY_BINDING_CACHE_REQUEST {}
3075 unsafe impl ::windows::runtime::Abi for KERB_QUERY_BINDING_CACHE_REQUEST {
3076     type Abi = Self;
3077     type DefaultType = Self;
3078 }
3079 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3080 #[repr(C)]
3081 #[cfg(feature = "Win32_Foundation")]
3082 pub struct KERB_QUERY_BINDING_CACHE_RESPONSE {
3083     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3084     pub CountOfEntries: u32,
3085     pub Entries: *mut KERB_BINDING_CACHE_ENTRY_DATA,
3086 }
3087 #[cfg(feature = "Win32_Foundation")]
3088 impl KERB_QUERY_BINDING_CACHE_RESPONSE {}
3089 #[cfg(feature = "Win32_Foundation")]
3090 impl ::std::default::Default for KERB_QUERY_BINDING_CACHE_RESPONSE {
3091     fn default() -> Self {
3092         unsafe { ::std::mem::zeroed() }
3093     }
3094 }
3095 #[cfg(feature = "Win32_Foundation")]
3096 impl ::std::fmt::Debug for KERB_QUERY_BINDING_CACHE_RESPONSE {
3097     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3098         fmt.debug_struct("KERB_QUERY_BINDING_CACHE_RESPONSE").field("MessageType", &self.MessageType).field("CountOfEntries", &self.CountOfEntries).field("Entries", &self.Entries).finish()
3099     }
3100 }
3101 #[cfg(feature = "Win32_Foundation")]
3102 impl ::std::cmp::PartialEq for KERB_QUERY_BINDING_CACHE_RESPONSE {
3103     fn eq(&self, other: &Self) -> bool {
3104         self.MessageType == other.MessageType && self.CountOfEntries == other.CountOfEntries && self.Entries == other.Entries
3105     }
3106 }
3107 #[cfg(feature = "Win32_Foundation")]
3108 impl ::std::cmp::Eq for KERB_QUERY_BINDING_CACHE_RESPONSE {}
3109 #[cfg(feature = "Win32_Foundation")]
3110 unsafe impl ::windows::runtime::Abi for KERB_QUERY_BINDING_CACHE_RESPONSE {
3111     type Abi = Self;
3112     type DefaultType = Self;
3113 }
3114 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3115 #[repr(C)]
3116 #[cfg(feature = "Win32_Foundation")]
3117 pub struct KERB_QUERY_DOMAIN_EXTENDED_POLICIES_REQUEST {
3118     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3119     pub Flags: u32,
3120     pub DomainName: super::super::super::Foundation::UNICODE_STRING,
3121 }
3122 #[cfg(feature = "Win32_Foundation")]
3123 impl KERB_QUERY_DOMAIN_EXTENDED_POLICIES_REQUEST {}
3124 #[cfg(feature = "Win32_Foundation")]
3125 impl ::std::default::Default for KERB_QUERY_DOMAIN_EXTENDED_POLICIES_REQUEST {
3126     fn default() -> Self {
3127         unsafe { ::std::mem::zeroed() }
3128     }
3129 }
3130 #[cfg(feature = "Win32_Foundation")]
3131 impl ::std::fmt::Debug for KERB_QUERY_DOMAIN_EXTENDED_POLICIES_REQUEST {
3132     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3133         fmt.debug_struct("KERB_QUERY_DOMAIN_EXTENDED_POLICIES_REQUEST").field("MessageType", &self.MessageType).field("Flags", &self.Flags).field("DomainName", &self.DomainName).finish()
3134     }
3135 }
3136 #[cfg(feature = "Win32_Foundation")]
3137 impl ::std::cmp::PartialEq for KERB_QUERY_DOMAIN_EXTENDED_POLICIES_REQUEST {
3138     fn eq(&self, other: &Self) -> bool {
3139         self.MessageType == other.MessageType && self.Flags == other.Flags && self.DomainName == other.DomainName
3140     }
3141 }
3142 #[cfg(feature = "Win32_Foundation")]
3143 impl ::std::cmp::Eq for KERB_QUERY_DOMAIN_EXTENDED_POLICIES_REQUEST {}
3144 #[cfg(feature = "Win32_Foundation")]
3145 unsafe impl ::windows::runtime::Abi for KERB_QUERY_DOMAIN_EXTENDED_POLICIES_REQUEST {
3146     type Abi = Self;
3147     type DefaultType = Self;
3148 }
3149 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3150 #[repr(C)]
3151 pub struct KERB_QUERY_DOMAIN_EXTENDED_POLICIES_RESPONSE {
3152     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3153     pub Flags: u32,
3154     pub ExtendedPolicies: u32,
3155     pub DsFlags: u32,
3156 }
3157 impl KERB_QUERY_DOMAIN_EXTENDED_POLICIES_RESPONSE {}
3158 impl ::std::default::Default for KERB_QUERY_DOMAIN_EXTENDED_POLICIES_RESPONSE {
3159     fn default() -> Self {
3160         unsafe { ::std::mem::zeroed() }
3161     }
3162 }
3163 impl ::std::fmt::Debug for KERB_QUERY_DOMAIN_EXTENDED_POLICIES_RESPONSE {
3164     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3165         fmt.debug_struct("KERB_QUERY_DOMAIN_EXTENDED_POLICIES_RESPONSE").field("MessageType", &self.MessageType).field("Flags", &self.Flags).field("ExtendedPolicies", &self.ExtendedPolicies).field("DsFlags", &self.DsFlags).finish()
3166     }
3167 }
3168 impl ::std::cmp::PartialEq for KERB_QUERY_DOMAIN_EXTENDED_POLICIES_RESPONSE {
3169     fn eq(&self, other: &Self) -> bool {
3170         self.MessageType == other.MessageType && self.Flags == other.Flags && self.ExtendedPolicies == other.ExtendedPolicies && self.DsFlags == other.DsFlags
3171     }
3172 }
3173 impl ::std::cmp::Eq for KERB_QUERY_DOMAIN_EXTENDED_POLICIES_RESPONSE {}
3174 unsafe impl ::windows::runtime::Abi for KERB_QUERY_DOMAIN_EXTENDED_POLICIES_RESPONSE {
3175     type Abi = Self;
3176     type DefaultType = Self;
3177 }
3178 pub const KERB_QUERY_DOMAIN_EXTENDED_POLICIES_RESPONSE_FLAG_DAC_DISABLED: u32 = 1u32;
3179 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3180 #[repr(C)]
3181 #[cfg(feature = "Win32_Foundation")]
3182 pub struct KERB_QUERY_KDC_PROXY_CACHE_REQUEST {
3183     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3184     pub Flags: u32,
3185     pub LogonId: super::super::super::Foundation::LUID,
3186 }
3187 #[cfg(feature = "Win32_Foundation")]
3188 impl KERB_QUERY_KDC_PROXY_CACHE_REQUEST {}
3189 #[cfg(feature = "Win32_Foundation")]
3190 impl ::std::default::Default for KERB_QUERY_KDC_PROXY_CACHE_REQUEST {
3191     fn default() -> Self {
3192         unsafe { ::std::mem::zeroed() }
3193     }
3194 }
3195 #[cfg(feature = "Win32_Foundation")]
3196 impl ::std::fmt::Debug for KERB_QUERY_KDC_PROXY_CACHE_REQUEST {
3197     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3198         fmt.debug_struct("KERB_QUERY_KDC_PROXY_CACHE_REQUEST").field("MessageType", &self.MessageType).field("Flags", &self.Flags).field("LogonId", &self.LogonId).finish()
3199     }
3200 }
3201 #[cfg(feature = "Win32_Foundation")]
3202 impl ::std::cmp::PartialEq for KERB_QUERY_KDC_PROXY_CACHE_REQUEST {
3203     fn eq(&self, other: &Self) -> bool {
3204         self.MessageType == other.MessageType && self.Flags == other.Flags && self.LogonId == other.LogonId
3205     }
3206 }
3207 #[cfg(feature = "Win32_Foundation")]
3208 impl ::std::cmp::Eq for KERB_QUERY_KDC_PROXY_CACHE_REQUEST {}
3209 #[cfg(feature = "Win32_Foundation")]
3210 unsafe impl ::windows::runtime::Abi for KERB_QUERY_KDC_PROXY_CACHE_REQUEST {
3211     type Abi = Self;
3212     type DefaultType = Self;
3213 }
3214 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3215 #[repr(C)]
3216 #[cfg(feature = "Win32_Foundation")]
3217 pub struct KERB_QUERY_KDC_PROXY_CACHE_RESPONSE {
3218     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3219     pub CountOfEntries: u32,
3220     pub Entries: *mut KDC_PROXY_CACHE_ENTRY_DATA,
3221 }
3222 #[cfg(feature = "Win32_Foundation")]
3223 impl KERB_QUERY_KDC_PROXY_CACHE_RESPONSE {}
3224 #[cfg(feature = "Win32_Foundation")]
3225 impl ::std::default::Default for KERB_QUERY_KDC_PROXY_CACHE_RESPONSE {
3226     fn default() -> Self {
3227         unsafe { ::std::mem::zeroed() }
3228     }
3229 }
3230 #[cfg(feature = "Win32_Foundation")]
3231 impl ::std::fmt::Debug for KERB_QUERY_KDC_PROXY_CACHE_RESPONSE {
3232     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3233         fmt.debug_struct("KERB_QUERY_KDC_PROXY_CACHE_RESPONSE").field("MessageType", &self.MessageType).field("CountOfEntries", &self.CountOfEntries).field("Entries", &self.Entries).finish()
3234     }
3235 }
3236 #[cfg(feature = "Win32_Foundation")]
3237 impl ::std::cmp::PartialEq for KERB_QUERY_KDC_PROXY_CACHE_RESPONSE {
3238     fn eq(&self, other: &Self) -> bool {
3239         self.MessageType == other.MessageType && self.CountOfEntries == other.CountOfEntries && self.Entries == other.Entries
3240     }
3241 }
3242 #[cfg(feature = "Win32_Foundation")]
3243 impl ::std::cmp::Eq for KERB_QUERY_KDC_PROXY_CACHE_RESPONSE {}
3244 #[cfg(feature = "Win32_Foundation")]
3245 unsafe impl ::windows::runtime::Abi for KERB_QUERY_KDC_PROXY_CACHE_RESPONSE {
3246     type Abi = Self;
3247     type DefaultType = Self;
3248 }
3249 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3250 #[repr(C)]
3251 #[cfg(feature = "Win32_Foundation")]
3252 pub struct KERB_QUERY_S4U2PROXY_CACHE_REQUEST {
3253     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3254     pub Flags: u32,
3255     pub LogonId: super::super::super::Foundation::LUID,
3256 }
3257 #[cfg(feature = "Win32_Foundation")]
3258 impl KERB_QUERY_S4U2PROXY_CACHE_REQUEST {}
3259 #[cfg(feature = "Win32_Foundation")]
3260 impl ::std::default::Default for KERB_QUERY_S4U2PROXY_CACHE_REQUEST {
3261     fn default() -> Self {
3262         unsafe { ::std::mem::zeroed() }
3263     }
3264 }
3265 #[cfg(feature = "Win32_Foundation")]
3266 impl ::std::fmt::Debug for KERB_QUERY_S4U2PROXY_CACHE_REQUEST {
3267     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3268         fmt.debug_struct("KERB_QUERY_S4U2PROXY_CACHE_REQUEST").field("MessageType", &self.MessageType).field("Flags", &self.Flags).field("LogonId", &self.LogonId).finish()
3269     }
3270 }
3271 #[cfg(feature = "Win32_Foundation")]
3272 impl ::std::cmp::PartialEq for KERB_QUERY_S4U2PROXY_CACHE_REQUEST {
3273     fn eq(&self, other: &Self) -> bool {
3274         self.MessageType == other.MessageType && self.Flags == other.Flags && self.LogonId == other.LogonId
3275     }
3276 }
3277 #[cfg(feature = "Win32_Foundation")]
3278 impl ::std::cmp::Eq for KERB_QUERY_S4U2PROXY_CACHE_REQUEST {}
3279 #[cfg(feature = "Win32_Foundation")]
3280 unsafe impl ::windows::runtime::Abi for KERB_QUERY_S4U2PROXY_CACHE_REQUEST {
3281     type Abi = Self;
3282     type DefaultType = Self;
3283 }
3284 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3285 #[repr(C)]
3286 #[cfg(feature = "Win32_Foundation")]
3287 pub struct KERB_QUERY_S4U2PROXY_CACHE_RESPONSE {
3288     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3289     pub CountOfCreds: u32,
3290     pub Creds: *mut KERB_S4U2PROXY_CRED,
3291 }
3292 #[cfg(feature = "Win32_Foundation")]
3293 impl KERB_QUERY_S4U2PROXY_CACHE_RESPONSE {}
3294 #[cfg(feature = "Win32_Foundation")]
3295 impl ::std::default::Default for KERB_QUERY_S4U2PROXY_CACHE_RESPONSE {
3296     fn default() -> Self {
3297         unsafe { ::std::mem::zeroed() }
3298     }
3299 }
3300 #[cfg(feature = "Win32_Foundation")]
3301 impl ::std::fmt::Debug for KERB_QUERY_S4U2PROXY_CACHE_RESPONSE {
3302     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3303         fmt.debug_struct("KERB_QUERY_S4U2PROXY_CACHE_RESPONSE").field("MessageType", &self.MessageType).field("CountOfCreds", &self.CountOfCreds).field("Creds", &self.Creds).finish()
3304     }
3305 }
3306 #[cfg(feature = "Win32_Foundation")]
3307 impl ::std::cmp::PartialEq for KERB_QUERY_S4U2PROXY_CACHE_RESPONSE {
3308     fn eq(&self, other: &Self) -> bool {
3309         self.MessageType == other.MessageType && self.CountOfCreds == other.CountOfCreds && self.Creds == other.Creds
3310     }
3311 }
3312 #[cfg(feature = "Win32_Foundation")]
3313 impl ::std::cmp::Eq for KERB_QUERY_S4U2PROXY_CACHE_RESPONSE {}
3314 #[cfg(feature = "Win32_Foundation")]
3315 unsafe impl ::windows::runtime::Abi for KERB_QUERY_S4U2PROXY_CACHE_RESPONSE {
3316     type Abi = Self;
3317     type DefaultType = Self;
3318 }
3319 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3320 #[repr(C)]
3321 #[cfg(feature = "Win32_Foundation")]
3322 pub struct KERB_QUERY_TKT_CACHE_EX2_RESPONSE {
3323     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3324     pub CountOfTickets: u32,
3325     pub Tickets: [KERB_TICKET_CACHE_INFO_EX2; 1],
3326 }
3327 #[cfg(feature = "Win32_Foundation")]
3328 impl KERB_QUERY_TKT_CACHE_EX2_RESPONSE {}
3329 #[cfg(feature = "Win32_Foundation")]
3330 impl ::std::default::Default for KERB_QUERY_TKT_CACHE_EX2_RESPONSE {
3331     fn default() -> Self {
3332         unsafe { ::std::mem::zeroed() }
3333     }
3334 }
3335 #[cfg(feature = "Win32_Foundation")]
3336 impl ::std::fmt::Debug for KERB_QUERY_TKT_CACHE_EX2_RESPONSE {
3337     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3338         fmt.debug_struct("KERB_QUERY_TKT_CACHE_EX2_RESPONSE").field("MessageType", &self.MessageType).field("CountOfTickets", &self.CountOfTickets).field("Tickets", &self.Tickets).finish()
3339     }
3340 }
3341 #[cfg(feature = "Win32_Foundation")]
3342 impl ::std::cmp::PartialEq for KERB_QUERY_TKT_CACHE_EX2_RESPONSE {
3343     fn eq(&self, other: &Self) -> bool {
3344         self.MessageType == other.MessageType && self.CountOfTickets == other.CountOfTickets && self.Tickets == other.Tickets
3345     }
3346 }
3347 #[cfg(feature = "Win32_Foundation")]
3348 impl ::std::cmp::Eq for KERB_QUERY_TKT_CACHE_EX2_RESPONSE {}
3349 #[cfg(feature = "Win32_Foundation")]
3350 unsafe impl ::windows::runtime::Abi for KERB_QUERY_TKT_CACHE_EX2_RESPONSE {
3351     type Abi = Self;
3352     type DefaultType = Self;
3353 }
3354 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3355 #[repr(C)]
3356 #[cfg(feature = "Win32_Foundation")]
3357 pub struct KERB_QUERY_TKT_CACHE_EX3_RESPONSE {
3358     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3359     pub CountOfTickets: u32,
3360     pub Tickets: [KERB_TICKET_CACHE_INFO_EX3; 1],
3361 }
3362 #[cfg(feature = "Win32_Foundation")]
3363 impl KERB_QUERY_TKT_CACHE_EX3_RESPONSE {}
3364 #[cfg(feature = "Win32_Foundation")]
3365 impl ::std::default::Default for KERB_QUERY_TKT_CACHE_EX3_RESPONSE {
3366     fn default() -> Self {
3367         unsafe { ::std::mem::zeroed() }
3368     }
3369 }
3370 #[cfg(feature = "Win32_Foundation")]
3371 impl ::std::fmt::Debug for KERB_QUERY_TKT_CACHE_EX3_RESPONSE {
3372     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3373         fmt.debug_struct("KERB_QUERY_TKT_CACHE_EX3_RESPONSE").field("MessageType", &self.MessageType).field("CountOfTickets", &self.CountOfTickets).field("Tickets", &self.Tickets).finish()
3374     }
3375 }
3376 #[cfg(feature = "Win32_Foundation")]
3377 impl ::std::cmp::PartialEq for KERB_QUERY_TKT_CACHE_EX3_RESPONSE {
3378     fn eq(&self, other: &Self) -> bool {
3379         self.MessageType == other.MessageType && self.CountOfTickets == other.CountOfTickets && self.Tickets == other.Tickets
3380     }
3381 }
3382 #[cfg(feature = "Win32_Foundation")]
3383 impl ::std::cmp::Eq for KERB_QUERY_TKT_CACHE_EX3_RESPONSE {}
3384 #[cfg(feature = "Win32_Foundation")]
3385 unsafe impl ::windows::runtime::Abi for KERB_QUERY_TKT_CACHE_EX3_RESPONSE {
3386     type Abi = Self;
3387     type DefaultType = Self;
3388 }
3389 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3390 #[repr(C)]
3391 #[cfg(feature = "Win32_Foundation")]
3392 pub struct KERB_QUERY_TKT_CACHE_EX_RESPONSE {
3393     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3394     pub CountOfTickets: u32,
3395     pub Tickets: [KERB_TICKET_CACHE_INFO_EX; 1],
3396 }
3397 #[cfg(feature = "Win32_Foundation")]
3398 impl KERB_QUERY_TKT_CACHE_EX_RESPONSE {}
3399 #[cfg(feature = "Win32_Foundation")]
3400 impl ::std::default::Default for KERB_QUERY_TKT_CACHE_EX_RESPONSE {
3401     fn default() -> Self {
3402         unsafe { ::std::mem::zeroed() }
3403     }
3404 }
3405 #[cfg(feature = "Win32_Foundation")]
3406 impl ::std::fmt::Debug for KERB_QUERY_TKT_CACHE_EX_RESPONSE {
3407     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3408         fmt.debug_struct("KERB_QUERY_TKT_CACHE_EX_RESPONSE").field("MessageType", &self.MessageType).field("CountOfTickets", &self.CountOfTickets).field("Tickets", &self.Tickets).finish()
3409     }
3410 }
3411 #[cfg(feature = "Win32_Foundation")]
3412 impl ::std::cmp::PartialEq for KERB_QUERY_TKT_CACHE_EX_RESPONSE {
3413     fn eq(&self, other: &Self) -> bool {
3414         self.MessageType == other.MessageType && self.CountOfTickets == other.CountOfTickets && self.Tickets == other.Tickets
3415     }
3416 }
3417 #[cfg(feature = "Win32_Foundation")]
3418 impl ::std::cmp::Eq for KERB_QUERY_TKT_CACHE_EX_RESPONSE {}
3419 #[cfg(feature = "Win32_Foundation")]
3420 unsafe impl ::windows::runtime::Abi for KERB_QUERY_TKT_CACHE_EX_RESPONSE {
3421     type Abi = Self;
3422     type DefaultType = Self;
3423 }
3424 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3425 #[repr(C)]
3426 #[cfg(feature = "Win32_Foundation")]
3427 pub struct KERB_QUERY_TKT_CACHE_REQUEST {
3428     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3429     pub LogonId: super::super::super::Foundation::LUID,
3430 }
3431 #[cfg(feature = "Win32_Foundation")]
3432 impl KERB_QUERY_TKT_CACHE_REQUEST {}
3433 #[cfg(feature = "Win32_Foundation")]
3434 impl ::std::default::Default for KERB_QUERY_TKT_CACHE_REQUEST {
3435     fn default() -> Self {
3436         unsafe { ::std::mem::zeroed() }
3437     }
3438 }
3439 #[cfg(feature = "Win32_Foundation")]
3440 impl ::std::fmt::Debug for KERB_QUERY_TKT_CACHE_REQUEST {
3441     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3442         fmt.debug_struct("KERB_QUERY_TKT_CACHE_REQUEST").field("MessageType", &self.MessageType).field("LogonId", &self.LogonId).finish()
3443     }
3444 }
3445 #[cfg(feature = "Win32_Foundation")]
3446 impl ::std::cmp::PartialEq for KERB_QUERY_TKT_CACHE_REQUEST {
3447     fn eq(&self, other: &Self) -> bool {
3448         self.MessageType == other.MessageType && self.LogonId == other.LogonId
3449     }
3450 }
3451 #[cfg(feature = "Win32_Foundation")]
3452 impl ::std::cmp::Eq for KERB_QUERY_TKT_CACHE_REQUEST {}
3453 #[cfg(feature = "Win32_Foundation")]
3454 unsafe impl ::windows::runtime::Abi for KERB_QUERY_TKT_CACHE_REQUEST {
3455     type Abi = Self;
3456     type DefaultType = Self;
3457 }
3458 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3459 #[repr(C)]
3460 #[cfg(feature = "Win32_Foundation")]
3461 pub struct KERB_QUERY_TKT_CACHE_RESPONSE {
3462     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3463     pub CountOfTickets: u32,
3464     pub Tickets: [KERB_TICKET_CACHE_INFO; 1],
3465 }
3466 #[cfg(feature = "Win32_Foundation")]
3467 impl KERB_QUERY_TKT_CACHE_RESPONSE {}
3468 #[cfg(feature = "Win32_Foundation")]
3469 impl ::std::default::Default for KERB_QUERY_TKT_CACHE_RESPONSE {
3470     fn default() -> Self {
3471         unsafe { ::std::mem::zeroed() }
3472     }
3473 }
3474 #[cfg(feature = "Win32_Foundation")]
3475 impl ::std::fmt::Debug for KERB_QUERY_TKT_CACHE_RESPONSE {
3476     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3477         fmt.debug_struct("KERB_QUERY_TKT_CACHE_RESPONSE").field("MessageType", &self.MessageType).field("CountOfTickets", &self.CountOfTickets).field("Tickets", &self.Tickets).finish()
3478     }
3479 }
3480 #[cfg(feature = "Win32_Foundation")]
3481 impl ::std::cmp::PartialEq for KERB_QUERY_TKT_CACHE_RESPONSE {
3482     fn eq(&self, other: &Self) -> bool {
3483         self.MessageType == other.MessageType && self.CountOfTickets == other.CountOfTickets && self.Tickets == other.Tickets
3484     }
3485 }
3486 #[cfg(feature = "Win32_Foundation")]
3487 impl ::std::cmp::Eq for KERB_QUERY_TKT_CACHE_RESPONSE {}
3488 #[cfg(feature = "Win32_Foundation")]
3489 unsafe impl ::windows::runtime::Abi for KERB_QUERY_TKT_CACHE_RESPONSE {
3490     type Abi = Self;
3491     type DefaultType = Self;
3492 }
3493 pub const KERB_REFRESH_POLICY_KDC: u32 = 2u32;
3494 pub const KERB_REFRESH_POLICY_KERBEROS: u32 = 1u32;
3495 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3496 #[repr(C)]
3497 pub struct KERB_REFRESH_POLICY_REQUEST {
3498     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3499     pub Flags: u32,
3500 }
3501 impl KERB_REFRESH_POLICY_REQUEST {}
3502 impl ::std::default::Default for KERB_REFRESH_POLICY_REQUEST {
3503     fn default() -> Self {
3504         unsafe { ::std::mem::zeroed() }
3505     }
3506 }
3507 impl ::std::fmt::Debug for KERB_REFRESH_POLICY_REQUEST {
3508     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3509         fmt.debug_struct("KERB_REFRESH_POLICY_REQUEST").field("MessageType", &self.MessageType).field("Flags", &self.Flags).finish()
3510     }
3511 }
3512 impl ::std::cmp::PartialEq for KERB_REFRESH_POLICY_REQUEST {
3513     fn eq(&self, other: &Self) -> bool {
3514         self.MessageType == other.MessageType && self.Flags == other.Flags
3515     }
3516 }
3517 impl ::std::cmp::Eq for KERB_REFRESH_POLICY_REQUEST {}
3518 unsafe impl ::windows::runtime::Abi for KERB_REFRESH_POLICY_REQUEST {
3519     type Abi = Self;
3520     type DefaultType = Self;
3521 }
3522 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3523 #[repr(C)]
3524 pub struct KERB_REFRESH_POLICY_RESPONSE {
3525     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3526     pub Flags: u32,
3527 }
3528 impl KERB_REFRESH_POLICY_RESPONSE {}
3529 impl ::std::default::Default for KERB_REFRESH_POLICY_RESPONSE {
3530     fn default() -> Self {
3531         unsafe { ::std::mem::zeroed() }
3532     }
3533 }
3534 impl ::std::fmt::Debug for KERB_REFRESH_POLICY_RESPONSE {
3535     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3536         fmt.debug_struct("KERB_REFRESH_POLICY_RESPONSE").field("MessageType", &self.MessageType).field("Flags", &self.Flags).finish()
3537     }
3538 }
3539 impl ::std::cmp::PartialEq for KERB_REFRESH_POLICY_RESPONSE {
3540     fn eq(&self, other: &Self) -> bool {
3541         self.MessageType == other.MessageType && self.Flags == other.Flags
3542     }
3543 }
3544 impl ::std::cmp::Eq for KERB_REFRESH_POLICY_RESPONSE {}
3545 unsafe impl ::windows::runtime::Abi for KERB_REFRESH_POLICY_RESPONSE {
3546     type Abi = Self;
3547     type DefaultType = Self;
3548 }
3549 pub const KERB_REFRESH_SCCRED_GETTGT: u32 = 1u32;
3550 pub const KERB_REFRESH_SCCRED_RELEASE: u32 = 0u32;
3551 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3552 #[repr(C)]
3553 #[cfg(feature = "Win32_Foundation")]
3554 pub struct KERB_REFRESH_SCCRED_REQUEST {
3555     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3556     pub CredentialBlob: super::super::super::Foundation::UNICODE_STRING,
3557     pub LogonId: super::super::super::Foundation::LUID,
3558     pub Flags: u32,
3559 }
3560 #[cfg(feature = "Win32_Foundation")]
3561 impl KERB_REFRESH_SCCRED_REQUEST {}
3562 #[cfg(feature = "Win32_Foundation")]
3563 impl ::std::default::Default for KERB_REFRESH_SCCRED_REQUEST {
3564     fn default() -> Self {
3565         unsafe { ::std::mem::zeroed() }
3566     }
3567 }
3568 #[cfg(feature = "Win32_Foundation")]
3569 impl ::std::fmt::Debug for KERB_REFRESH_SCCRED_REQUEST {
3570     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3571         fmt.debug_struct("KERB_REFRESH_SCCRED_REQUEST").field("MessageType", &self.MessageType).field("CredentialBlob", &self.CredentialBlob).field("LogonId", &self.LogonId).field("Flags", &self.Flags).finish()
3572     }
3573 }
3574 #[cfg(feature = "Win32_Foundation")]
3575 impl ::std::cmp::PartialEq for KERB_REFRESH_SCCRED_REQUEST {
3576     fn eq(&self, other: &Self) -> bool {
3577         self.MessageType == other.MessageType && self.CredentialBlob == other.CredentialBlob && self.LogonId == other.LogonId && self.Flags == other.Flags
3578     }
3579 }
3580 #[cfg(feature = "Win32_Foundation")]
3581 impl ::std::cmp::Eq for KERB_REFRESH_SCCRED_REQUEST {}
3582 #[cfg(feature = "Win32_Foundation")]
3583 unsafe impl ::windows::runtime::Abi for KERB_REFRESH_SCCRED_REQUEST {
3584     type Abi = Self;
3585     type DefaultType = Self;
3586 }
3587 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3588 #[repr(transparent)]
3589 pub struct KERB_REQUEST_FLAGS(pub u32);
3590 pub const KERB_REQUEST_ADD_CREDENTIAL: KERB_REQUEST_FLAGS = KERB_REQUEST_FLAGS(1u32);
3591 pub const KERB_REQUEST_REPLACE_CREDENTIAL: KERB_REQUEST_FLAGS = KERB_REQUEST_FLAGS(2u32);
3592 pub const KERB_REQUEST_REMOVE_CREDENTIAL: KERB_REQUEST_FLAGS = KERB_REQUEST_FLAGS(4u32);
3593 impl ::std::convert::From<u32> for KERB_REQUEST_FLAGS {
3594     fn from(value: u32) -> Self {
3595         Self(value)
3596     }
3597 }
3598 unsafe impl ::windows::runtime::Abi for KERB_REQUEST_FLAGS {
3599     type Abi = Self;
3600     type DefaultType = Self;
3601 }
3602 impl ::std::ops::BitOr for KERB_REQUEST_FLAGS {
3603     type Output = Self;
3604     fn bitor(self, rhs: Self) -> Self {
3605         Self(self.0 | rhs.0)
3606     }
3607 }
3608 impl ::std::ops::BitAnd for KERB_REQUEST_FLAGS {
3609     type Output = Self;
3610     fn bitand(self, rhs: Self) -> Self {
3611         Self(self.0 & rhs.0)
3612     }
3613 }
3614 impl ::std::ops::BitOrAssign for KERB_REQUEST_FLAGS {
3615     fn bitor_assign(&mut self, rhs: Self) {
3616         self.0.bitor_assign(rhs.0)
3617     }
3618 }
3619 impl ::std::ops::BitAndAssign for KERB_REQUEST_FLAGS {
3620     fn bitand_assign(&mut self, rhs: Self) {
3621         self.0.bitand_assign(rhs.0)
3622     }
3623 }
3624 impl ::std::ops::Not for KERB_REQUEST_FLAGS {
3625     type Output = Self;
3626     fn not(self) -> Self {
3627         Self(self.0.not())
3628     }
3629 }
3630 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3631 #[repr(C)]
3632 #[cfg(feature = "Win32_Foundation")]
3633 pub struct KERB_RETRIEVE_KEY_TAB_REQUEST {
3634     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3635     pub Flags: u32,
3636     pub UserName: super::super::super::Foundation::UNICODE_STRING,
3637     pub DomainName: super::super::super::Foundation::UNICODE_STRING,
3638     pub Password: super::super::super::Foundation::UNICODE_STRING,
3639 }
3640 #[cfg(feature = "Win32_Foundation")]
3641 impl KERB_RETRIEVE_KEY_TAB_REQUEST {}
3642 #[cfg(feature = "Win32_Foundation")]
3643 impl ::std::default::Default for KERB_RETRIEVE_KEY_TAB_REQUEST {
3644     fn default() -> Self {
3645         unsafe { ::std::mem::zeroed() }
3646     }
3647 }
3648 #[cfg(feature = "Win32_Foundation")]
3649 impl ::std::fmt::Debug for KERB_RETRIEVE_KEY_TAB_REQUEST {
3650     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3651         fmt.debug_struct("KERB_RETRIEVE_KEY_TAB_REQUEST").field("MessageType", &self.MessageType).field("Flags", &self.Flags).field("UserName", &self.UserName).field("DomainName", &self.DomainName).field("Password", &self.Password).finish()
3652     }
3653 }
3654 #[cfg(feature = "Win32_Foundation")]
3655 impl ::std::cmp::PartialEq for KERB_RETRIEVE_KEY_TAB_REQUEST {
3656     fn eq(&self, other: &Self) -> bool {
3657         self.MessageType == other.MessageType && self.Flags == other.Flags && self.UserName == other.UserName && self.DomainName == other.DomainName && self.Password == other.Password
3658     }
3659 }
3660 #[cfg(feature = "Win32_Foundation")]
3661 impl ::std::cmp::Eq for KERB_RETRIEVE_KEY_TAB_REQUEST {}
3662 #[cfg(feature = "Win32_Foundation")]
3663 unsafe impl ::windows::runtime::Abi for KERB_RETRIEVE_KEY_TAB_REQUEST {
3664     type Abi = Self;
3665     type DefaultType = Self;
3666 }
3667 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3668 #[repr(C)]
3669 pub struct KERB_RETRIEVE_KEY_TAB_RESPONSE {
3670     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3671     pub KeyTabLength: u32,
3672     pub KeyTab: *mut u8,
3673 }
3674 impl KERB_RETRIEVE_KEY_TAB_RESPONSE {}
3675 impl ::std::default::Default for KERB_RETRIEVE_KEY_TAB_RESPONSE {
3676     fn default() -> Self {
3677         unsafe { ::std::mem::zeroed() }
3678     }
3679 }
3680 impl ::std::fmt::Debug for KERB_RETRIEVE_KEY_TAB_RESPONSE {
3681     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3682         fmt.debug_struct("KERB_RETRIEVE_KEY_TAB_RESPONSE").field("MessageType", &self.MessageType).field("KeyTabLength", &self.KeyTabLength).field("KeyTab", &self.KeyTab).finish()
3683     }
3684 }
3685 impl ::std::cmp::PartialEq for KERB_RETRIEVE_KEY_TAB_RESPONSE {
3686     fn eq(&self, other: &Self) -> bool {
3687         self.MessageType == other.MessageType && self.KeyTabLength == other.KeyTabLength && self.KeyTab == other.KeyTab
3688     }
3689 }
3690 impl ::std::cmp::Eq for KERB_RETRIEVE_KEY_TAB_RESPONSE {}
3691 unsafe impl ::windows::runtime::Abi for KERB_RETRIEVE_KEY_TAB_RESPONSE {
3692     type Abi = Self;
3693     type DefaultType = Self;
3694 }
3695 pub const KERB_RETRIEVE_TICKET_AS_KERB_CRED: u32 = 8u32;
3696 pub const KERB_RETRIEVE_TICKET_CACHE_TICKET: u32 = 32u32;
3697 pub const KERB_RETRIEVE_TICKET_DEFAULT: u32 = 0u32;
3698 pub const KERB_RETRIEVE_TICKET_DONT_USE_CACHE: u32 = 1u32;
3699 pub const KERB_RETRIEVE_TICKET_MAX_LIFETIME: u32 = 64u32;
3700 pub const KERB_RETRIEVE_TICKET_USE_CACHE_ONLY: u32 = 2u32;
3701 pub const KERB_RETRIEVE_TICKET_USE_CREDHANDLE: u32 = 4u32;
3702 pub const KERB_RETRIEVE_TICKET_WITH_SEC_CRED: u32 = 16u32;
3703 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3704 #[repr(C)]
3705 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3706 pub struct KERB_RETRIEVE_TKT_REQUEST {
3707     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3708     pub LogonId: super::super::super::Foundation::LUID,
3709     pub TargetName: super::super::super::Foundation::UNICODE_STRING,
3710     pub TicketFlags: u32,
3711     pub CacheOptions: u32,
3712     pub EncryptionType: KERB_CRYPTO_KEY_TYPE,
3713     pub CredentialsHandle: super::super::Credentials::SecHandle,
3714 }
3715 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3716 impl KERB_RETRIEVE_TKT_REQUEST {}
3717 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3718 impl ::std::default::Default for KERB_RETRIEVE_TKT_REQUEST {
3719     fn default() -> Self {
3720         unsafe { ::std::mem::zeroed() }
3721     }
3722 }
3723 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3724 impl ::std::fmt::Debug for KERB_RETRIEVE_TKT_REQUEST {
3725     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3726         fmt.debug_struct("KERB_RETRIEVE_TKT_REQUEST")
3727             .field("MessageType", &self.MessageType)
3728             .field("LogonId", &self.LogonId)
3729             .field("TargetName", &self.TargetName)
3730             .field("TicketFlags", &self.TicketFlags)
3731             .field("CacheOptions", &self.CacheOptions)
3732             .field("EncryptionType", &self.EncryptionType)
3733             .field("CredentialsHandle", &self.CredentialsHandle)
3734             .finish()
3735     }
3736 }
3737 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3738 impl ::std::cmp::PartialEq for KERB_RETRIEVE_TKT_REQUEST {
3739     fn eq(&self, other: &Self) -> bool {
3740         self.MessageType == other.MessageType && self.LogonId == other.LogonId && self.TargetName == other.TargetName && self.TicketFlags == other.TicketFlags && self.CacheOptions == other.CacheOptions && self.EncryptionType == other.EncryptionType && self.CredentialsHandle == other.CredentialsHandle
3741     }
3742 }
3743 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3744 impl ::std::cmp::Eq for KERB_RETRIEVE_TKT_REQUEST {}
3745 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3746 unsafe impl ::windows::runtime::Abi for KERB_RETRIEVE_TKT_REQUEST {
3747     type Abi = Self;
3748     type DefaultType = Self;
3749 }
3750 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3751 #[repr(C)]
3752 #[cfg(feature = "Win32_Foundation")]
3753 pub struct KERB_RETRIEVE_TKT_RESPONSE {
3754     pub Ticket: KERB_EXTERNAL_TICKET,
3755 }
3756 #[cfg(feature = "Win32_Foundation")]
3757 impl KERB_RETRIEVE_TKT_RESPONSE {}
3758 #[cfg(feature = "Win32_Foundation")]
3759 impl ::std::default::Default for KERB_RETRIEVE_TKT_RESPONSE {
3760     fn default() -> Self {
3761         unsafe { ::std::mem::zeroed() }
3762     }
3763 }
3764 #[cfg(feature = "Win32_Foundation")]
3765 impl ::std::fmt::Debug for KERB_RETRIEVE_TKT_RESPONSE {
3766     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3767         fmt.debug_struct("KERB_RETRIEVE_TKT_RESPONSE").field("Ticket", &self.Ticket).finish()
3768     }
3769 }
3770 #[cfg(feature = "Win32_Foundation")]
3771 impl ::std::cmp::PartialEq for KERB_RETRIEVE_TKT_RESPONSE {
3772     fn eq(&self, other: &Self) -> bool {
3773         self.Ticket == other.Ticket
3774     }
3775 }
3776 #[cfg(feature = "Win32_Foundation")]
3777 impl ::std::cmp::Eq for KERB_RETRIEVE_TKT_RESPONSE {}
3778 #[cfg(feature = "Win32_Foundation")]
3779 unsafe impl ::windows::runtime::Abi for KERB_RETRIEVE_TKT_RESPONSE {
3780     type Abi = Self;
3781     type DefaultType = Self;
3782 }
3783 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3784 #[repr(C)]
3785 #[cfg(feature = "Win32_Foundation")]
3786 pub struct KERB_S4U2PROXY_CACHE_ENTRY_INFO {
3787     pub ServerName: super::super::super::Foundation::UNICODE_STRING,
3788     pub Flags: u32,
3789     pub LastStatus: super::super::super::Foundation::NTSTATUS,
3790     pub Expiry: i64,
3791 }
3792 #[cfg(feature = "Win32_Foundation")]
3793 impl KERB_S4U2PROXY_CACHE_ENTRY_INFO {}
3794 #[cfg(feature = "Win32_Foundation")]
3795 impl ::std::default::Default for KERB_S4U2PROXY_CACHE_ENTRY_INFO {
3796     fn default() -> Self {
3797         unsafe { ::std::mem::zeroed() }
3798     }
3799 }
3800 #[cfg(feature = "Win32_Foundation")]
3801 impl ::std::fmt::Debug for KERB_S4U2PROXY_CACHE_ENTRY_INFO {
3802     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3803         fmt.debug_struct("KERB_S4U2PROXY_CACHE_ENTRY_INFO").field("ServerName", &self.ServerName).field("Flags", &self.Flags).field("LastStatus", &self.LastStatus).field("Expiry", &self.Expiry).finish()
3804     }
3805 }
3806 #[cfg(feature = "Win32_Foundation")]
3807 impl ::std::cmp::PartialEq for KERB_S4U2PROXY_CACHE_ENTRY_INFO {
3808     fn eq(&self, other: &Self) -> bool {
3809         self.ServerName == other.ServerName && self.Flags == other.Flags && self.LastStatus == other.LastStatus && self.Expiry == other.Expiry
3810     }
3811 }
3812 #[cfg(feature = "Win32_Foundation")]
3813 impl ::std::cmp::Eq for KERB_S4U2PROXY_CACHE_ENTRY_INFO {}
3814 #[cfg(feature = "Win32_Foundation")]
3815 unsafe impl ::windows::runtime::Abi for KERB_S4U2PROXY_CACHE_ENTRY_INFO {
3816     type Abi = Self;
3817     type DefaultType = Self;
3818 }
3819 pub const KERB_S4U2PROXY_CACHE_ENTRY_INFO_FLAG_NEGATIVE: u32 = 1u32;
3820 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3821 #[repr(C)]
3822 #[cfg(feature = "Win32_Foundation")]
3823 pub struct KERB_S4U2PROXY_CRED {
3824     pub UserName: super::super::super::Foundation::UNICODE_STRING,
3825     pub DomainName: super::super::super::Foundation::UNICODE_STRING,
3826     pub Flags: u32,
3827     pub LastStatus: super::super::super::Foundation::NTSTATUS,
3828     pub Expiry: i64,
3829     pub CountOfEntries: u32,
3830     pub Entries: *mut KERB_S4U2PROXY_CACHE_ENTRY_INFO,
3831 }
3832 #[cfg(feature = "Win32_Foundation")]
3833 impl KERB_S4U2PROXY_CRED {}
3834 #[cfg(feature = "Win32_Foundation")]
3835 impl ::std::default::Default for KERB_S4U2PROXY_CRED {
3836     fn default() -> Self {
3837         unsafe { ::std::mem::zeroed() }
3838     }
3839 }
3840 #[cfg(feature = "Win32_Foundation")]
3841 impl ::std::fmt::Debug for KERB_S4U2PROXY_CRED {
3842     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3843         fmt.debug_struct("KERB_S4U2PROXY_CRED").field("UserName", &self.UserName).field("DomainName", &self.DomainName).field("Flags", &self.Flags).field("LastStatus", &self.LastStatus).field("Expiry", &self.Expiry).field("CountOfEntries", &self.CountOfEntries).field("Entries", &self.Entries).finish()
3844     }
3845 }
3846 #[cfg(feature = "Win32_Foundation")]
3847 impl ::std::cmp::PartialEq for KERB_S4U2PROXY_CRED {
3848     fn eq(&self, other: &Self) -> bool {
3849         self.UserName == other.UserName && self.DomainName == other.DomainName && self.Flags == other.Flags && self.LastStatus == other.LastStatus && self.Expiry == other.Expiry && self.CountOfEntries == other.CountOfEntries && self.Entries == other.Entries
3850     }
3851 }
3852 #[cfg(feature = "Win32_Foundation")]
3853 impl ::std::cmp::Eq for KERB_S4U2PROXY_CRED {}
3854 #[cfg(feature = "Win32_Foundation")]
3855 unsafe impl ::windows::runtime::Abi for KERB_S4U2PROXY_CRED {
3856     type Abi = Self;
3857     type DefaultType = Self;
3858 }
3859 pub const KERB_S4U2PROXY_CRED_FLAG_NEGATIVE: u32 = 1u32;
3860 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3861 #[repr(C)]
3862 #[cfg(feature = "Win32_Foundation")]
3863 pub struct KERB_S4U_LOGON {
3864     pub MessageType: KERB_LOGON_SUBMIT_TYPE,
3865     pub Flags: u32,
3866     pub ClientUpn: super::super::super::Foundation::UNICODE_STRING,
3867     pub ClientRealm: super::super::super::Foundation::UNICODE_STRING,
3868 }
3869 #[cfg(feature = "Win32_Foundation")]
3870 impl KERB_S4U_LOGON {}
3871 #[cfg(feature = "Win32_Foundation")]
3872 impl ::std::default::Default for KERB_S4U_LOGON {
3873     fn default() -> Self {
3874         unsafe { ::std::mem::zeroed() }
3875     }
3876 }
3877 #[cfg(feature = "Win32_Foundation")]
3878 impl ::std::fmt::Debug for KERB_S4U_LOGON {
3879     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3880         fmt.debug_struct("KERB_S4U_LOGON").field("MessageType", &self.MessageType).field("Flags", &self.Flags).field("ClientUpn", &self.ClientUpn).field("ClientRealm", &self.ClientRealm).finish()
3881     }
3882 }
3883 #[cfg(feature = "Win32_Foundation")]
3884 impl ::std::cmp::PartialEq for KERB_S4U_LOGON {
3885     fn eq(&self, other: &Self) -> bool {
3886         self.MessageType == other.MessageType && self.Flags == other.Flags && self.ClientUpn == other.ClientUpn && self.ClientRealm == other.ClientRealm
3887     }
3888 }
3889 #[cfg(feature = "Win32_Foundation")]
3890 impl ::std::cmp::Eq for KERB_S4U_LOGON {}
3891 #[cfg(feature = "Win32_Foundation")]
3892 unsafe impl ::windows::runtime::Abi for KERB_S4U_LOGON {
3893     type Abi = Self;
3894     type DefaultType = Self;
3895 }
3896 pub const KERB_S4U_LOGON_FLAG_CHECK_LOGONHOURS: u32 = 2u32;
3897 pub const KERB_S4U_LOGON_FLAG_IDENTIFY: u32 = 8u32;
3898 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3899 #[repr(C)]
3900 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3901 pub struct KERB_SETPASSWORD_EX_REQUEST {
3902     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3903     pub LogonId: super::super::super::Foundation::LUID,
3904     pub CredentialsHandle: super::super::Credentials::SecHandle,
3905     pub Flags: u32,
3906     pub AccountRealm: super::super::super::Foundation::UNICODE_STRING,
3907     pub AccountName: super::super::super::Foundation::UNICODE_STRING,
3908     pub Password: super::super::super::Foundation::UNICODE_STRING,
3909     pub ClientRealm: super::super::super::Foundation::UNICODE_STRING,
3910     pub ClientName: super::super::super::Foundation::UNICODE_STRING,
3911     pub Impersonating: super::super::super::Foundation::BOOLEAN,
3912     pub KdcAddress: super::super::super::Foundation::UNICODE_STRING,
3913     pub KdcAddressType: u32,
3914 }
3915 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3916 impl KERB_SETPASSWORD_EX_REQUEST {}
3917 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3918 impl ::std::default::Default for KERB_SETPASSWORD_EX_REQUEST {
3919     fn default() -> Self {
3920         unsafe { ::std::mem::zeroed() }
3921     }
3922 }
3923 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3924 impl ::std::fmt::Debug for KERB_SETPASSWORD_EX_REQUEST {
3925     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3926         fmt.debug_struct("KERB_SETPASSWORD_EX_REQUEST")
3927             .field("MessageType", &self.MessageType)
3928             .field("LogonId", &self.LogonId)
3929             .field("CredentialsHandle", &self.CredentialsHandle)
3930             .field("Flags", &self.Flags)
3931             .field("AccountRealm", &self.AccountRealm)
3932             .field("AccountName", &self.AccountName)
3933             .field("Password", &self.Password)
3934             .field("ClientRealm", &self.ClientRealm)
3935             .field("ClientName", &self.ClientName)
3936             .field("Impersonating", &self.Impersonating)
3937             .field("KdcAddress", &self.KdcAddress)
3938             .field("KdcAddressType", &self.KdcAddressType)
3939             .finish()
3940     }
3941 }
3942 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3943 impl ::std::cmp::PartialEq for KERB_SETPASSWORD_EX_REQUEST {
3944     fn eq(&self, other: &Self) -> bool {
3945         self.MessageType == other.MessageType && self.LogonId == other.LogonId && self.CredentialsHandle == other.CredentialsHandle && self.Flags == other.Flags && self.AccountRealm == other.AccountRealm && self.AccountName == other.AccountName && self.Password == other.Password && self.ClientRealm == other.ClientRealm && self.ClientName == other.ClientName && self.Impersonating == other.Impersonating && self.KdcAddress == other.KdcAddress && self.KdcAddressType == other.KdcAddressType
3946     }
3947 }
3948 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3949 impl ::std::cmp::Eq for KERB_SETPASSWORD_EX_REQUEST {}
3950 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3951 unsafe impl ::windows::runtime::Abi for KERB_SETPASSWORD_EX_REQUEST {
3952     type Abi = Self;
3953     type DefaultType = Self;
3954 }
3955 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3956 #[repr(C)]
3957 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3958 pub struct KERB_SETPASSWORD_REQUEST {
3959     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
3960     pub LogonId: super::super::super::Foundation::LUID,
3961     pub CredentialsHandle: super::super::Credentials::SecHandle,
3962     pub Flags: u32,
3963     pub DomainName: super::super::super::Foundation::UNICODE_STRING,
3964     pub AccountName: super::super::super::Foundation::UNICODE_STRING,
3965     pub Password: super::super::super::Foundation::UNICODE_STRING,
3966 }
3967 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3968 impl KERB_SETPASSWORD_REQUEST {}
3969 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3970 impl ::std::default::Default for KERB_SETPASSWORD_REQUEST {
3971     fn default() -> Self {
3972         unsafe { ::std::mem::zeroed() }
3973     }
3974 }
3975 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3976 impl ::std::fmt::Debug for KERB_SETPASSWORD_REQUEST {
3977     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3978         fmt.debug_struct("KERB_SETPASSWORD_REQUEST")
3979             .field("MessageType", &self.MessageType)
3980             .field("LogonId", &self.LogonId)
3981             .field("CredentialsHandle", &self.CredentialsHandle)
3982             .field("Flags", &self.Flags)
3983             .field("DomainName", &self.DomainName)
3984             .field("AccountName", &self.AccountName)
3985             .field("Password", &self.Password)
3986             .finish()
3987     }
3988 }
3989 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3990 impl ::std::cmp::PartialEq for KERB_SETPASSWORD_REQUEST {
3991     fn eq(&self, other: &Self) -> bool {
3992         self.MessageType == other.MessageType && self.LogonId == other.LogonId && self.CredentialsHandle == other.CredentialsHandle && self.Flags == other.Flags && self.DomainName == other.DomainName && self.AccountName == other.AccountName && self.Password == other.Password
3993     }
3994 }
3995 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3996 impl ::std::cmp::Eq for KERB_SETPASSWORD_REQUEST {}
3997 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
3998 unsafe impl ::windows::runtime::Abi for KERB_SETPASSWORD_REQUEST {
3999     type Abi = Self;
4000     type DefaultType = Self;
4001 }
4002 pub const KERB_SETPASS_USE_CREDHANDLE: u32 = 2u32;
4003 pub const KERB_SETPASS_USE_LOGONID: u32 = 1u32;
4004 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4005 #[repr(C)]
4006 #[cfg(feature = "Win32_Foundation")]
4007 pub struct KERB_SMART_CARD_LOGON {
4008     pub MessageType: KERB_LOGON_SUBMIT_TYPE,
4009     pub Pin: super::super::super::Foundation::UNICODE_STRING,
4010     pub CspDataLength: u32,
4011     pub CspData: *mut u8,
4012 }
4013 #[cfg(feature = "Win32_Foundation")]
4014 impl KERB_SMART_CARD_LOGON {}
4015 #[cfg(feature = "Win32_Foundation")]
4016 impl ::std::default::Default for KERB_SMART_CARD_LOGON {
4017     fn default() -> Self {
4018         unsafe { ::std::mem::zeroed() }
4019     }
4020 }
4021 #[cfg(feature = "Win32_Foundation")]
4022 impl ::std::fmt::Debug for KERB_SMART_CARD_LOGON {
4023     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4024         fmt.debug_struct("KERB_SMART_CARD_LOGON").field("MessageType", &self.MessageType).field("Pin", &self.Pin).field("CspDataLength", &self.CspDataLength).field("CspData", &self.CspData).finish()
4025     }
4026 }
4027 #[cfg(feature = "Win32_Foundation")]
4028 impl ::std::cmp::PartialEq for KERB_SMART_CARD_LOGON {
4029     fn eq(&self, other: &Self) -> bool {
4030         self.MessageType == other.MessageType && self.Pin == other.Pin && self.CspDataLength == other.CspDataLength && self.CspData == other.CspData
4031     }
4032 }
4033 #[cfg(feature = "Win32_Foundation")]
4034 impl ::std::cmp::Eq for KERB_SMART_CARD_LOGON {}
4035 #[cfg(feature = "Win32_Foundation")]
4036 unsafe impl ::windows::runtime::Abi for KERB_SMART_CARD_LOGON {
4037     type Abi = Self;
4038     type DefaultType = Self;
4039 }
4040 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4041 #[repr(C)]
4042 #[cfg(feature = "Win32_Foundation")]
4043 pub struct KERB_SMART_CARD_PROFILE {
4044     pub Profile: KERB_INTERACTIVE_PROFILE,
4045     pub CertificateSize: u32,
4046     pub CertificateData: *mut u8,
4047 }
4048 #[cfg(feature = "Win32_Foundation")]
4049 impl KERB_SMART_CARD_PROFILE {}
4050 #[cfg(feature = "Win32_Foundation")]
4051 impl ::std::default::Default for KERB_SMART_CARD_PROFILE {
4052     fn default() -> Self {
4053         unsafe { ::std::mem::zeroed() }
4054     }
4055 }
4056 #[cfg(feature = "Win32_Foundation")]
4057 impl ::std::fmt::Debug for KERB_SMART_CARD_PROFILE {
4058     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4059         fmt.debug_struct("KERB_SMART_CARD_PROFILE").field("Profile", &self.Profile).field("CertificateSize", &self.CertificateSize).field("CertificateData", &self.CertificateData).finish()
4060     }
4061 }
4062 #[cfg(feature = "Win32_Foundation")]
4063 impl ::std::cmp::PartialEq for KERB_SMART_CARD_PROFILE {
4064     fn eq(&self, other: &Self) -> bool {
4065         self.Profile == other.Profile && self.CertificateSize == other.CertificateSize && self.CertificateData == other.CertificateData
4066     }
4067 }
4068 #[cfg(feature = "Win32_Foundation")]
4069 impl ::std::cmp::Eq for KERB_SMART_CARD_PROFILE {}
4070 #[cfg(feature = "Win32_Foundation")]
4071 unsafe impl ::windows::runtime::Abi for KERB_SMART_CARD_PROFILE {
4072     type Abi = Self;
4073     type DefaultType = Self;
4074 }
4075 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4076 #[repr(C)]
4077 #[cfg(feature = "Win32_Foundation")]
4078 pub struct KERB_SMART_CARD_UNLOCK_LOGON {
4079     pub Logon: KERB_SMART_CARD_LOGON,
4080     pub LogonId: super::super::super::Foundation::LUID,
4081 }
4082 #[cfg(feature = "Win32_Foundation")]
4083 impl KERB_SMART_CARD_UNLOCK_LOGON {}
4084 #[cfg(feature = "Win32_Foundation")]
4085 impl ::std::default::Default for KERB_SMART_CARD_UNLOCK_LOGON {
4086     fn default() -> Self {
4087         unsafe { ::std::mem::zeroed() }
4088     }
4089 }
4090 #[cfg(feature = "Win32_Foundation")]
4091 impl ::std::fmt::Debug for KERB_SMART_CARD_UNLOCK_LOGON {
4092     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4093         fmt.debug_struct("KERB_SMART_CARD_UNLOCK_LOGON").field("Logon", &self.Logon).field("LogonId", &self.LogonId).finish()
4094     }
4095 }
4096 #[cfg(feature = "Win32_Foundation")]
4097 impl ::std::cmp::PartialEq for KERB_SMART_CARD_UNLOCK_LOGON {
4098     fn eq(&self, other: &Self) -> bool {
4099         self.Logon == other.Logon && self.LogonId == other.LogonId
4100     }
4101 }
4102 #[cfg(feature = "Win32_Foundation")]
4103 impl ::std::cmp::Eq for KERB_SMART_CARD_UNLOCK_LOGON {}
4104 #[cfg(feature = "Win32_Foundation")]
4105 unsafe impl ::windows::runtime::Abi for KERB_SMART_CARD_UNLOCK_LOGON {
4106     type Abi = Self;
4107     type DefaultType = Self;
4108 }
4109 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4110 #[repr(C)]
4111 #[cfg(feature = "Win32_Foundation")]
4112 pub struct KERB_SUBMIT_TKT_REQUEST {
4113     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
4114     pub LogonId: super::super::super::Foundation::LUID,
4115     pub Flags: u32,
4116     pub Key: KERB_CRYPTO_KEY32,
4117     pub KerbCredSize: u32,
4118     pub KerbCredOffset: u32,
4119 }
4120 #[cfg(feature = "Win32_Foundation")]
4121 impl KERB_SUBMIT_TKT_REQUEST {}
4122 #[cfg(feature = "Win32_Foundation")]
4123 impl ::std::default::Default for KERB_SUBMIT_TKT_REQUEST {
4124     fn default() -> Self {
4125         unsafe { ::std::mem::zeroed() }
4126     }
4127 }
4128 #[cfg(feature = "Win32_Foundation")]
4129 impl ::std::fmt::Debug for KERB_SUBMIT_TKT_REQUEST {
4130     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4131         fmt.debug_struct("KERB_SUBMIT_TKT_REQUEST").field("MessageType", &self.MessageType).field("LogonId", &self.LogonId).field("Flags", &self.Flags).field("Key", &self.Key).field("KerbCredSize", &self.KerbCredSize).field("KerbCredOffset", &self.KerbCredOffset).finish()
4132     }
4133 }
4134 #[cfg(feature = "Win32_Foundation")]
4135 impl ::std::cmp::PartialEq for KERB_SUBMIT_TKT_REQUEST {
4136     fn eq(&self, other: &Self) -> bool {
4137         self.MessageType == other.MessageType && self.LogonId == other.LogonId && self.Flags == other.Flags && self.Key == other.Key && self.KerbCredSize == other.KerbCredSize && self.KerbCredOffset == other.KerbCredOffset
4138     }
4139 }
4140 #[cfg(feature = "Win32_Foundation")]
4141 impl ::std::cmp::Eq for KERB_SUBMIT_TKT_REQUEST {}
4142 #[cfg(feature = "Win32_Foundation")]
4143 unsafe impl ::windows::runtime::Abi for KERB_SUBMIT_TKT_REQUEST {
4144     type Abi = Self;
4145     type DefaultType = Self;
4146 }
4147 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4148 #[repr(C)]
4149 #[cfg(feature = "Win32_Foundation")]
4150 pub struct KERB_TICKET_CACHE_INFO {
4151     pub ServerName: super::super::super::Foundation::UNICODE_STRING,
4152     pub RealmName: super::super::super::Foundation::UNICODE_STRING,
4153     pub StartTime: i64,
4154     pub EndTime: i64,
4155     pub RenewTime: i64,
4156     pub EncryptionType: i32,
4157     pub TicketFlags: KERB_TICKET_FLAGS,
4158 }
4159 #[cfg(feature = "Win32_Foundation")]
4160 impl KERB_TICKET_CACHE_INFO {}
4161 #[cfg(feature = "Win32_Foundation")]
4162 impl ::std::default::Default for KERB_TICKET_CACHE_INFO {
4163     fn default() -> Self {
4164         unsafe { ::std::mem::zeroed() }
4165     }
4166 }
4167 #[cfg(feature = "Win32_Foundation")]
4168 impl ::std::fmt::Debug for KERB_TICKET_CACHE_INFO {
4169     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4170         fmt.debug_struct("KERB_TICKET_CACHE_INFO")
4171             .field("ServerName", &self.ServerName)
4172             .field("RealmName", &self.RealmName)
4173             .field("StartTime", &self.StartTime)
4174             .field("EndTime", &self.EndTime)
4175             .field("RenewTime", &self.RenewTime)
4176             .field("EncryptionType", &self.EncryptionType)
4177             .field("TicketFlags", &self.TicketFlags)
4178             .finish()
4179     }
4180 }
4181 #[cfg(feature = "Win32_Foundation")]
4182 impl ::std::cmp::PartialEq for KERB_TICKET_CACHE_INFO {
4183     fn eq(&self, other: &Self) -> bool {
4184         self.ServerName == other.ServerName && self.RealmName == other.RealmName && self.StartTime == other.StartTime && self.EndTime == other.EndTime && self.RenewTime == other.RenewTime && self.EncryptionType == other.EncryptionType && self.TicketFlags == other.TicketFlags
4185     }
4186 }
4187 #[cfg(feature = "Win32_Foundation")]
4188 impl ::std::cmp::Eq for KERB_TICKET_CACHE_INFO {}
4189 #[cfg(feature = "Win32_Foundation")]
4190 unsafe impl ::windows::runtime::Abi for KERB_TICKET_CACHE_INFO {
4191     type Abi = Self;
4192     type DefaultType = Self;
4193 }
4194 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4195 #[repr(C)]
4196 #[cfg(feature = "Win32_Foundation")]
4197 pub struct KERB_TICKET_CACHE_INFO_EX {
4198     pub ClientName: super::super::super::Foundation::UNICODE_STRING,
4199     pub ClientRealm: super::super::super::Foundation::UNICODE_STRING,
4200     pub ServerName: super::super::super::Foundation::UNICODE_STRING,
4201     pub ServerRealm: super::super::super::Foundation::UNICODE_STRING,
4202     pub StartTime: i64,
4203     pub EndTime: i64,
4204     pub RenewTime: i64,
4205     pub EncryptionType: i32,
4206     pub TicketFlags: u32,
4207 }
4208 #[cfg(feature = "Win32_Foundation")]
4209 impl KERB_TICKET_CACHE_INFO_EX {}
4210 #[cfg(feature = "Win32_Foundation")]
4211 impl ::std::default::Default for KERB_TICKET_CACHE_INFO_EX {
4212     fn default() -> Self {
4213         unsafe { ::std::mem::zeroed() }
4214     }
4215 }
4216 #[cfg(feature = "Win32_Foundation")]
4217 impl ::std::fmt::Debug for KERB_TICKET_CACHE_INFO_EX {
4218     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4219         fmt.debug_struct("KERB_TICKET_CACHE_INFO_EX")
4220             .field("ClientName", &self.ClientName)
4221             .field("ClientRealm", &self.ClientRealm)
4222             .field("ServerName", &self.ServerName)
4223             .field("ServerRealm", &self.ServerRealm)
4224             .field("StartTime", &self.StartTime)
4225             .field("EndTime", &self.EndTime)
4226             .field("RenewTime", &self.RenewTime)
4227             .field("EncryptionType", &self.EncryptionType)
4228             .field("TicketFlags", &self.TicketFlags)
4229             .finish()
4230     }
4231 }
4232 #[cfg(feature = "Win32_Foundation")]
4233 impl ::std::cmp::PartialEq for KERB_TICKET_CACHE_INFO_EX {
4234     fn eq(&self, other: &Self) -> bool {
4235         self.ClientName == other.ClientName && self.ClientRealm == other.ClientRealm && self.ServerName == other.ServerName && self.ServerRealm == other.ServerRealm && self.StartTime == other.StartTime && self.EndTime == other.EndTime && self.RenewTime == other.RenewTime && self.EncryptionType == other.EncryptionType && self.TicketFlags == other.TicketFlags
4236     }
4237 }
4238 #[cfg(feature = "Win32_Foundation")]
4239 impl ::std::cmp::Eq for KERB_TICKET_CACHE_INFO_EX {}
4240 #[cfg(feature = "Win32_Foundation")]
4241 unsafe impl ::windows::runtime::Abi for KERB_TICKET_CACHE_INFO_EX {
4242     type Abi = Self;
4243     type DefaultType = Self;
4244 }
4245 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4246 #[repr(C)]
4247 #[cfg(feature = "Win32_Foundation")]
4248 pub struct KERB_TICKET_CACHE_INFO_EX2 {
4249     pub ClientName: super::super::super::Foundation::UNICODE_STRING,
4250     pub ClientRealm: super::super::super::Foundation::UNICODE_STRING,
4251     pub ServerName: super::super::super::Foundation::UNICODE_STRING,
4252     pub ServerRealm: super::super::super::Foundation::UNICODE_STRING,
4253     pub StartTime: i64,
4254     pub EndTime: i64,
4255     pub RenewTime: i64,
4256     pub EncryptionType: i32,
4257     pub TicketFlags: u32,
4258     pub SessionKeyType: u32,
4259     pub BranchId: u32,
4260 }
4261 #[cfg(feature = "Win32_Foundation")]
4262 impl KERB_TICKET_CACHE_INFO_EX2 {}
4263 #[cfg(feature = "Win32_Foundation")]
4264 impl ::std::default::Default for KERB_TICKET_CACHE_INFO_EX2 {
4265     fn default() -> Self {
4266         unsafe { ::std::mem::zeroed() }
4267     }
4268 }
4269 #[cfg(feature = "Win32_Foundation")]
4270 impl ::std::fmt::Debug for KERB_TICKET_CACHE_INFO_EX2 {
4271     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4272         fmt.debug_struct("KERB_TICKET_CACHE_INFO_EX2")
4273             .field("ClientName", &self.ClientName)
4274             .field("ClientRealm", &self.ClientRealm)
4275             .field("ServerName", &self.ServerName)
4276             .field("ServerRealm", &self.ServerRealm)
4277             .field("StartTime", &self.StartTime)
4278             .field("EndTime", &self.EndTime)
4279             .field("RenewTime", &self.RenewTime)
4280             .field("EncryptionType", &self.EncryptionType)
4281             .field("TicketFlags", &self.TicketFlags)
4282             .field("SessionKeyType", &self.SessionKeyType)
4283             .field("BranchId", &self.BranchId)
4284             .finish()
4285     }
4286 }
4287 #[cfg(feature = "Win32_Foundation")]
4288 impl ::std::cmp::PartialEq for KERB_TICKET_CACHE_INFO_EX2 {
4289     fn eq(&self, other: &Self) -> bool {
4290         self.ClientName == other.ClientName && self.ClientRealm == other.ClientRealm && self.ServerName == other.ServerName && self.ServerRealm == other.ServerRealm && self.StartTime == other.StartTime && self.EndTime == other.EndTime && self.RenewTime == other.RenewTime && self.EncryptionType == other.EncryptionType && self.TicketFlags == other.TicketFlags && self.SessionKeyType == other.SessionKeyType && self.BranchId == other.BranchId
4291     }
4292 }
4293 #[cfg(feature = "Win32_Foundation")]
4294 impl ::std::cmp::Eq for KERB_TICKET_CACHE_INFO_EX2 {}
4295 #[cfg(feature = "Win32_Foundation")]
4296 unsafe impl ::windows::runtime::Abi for KERB_TICKET_CACHE_INFO_EX2 {
4297     type Abi = Self;
4298     type DefaultType = Self;
4299 }
4300 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4301 #[repr(C)]
4302 #[cfg(feature = "Win32_Foundation")]
4303 pub struct KERB_TICKET_CACHE_INFO_EX3 {
4304     pub ClientName: super::super::super::Foundation::UNICODE_STRING,
4305     pub ClientRealm: super::super::super::Foundation::UNICODE_STRING,
4306     pub ServerName: super::super::super::Foundation::UNICODE_STRING,
4307     pub ServerRealm: super::super::super::Foundation::UNICODE_STRING,
4308     pub StartTime: i64,
4309     pub EndTime: i64,
4310     pub RenewTime: i64,
4311     pub EncryptionType: i32,
4312     pub TicketFlags: u32,
4313     pub SessionKeyType: u32,
4314     pub BranchId: u32,
4315     pub CacheFlags: u32,
4316     pub KdcCalled: super::super::super::Foundation::UNICODE_STRING,
4317 }
4318 #[cfg(feature = "Win32_Foundation")]
4319 impl KERB_TICKET_CACHE_INFO_EX3 {}
4320 #[cfg(feature = "Win32_Foundation")]
4321 impl ::std::default::Default for KERB_TICKET_CACHE_INFO_EX3 {
4322     fn default() -> Self {
4323         unsafe { ::std::mem::zeroed() }
4324     }
4325 }
4326 #[cfg(feature = "Win32_Foundation")]
4327 impl ::std::fmt::Debug for KERB_TICKET_CACHE_INFO_EX3 {
4328     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4329         fmt.debug_struct("KERB_TICKET_CACHE_INFO_EX3")
4330             .field("ClientName", &self.ClientName)
4331             .field("ClientRealm", &self.ClientRealm)
4332             .field("ServerName", &self.ServerName)
4333             .field("ServerRealm", &self.ServerRealm)
4334             .field("StartTime", &self.StartTime)
4335             .field("EndTime", &self.EndTime)
4336             .field("RenewTime", &self.RenewTime)
4337             .field("EncryptionType", &self.EncryptionType)
4338             .field("TicketFlags", &self.TicketFlags)
4339             .field("SessionKeyType", &self.SessionKeyType)
4340             .field("BranchId", &self.BranchId)
4341             .field("CacheFlags", &self.CacheFlags)
4342             .field("KdcCalled", &self.KdcCalled)
4343             .finish()
4344     }
4345 }
4346 #[cfg(feature = "Win32_Foundation")]
4347 impl ::std::cmp::PartialEq for KERB_TICKET_CACHE_INFO_EX3 {
4348     fn eq(&self, other: &Self) -> bool {
4349         self.ClientName == other.ClientName
4350             && self.ClientRealm == other.ClientRealm
4351             && self.ServerName == other.ServerName
4352             && self.ServerRealm == other.ServerRealm
4353             && self.StartTime == other.StartTime
4354             && self.EndTime == other.EndTime
4355             && self.RenewTime == other.RenewTime
4356             && self.EncryptionType == other.EncryptionType
4357             && self.TicketFlags == other.TicketFlags
4358             && self.SessionKeyType == other.SessionKeyType
4359             && self.BranchId == other.BranchId
4360             && self.CacheFlags == other.CacheFlags
4361             && self.KdcCalled == other.KdcCalled
4362     }
4363 }
4364 #[cfg(feature = "Win32_Foundation")]
4365 impl ::std::cmp::Eq for KERB_TICKET_CACHE_INFO_EX3 {}
4366 #[cfg(feature = "Win32_Foundation")]
4367 unsafe impl ::windows::runtime::Abi for KERB_TICKET_CACHE_INFO_EX3 {
4368     type Abi = Self;
4369     type DefaultType = Self;
4370 }
4371 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4372 #[repr(transparent)]
4373 pub struct KERB_TICKET_FLAGS(pub u32);
4374 pub const KERB_TICKET_FLAGS_forwardable: KERB_TICKET_FLAGS = KERB_TICKET_FLAGS(1073741824u32);
4375 pub const KERB_TICKET_FLAGS_forwarded: KERB_TICKET_FLAGS = KERB_TICKET_FLAGS(536870912u32);
4376 pub const KERB_TICKET_FLAGS_hw_authent: KERB_TICKET_FLAGS = KERB_TICKET_FLAGS(1048576u32);
4377 pub const KERB_TICKET_FLAGS_initial: KERB_TICKET_FLAGS = KERB_TICKET_FLAGS(4194304u32);
4378 pub const KERB_TICKET_FLAGS_invalid: KERB_TICKET_FLAGS = KERB_TICKET_FLAGS(16777216u32);
4379 pub const KERB_TICKET_FLAGS_may_postdate: KERB_TICKET_FLAGS = KERB_TICKET_FLAGS(67108864u32);
4380 pub const KERB_TICKET_FLAGS_ok_as_delegate: KERB_TICKET_FLAGS = KERB_TICKET_FLAGS(262144u32);
4381 pub const KERB_TICKET_FLAGS_postdated: KERB_TICKET_FLAGS = KERB_TICKET_FLAGS(33554432u32);
4382 pub const KERB_TICKET_FLAGS_pre_authent: KERB_TICKET_FLAGS = KERB_TICKET_FLAGS(2097152u32);
4383 pub const KERB_TICKET_FLAGS_proxiable: KERB_TICKET_FLAGS = KERB_TICKET_FLAGS(268435456u32);
4384 pub const KERB_TICKET_FLAGS_proxy: KERB_TICKET_FLAGS = KERB_TICKET_FLAGS(134217728u32);
4385 pub const KERB_TICKET_FLAGS_renewable: KERB_TICKET_FLAGS = KERB_TICKET_FLAGS(8388608u32);
4386 pub const KERB_TICKET_FLAGS_reserved: KERB_TICKET_FLAGS = KERB_TICKET_FLAGS(2147483648u32);
4387 pub const KERB_TICKET_FLAGS_reserved1: KERB_TICKET_FLAGS = KERB_TICKET_FLAGS(1u32);
4388 impl ::std::convert::From<u32> for KERB_TICKET_FLAGS {
4389     fn from(value: u32) -> Self {
4390         Self(value)
4391     }
4392 }
4393 unsafe impl ::windows::runtime::Abi for KERB_TICKET_FLAGS {
4394     type Abi = Self;
4395     type DefaultType = Self;
4396 }
4397 impl ::std::ops::BitOr for KERB_TICKET_FLAGS {
4398     type Output = Self;
4399     fn bitor(self, rhs: Self) -> Self {
4400         Self(self.0 | rhs.0)
4401     }
4402 }
4403 impl ::std::ops::BitAnd for KERB_TICKET_FLAGS {
4404     type Output = Self;
4405     fn bitand(self, rhs: Self) -> Self {
4406         Self(self.0 & rhs.0)
4407     }
4408 }
4409 impl ::std::ops::BitOrAssign for KERB_TICKET_FLAGS {
4410     fn bitor_assign(&mut self, rhs: Self) {
4411         self.0.bitor_assign(rhs.0)
4412     }
4413 }
4414 impl ::std::ops::BitAndAssign for KERB_TICKET_FLAGS {
4415     fn bitand_assign(&mut self, rhs: Self) {
4416         self.0.bitand_assign(rhs.0)
4417     }
4418 }
4419 impl ::std::ops::Not for KERB_TICKET_FLAGS {
4420     type Output = Self;
4421     fn not(self) -> Self {
4422         Self(self.0.not())
4423     }
4424 }
4425 pub const KERB_TICKET_FLAGS_cname_in_pa_data: u32 = 262144u32;
4426 pub const KERB_TICKET_FLAGS_enc_pa_rep: u32 = 65536u32;
4427 pub const KERB_TICKET_FLAGS_name_canonicalize: u32 = 65536u32;
4428 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4429 #[repr(C)]
4430 pub struct KERB_TICKET_LOGON {
4431     pub MessageType: KERB_LOGON_SUBMIT_TYPE,
4432     pub Flags: u32,
4433     pub ServiceTicketLength: u32,
4434     pub TicketGrantingTicketLength: u32,
4435     pub ServiceTicket: *mut u8,
4436     pub TicketGrantingTicket: *mut u8,
4437 }
4438 impl KERB_TICKET_LOGON {}
4439 impl ::std::default::Default for KERB_TICKET_LOGON {
4440     fn default() -> Self {
4441         unsafe { ::std::mem::zeroed() }
4442     }
4443 }
4444 impl ::std::fmt::Debug for KERB_TICKET_LOGON {
4445     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4446         fmt.debug_struct("KERB_TICKET_LOGON")
4447             .field("MessageType", &self.MessageType)
4448             .field("Flags", &self.Flags)
4449             .field("ServiceTicketLength", &self.ServiceTicketLength)
4450             .field("TicketGrantingTicketLength", &self.TicketGrantingTicketLength)
4451             .field("ServiceTicket", &self.ServiceTicket)
4452             .field("TicketGrantingTicket", &self.TicketGrantingTicket)
4453             .finish()
4454     }
4455 }
4456 impl ::std::cmp::PartialEq for KERB_TICKET_LOGON {
4457     fn eq(&self, other: &Self) -> bool {
4458         self.MessageType == other.MessageType && self.Flags == other.Flags && self.ServiceTicketLength == other.ServiceTicketLength && self.TicketGrantingTicketLength == other.TicketGrantingTicketLength && self.ServiceTicket == other.ServiceTicket && self.TicketGrantingTicket == other.TicketGrantingTicket
4459     }
4460 }
4461 impl ::std::cmp::Eq for KERB_TICKET_LOGON {}
4462 unsafe impl ::windows::runtime::Abi for KERB_TICKET_LOGON {
4463     type Abi = Self;
4464     type DefaultType = Self;
4465 }
4466 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4467 #[repr(C)]
4468 #[cfg(feature = "Win32_Foundation")]
4469 pub struct KERB_TICKET_PROFILE {
4470     pub Profile: KERB_INTERACTIVE_PROFILE,
4471     pub SessionKey: KERB_CRYPTO_KEY,
4472 }
4473 #[cfg(feature = "Win32_Foundation")]
4474 impl KERB_TICKET_PROFILE {}
4475 #[cfg(feature = "Win32_Foundation")]
4476 impl ::std::default::Default for KERB_TICKET_PROFILE {
4477     fn default() -> Self {
4478         unsafe { ::std::mem::zeroed() }
4479     }
4480 }
4481 #[cfg(feature = "Win32_Foundation")]
4482 impl ::std::fmt::Debug for KERB_TICKET_PROFILE {
4483     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4484         fmt.debug_struct("KERB_TICKET_PROFILE").field("Profile", &self.Profile).field("SessionKey", &self.SessionKey).finish()
4485     }
4486 }
4487 #[cfg(feature = "Win32_Foundation")]
4488 impl ::std::cmp::PartialEq for KERB_TICKET_PROFILE {
4489     fn eq(&self, other: &Self) -> bool {
4490         self.Profile == other.Profile && self.SessionKey == other.SessionKey
4491     }
4492 }
4493 #[cfg(feature = "Win32_Foundation")]
4494 impl ::std::cmp::Eq for KERB_TICKET_PROFILE {}
4495 #[cfg(feature = "Win32_Foundation")]
4496 unsafe impl ::windows::runtime::Abi for KERB_TICKET_PROFILE {
4497     type Abi = Self;
4498     type DefaultType = Self;
4499 }
4500 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4501 #[repr(C)]
4502 #[cfg(feature = "Win32_Foundation")]
4503 pub struct KERB_TICKET_UNLOCK_LOGON {
4504     pub Logon: KERB_TICKET_LOGON,
4505     pub LogonId: super::super::super::Foundation::LUID,
4506 }
4507 #[cfg(feature = "Win32_Foundation")]
4508 impl KERB_TICKET_UNLOCK_LOGON {}
4509 #[cfg(feature = "Win32_Foundation")]
4510 impl ::std::default::Default for KERB_TICKET_UNLOCK_LOGON {
4511     fn default() -> Self {
4512         unsafe { ::std::mem::zeroed() }
4513     }
4514 }
4515 #[cfg(feature = "Win32_Foundation")]
4516 impl ::std::fmt::Debug for KERB_TICKET_UNLOCK_LOGON {
4517     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4518         fmt.debug_struct("KERB_TICKET_UNLOCK_LOGON").field("Logon", &self.Logon).field("LogonId", &self.LogonId).finish()
4519     }
4520 }
4521 #[cfg(feature = "Win32_Foundation")]
4522 impl ::std::cmp::PartialEq for KERB_TICKET_UNLOCK_LOGON {
4523     fn eq(&self, other: &Self) -> bool {
4524         self.Logon == other.Logon && self.LogonId == other.LogonId
4525     }
4526 }
4527 #[cfg(feature = "Win32_Foundation")]
4528 impl ::std::cmp::Eq for KERB_TICKET_UNLOCK_LOGON {}
4529 #[cfg(feature = "Win32_Foundation")]
4530 unsafe impl ::windows::runtime::Abi for KERB_TICKET_UNLOCK_LOGON {
4531     type Abi = Self;
4532     type DefaultType = Self;
4533 }
4534 pub const KERB_TRANSFER_CRED_CLEANUP_CREDENTIALS: u32 = 2u32;
4535 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4536 #[repr(C)]
4537 #[cfg(feature = "Win32_Foundation")]
4538 pub struct KERB_TRANSFER_CRED_REQUEST {
4539     pub MessageType: KERB_PROTOCOL_MESSAGE_TYPE,
4540     pub OriginLogonId: super::super::super::Foundation::LUID,
4541     pub DestinationLogonId: super::super::super::Foundation::LUID,
4542     pub Flags: u32,
4543 }
4544 #[cfg(feature = "Win32_Foundation")]
4545 impl KERB_TRANSFER_CRED_REQUEST {}
4546 #[cfg(feature = "Win32_Foundation")]
4547 impl ::std::default::Default for KERB_TRANSFER_CRED_REQUEST {
4548     fn default() -> Self {
4549         unsafe { ::std::mem::zeroed() }
4550     }
4551 }
4552 #[cfg(feature = "Win32_Foundation")]
4553 impl ::std::fmt::Debug for KERB_TRANSFER_CRED_REQUEST {
4554     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4555         fmt.debug_struct("KERB_TRANSFER_CRED_REQUEST").field("MessageType", &self.MessageType).field("OriginLogonId", &self.OriginLogonId).field("DestinationLogonId", &self.DestinationLogonId).field("Flags", &self.Flags).finish()
4556     }
4557 }
4558 #[cfg(feature = "Win32_Foundation")]
4559 impl ::std::cmp::PartialEq for KERB_TRANSFER_CRED_REQUEST {
4560     fn eq(&self, other: &Self) -> bool {
4561         self.MessageType == other.MessageType && self.OriginLogonId == other.OriginLogonId && self.DestinationLogonId == other.DestinationLogonId && self.Flags == other.Flags
4562     }
4563 }
4564 #[cfg(feature = "Win32_Foundation")]
4565 impl ::std::cmp::Eq for KERB_TRANSFER_CRED_REQUEST {}
4566 #[cfg(feature = "Win32_Foundation")]
4567 unsafe impl ::windows::runtime::Abi for KERB_TRANSFER_CRED_REQUEST {
4568     type Abi = Self;
4569     type DefaultType = Self;
4570 }
4571 pub const KERB_TRANSFER_CRED_WITH_TICKETS: u32 = 1u32;
4572 pub const KERB_USE_DEFAULT_TICKET_FLAGS: u32 = 0u32;
4573 pub const KERB_WRAP_NO_ENCRYPT: u32 = 2147483649u32;
4574 pub const KERN_CONTEXT_CERT_INFO_V1: u32 = 0u32;
4575 pub const KRB_NT_ENTERPRISE_PRINCIPAL: u32 = 10u32;
4576 pub const KRB_NT_ENT_PRINCIPAL_AND_ID: i32 = -130i32;
4577 pub const KRB_NT_MS_BRANCH_ID: i32 = -133i32;
4578 pub const KRB_NT_MS_PRINCIPAL: i32 = -128i32;
4579 pub const KRB_NT_MS_PRINCIPAL_AND_ID: i32 = -129i32;
4580 pub const KRB_NT_PRINCIPAL: u32 = 1u32;
4581 pub const KRB_NT_PRINCIPAL_AND_ID: i32 = -131i32;
4582 pub const KRB_NT_SRV_HST: u32 = 3u32;
4583 pub const KRB_NT_SRV_INST: u32 = 2u32;
4584 pub const KRB_NT_SRV_INST_AND_ID: i32 = -132i32;
4585 pub const KRB_NT_SRV_XHST: u32 = 4u32;
4586 pub const KRB_NT_UID: u32 = 5u32;
4587 pub const KRB_NT_UNKNOWN: u32 = 0u32;
4588 pub const KRB_NT_WELLKNOWN: u32 = 11u32;
4589 pub const KRB_NT_X500_PRINCIPAL: u32 = 6u32;
4590 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4591 #[repr(transparent)]
4592 pub struct KSEC_CONTEXT_TYPE(pub i32);
4593 pub const KSecPaged: KSEC_CONTEXT_TYPE = KSEC_CONTEXT_TYPE(0i32);
4594 pub const KSecNonPaged: KSEC_CONTEXT_TYPE = KSEC_CONTEXT_TYPE(1i32);
4595 impl ::std::convert::From<i32> for KSEC_CONTEXT_TYPE {
4596     fn from(value: i32) -> Self {
4597         Self(value)
4598     }
4599 }
4600 unsafe impl ::windows::runtime::Abi for KSEC_CONTEXT_TYPE {
4601     type Abi = Self;
4602     type DefaultType = Self;
4603 }
4604 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4605 #[repr(C)]
4606 #[cfg(feature = "Win32_System_Kernel")]
4607 pub struct KSEC_LIST_ENTRY {
4608     pub List: super::super::super::System::Kernel::LIST_ENTRY,
4609     pub RefCount: i32,
4610     pub Signature: u32,
4611     pub OwningList: *mut ::std::ffi::c_void,
4612     pub Reserved: *mut ::std::ffi::c_void,
4613 }
4614 #[cfg(feature = "Win32_System_Kernel")]
4615 impl KSEC_LIST_ENTRY {}
4616 #[cfg(feature = "Win32_System_Kernel")]
4617 impl ::std::default::Default for KSEC_LIST_ENTRY {
4618     fn default() -> Self {
4619         unsafe { ::std::mem::zeroed() }
4620     }
4621 }
4622 #[cfg(feature = "Win32_System_Kernel")]
4623 impl ::std::fmt::Debug for KSEC_LIST_ENTRY {
4624     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4625         fmt.debug_struct("KSEC_LIST_ENTRY").field("List", &self.List).field("RefCount", &self.RefCount).field("Signature", &self.Signature).field("OwningList", &self.OwningList).field("Reserved", &self.Reserved).finish()
4626     }
4627 }
4628 #[cfg(feature = "Win32_System_Kernel")]
4629 impl ::std::cmp::PartialEq for KSEC_LIST_ENTRY {
4630     fn eq(&self, other: &Self) -> bool {
4631         self.List == other.List && self.RefCount == other.RefCount && self.Signature == other.Signature && self.OwningList == other.OwningList && self.Reserved == other.Reserved
4632     }
4633 }
4634 #[cfg(feature = "Win32_System_Kernel")]
4635 impl ::std::cmp::Eq for KSEC_LIST_ENTRY {}
4636 #[cfg(feature = "Win32_System_Kernel")]
4637 unsafe impl ::windows::runtime::Abi for KSEC_LIST_ENTRY {
4638     type Abi = Self;
4639     type DefaultType = Self;
4640 }
4641 #[cfg(feature = "Win32_Foundation")]
4642 pub type KspCompleteTokenFn = unsafe extern "system" fn(contextid: usize, token: *const SecBufferDesc) -> super::super::super::Foundation::NTSTATUS;
4643 #[cfg(feature = "Win32_Foundation")]
4644 pub type KspDeleteContextFn = unsafe extern "system" fn(contextid: usize, lsacontextid: *mut usize) -> super::super::super::Foundation::NTSTATUS;
4645 #[cfg(feature = "Win32_Foundation")]
4646 pub type KspGetTokenFn = unsafe extern "system" fn(contextid: usize, impersonationtoken: *mut super::super::super::Foundation::HANDLE, rawtoken: *mut *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
4647 #[cfg(feature = "Win32_Foundation")]
4648 pub type KspInitContextFn = unsafe extern "system" fn(contextid: usize, contextdata: *const SecBuffer, newcontextid: *mut usize) -> super::super::super::Foundation::NTSTATUS;
4649 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
4650 pub type KspInitPackageFn = unsafe extern "system" fn(functiontable: *const ::std::mem::ManuallyDrop<SECPKG_KERNEL_FUNCTIONS>) -> super::super::super::Foundation::NTSTATUS;
4651 #[cfg(feature = "Win32_Foundation")]
4652 pub type KspMakeSignatureFn = unsafe extern "system" fn(contextid: usize, fqop: u32, message: *const SecBufferDesc, messageseqno: u32) -> super::super::super::Foundation::NTSTATUS;
4653 #[cfg(feature = "Win32_Foundation")]
4654 pub type KspMapHandleFn = unsafe extern "system" fn(contextid: usize, lsacontextid: *mut usize) -> super::super::super::Foundation::NTSTATUS;
4655 #[cfg(feature = "Win32_Foundation")]
4656 pub type KspQueryAttributesFn = unsafe extern "system" fn(contextid: usize, attribute: u32, buffer: *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
4657 #[cfg(feature = "Win32_Foundation")]
4658 pub type KspSealMessageFn = unsafe extern "system" fn(contextid: usize, fqop: u32, message: *const SecBufferDesc, messageseqno: u32) -> super::super::super::Foundation::NTSTATUS;
4659 #[cfg(feature = "Win32_Foundation")]
4660 pub type KspSerializeAuthDataFn = unsafe extern "system" fn(pvauthdata: *const ::std::ffi::c_void, size: *mut u32, serializeddata: *mut *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
4661 #[cfg(feature = "Win32_Foundation")]
4662 pub type KspSetPagingModeFn = unsafe extern "system" fn(pagingmode: super::super::super::Foundation::BOOLEAN) -> super::super::super::Foundation::NTSTATUS;
4663 #[cfg(feature = "Win32_Foundation")]
4664 pub type KspUnsealMessageFn = unsafe extern "system" fn(contextid: usize, message: *const SecBufferDesc, messageseqno: u32, pfqop: *mut u32) -> super::super::super::Foundation::NTSTATUS;
4665 #[cfg(feature = "Win32_Foundation")]
4666 pub type KspVerifySignatureFn = unsafe extern "system" fn(contextid: usize, message: *const SecBufferDesc, messageseqno: u32, pfqop: *mut u32) -> super::super::super::Foundation::NTSTATUS;
4667 pub const LCRED_CRED_EXISTS: u32 = 1u32;
4668 pub const LCRED_STATUS_NOCRED: u32 = 0u32;
4669 pub const LCRED_STATUS_UNKNOWN_ISSUER: u32 = 2u32;
4670 pub const LOGON_GRACE_LOGON: u32 = 16777216u32;
4671 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4672 #[repr(C)]
4673 pub struct LOGON_HOURS {
4674     pub UnitsPerWeek: u16,
4675     pub LogonHours: *mut u8,
4676 }
4677 impl LOGON_HOURS {}
4678 impl ::std::default::Default for LOGON_HOURS {
4679     fn default() -> Self {
4680         unsafe { ::std::mem::zeroed() }
4681     }
4682 }
4683 impl ::std::fmt::Debug for LOGON_HOURS {
4684     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4685         fmt.debug_struct("LOGON_HOURS").field("UnitsPerWeek", &self.UnitsPerWeek).field("LogonHours", &self.LogonHours).finish()
4686     }
4687 }
4688 impl ::std::cmp::PartialEq for LOGON_HOURS {
4689     fn eq(&self, other: &Self) -> bool {
4690         self.UnitsPerWeek == other.UnitsPerWeek && self.LogonHours == other.LogonHours
4691     }
4692 }
4693 impl ::std::cmp::Eq for LOGON_HOURS {}
4694 unsafe impl ::windows::runtime::Abi for LOGON_HOURS {
4695     type Abi = Self;
4696     type DefaultType = Self;
4697 }
4698 pub const LOGON_LM_V2: u32 = 4096u32;
4699 pub const LOGON_MANAGED_SERVICE: u32 = 524288u32;
4700 pub const LOGON_NO_ELEVATION: u32 = 262144u32;
4701 pub const LOGON_NO_OPTIMIZED: u32 = 131072u32;
4702 pub const LOGON_NTLMV2_ENABLED: u32 = 256u32;
4703 pub const LOGON_NTLM_V2: u32 = 8192u32;
4704 pub const LOGON_NT_V2: u32 = 2048u32;
4705 pub const LOGON_OPTIMIZED: u32 = 16384u32;
4706 pub const LOGON_PKINIT: u32 = 65536u32;
4707 pub const LOGON_WINLOGON: u32 = 32768u32;
4708 pub const LOOKUP_TRANSLATE_NAMES: u32 = 2048u32;
4709 pub const LOOKUP_VIEW_LOCAL_INFORMATION: u32 = 1u32;
4710 pub const LSASETCAPS_RELOAD_FLAG: u32 = 1u32;
4711 pub const LSASETCAPS_VALID_FLAG_MASK: u32 = 1u32;
4712 #[cfg(feature = "Win32_Foundation")]
4713 pub type LSA_AP_POST_LOGON_USER = unsafe extern "system" fn(postlogonuserinfo: *const SECPKG_POST_LOGON_USER_INFO) -> super::super::super::Foundation::NTSTATUS;
4714 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4715 #[repr(C)]
4716 pub struct LSA_AUTH_INFORMATION {
4717     pub LastUpdateTime: i64,
4718     pub AuthType: LSA_AUTH_INFORMATION_AUTH_TYPE,
4719     pub AuthInfoLength: u32,
4720     pub AuthInfo: *mut u8,
4721 }
4722 impl LSA_AUTH_INFORMATION {}
4723 impl ::std::default::Default for LSA_AUTH_INFORMATION {
4724     fn default() -> Self {
4725         unsafe { ::std::mem::zeroed() }
4726     }
4727 }
4728 impl ::std::fmt::Debug for LSA_AUTH_INFORMATION {
4729     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4730         fmt.debug_struct("LSA_AUTH_INFORMATION").field("LastUpdateTime", &self.LastUpdateTime).field("AuthType", &self.AuthType).field("AuthInfoLength", &self.AuthInfoLength).field("AuthInfo", &self.AuthInfo).finish()
4731     }
4732 }
4733 impl ::std::cmp::PartialEq for LSA_AUTH_INFORMATION {
4734     fn eq(&self, other: &Self) -> bool {
4735         self.LastUpdateTime == other.LastUpdateTime && self.AuthType == other.AuthType && self.AuthInfoLength == other.AuthInfoLength && self.AuthInfo == other.AuthInfo
4736     }
4737 }
4738 impl ::std::cmp::Eq for LSA_AUTH_INFORMATION {}
4739 unsafe impl ::windows::runtime::Abi for LSA_AUTH_INFORMATION {
4740     type Abi = Self;
4741     type DefaultType = Self;
4742 }
4743 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4744 #[repr(transparent)]
4745 pub struct LSA_AUTH_INFORMATION_AUTH_TYPE(pub u32);
4746 pub const TRUST_AUTH_TYPE_NONE: LSA_AUTH_INFORMATION_AUTH_TYPE = LSA_AUTH_INFORMATION_AUTH_TYPE(0u32);
4747 pub const TRUST_AUTH_TYPE_NT4OWF: LSA_AUTH_INFORMATION_AUTH_TYPE = LSA_AUTH_INFORMATION_AUTH_TYPE(1u32);
4748 pub const TRUST_AUTH_TYPE_CLEAR: LSA_AUTH_INFORMATION_AUTH_TYPE = LSA_AUTH_INFORMATION_AUTH_TYPE(2u32);
4749 pub const TRUST_AUTH_TYPE_VERSION: LSA_AUTH_INFORMATION_AUTH_TYPE = LSA_AUTH_INFORMATION_AUTH_TYPE(3u32);
4750 impl ::std::convert::From<u32> for LSA_AUTH_INFORMATION_AUTH_TYPE {
4751     fn from(value: u32) -> Self {
4752         Self(value)
4753     }
4754 }
4755 unsafe impl ::windows::runtime::Abi for LSA_AUTH_INFORMATION_AUTH_TYPE {
4756     type Abi = Self;
4757     type DefaultType = Self;
4758 }
4759 impl ::std::ops::BitOr for LSA_AUTH_INFORMATION_AUTH_TYPE {
4760     type Output = Self;
4761     fn bitor(self, rhs: Self) -> Self {
4762         Self(self.0 | rhs.0)
4763     }
4764 }
4765 impl ::std::ops::BitAnd for LSA_AUTH_INFORMATION_AUTH_TYPE {
4766     type Output = Self;
4767     fn bitand(self, rhs: Self) -> Self {
4768         Self(self.0 & rhs.0)
4769     }
4770 }
4771 impl ::std::ops::BitOrAssign for LSA_AUTH_INFORMATION_AUTH_TYPE {
4772     fn bitor_assign(&mut self, rhs: Self) {
4773         self.0.bitor_assign(rhs.0)
4774     }
4775 }
4776 impl ::std::ops::BitAndAssign for LSA_AUTH_INFORMATION_AUTH_TYPE {
4777     fn bitand_assign(&mut self, rhs: Self) {
4778         self.0.bitand_assign(rhs.0)
4779     }
4780 }
4781 impl ::std::ops::Not for LSA_AUTH_INFORMATION_AUTH_TYPE {
4782     type Output = Self;
4783     fn not(self) -> Self {
4784         Self(self.0.not())
4785     }
4786 }
4787 pub const LSA_CALL_LICENSE_SERVER: u32 = 2147483648u32;
4788 #[derive(:: std :: clone :: Clone)]
4789 #[repr(C)]
4790 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
4791 pub struct LSA_DISPATCH_TABLE {
4792     pub CreateLogonSession: ::std::option::Option<PLSA_CREATE_LOGON_SESSION>,
4793     pub DeleteLogonSession: ::std::option::Option<PLSA_DELETE_LOGON_SESSION>,
4794     pub AddCredential: ::std::option::Option<PLSA_ADD_CREDENTIAL>,
4795     pub GetCredentials: ::std::option::Option<PLSA_GET_CREDENTIALS>,
4796     pub DeleteCredential: ::std::option::Option<PLSA_DELETE_CREDENTIAL>,
4797     pub AllocateLsaHeap: ::std::option::Option<PLSA_ALLOCATE_LSA_HEAP>,
4798     pub FreeLsaHeap: ::std::option::Option<PLSA_FREE_LSA_HEAP>,
4799     pub AllocateClientBuffer: ::std::option::Option<PLSA_ALLOCATE_CLIENT_BUFFER>,
4800     pub FreeClientBuffer: ::std::option::Option<PLSA_FREE_CLIENT_BUFFER>,
4801     pub CopyToClientBuffer: ::std::option::Option<PLSA_COPY_TO_CLIENT_BUFFER>,
4802     pub CopyFromClientBuffer: ::std::option::Option<PLSA_COPY_FROM_CLIENT_BUFFER>,
4803 }
4804 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
4805 impl LSA_DISPATCH_TABLE {}
4806 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
4807 impl ::std::default::Default for LSA_DISPATCH_TABLE {
4808     fn default() -> Self {
4809         unsafe { ::std::mem::zeroed() }
4810     }
4811 }
4812 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
4813 impl ::std::fmt::Debug for LSA_DISPATCH_TABLE {
4814     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4815         fmt.debug_struct("LSA_DISPATCH_TABLE").finish()
4816     }
4817 }
4818 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
4819 impl ::std::cmp::PartialEq for LSA_DISPATCH_TABLE {
4820     fn eq(&self, other: &Self) -> bool {
4821         self.CreateLogonSession.map(|f| f as usize) == other.CreateLogonSession.map(|f| f as usize)
4822             && self.DeleteLogonSession.map(|f| f as usize) == other.DeleteLogonSession.map(|f| f as usize)
4823             && self.AddCredential.map(|f| f as usize) == other.AddCredential.map(|f| f as usize)
4824             && self.GetCredentials.map(|f| f as usize) == other.GetCredentials.map(|f| f as usize)
4825             && self.DeleteCredential.map(|f| f as usize) == other.DeleteCredential.map(|f| f as usize)
4826             && self.AllocateLsaHeap.map(|f| f as usize) == other.AllocateLsaHeap.map(|f| f as usize)
4827             && self.FreeLsaHeap.map(|f| f as usize) == other.FreeLsaHeap.map(|f| f as usize)
4828             && self.AllocateClientBuffer.map(|f| f as usize) == other.AllocateClientBuffer.map(|f| f as usize)
4829             && self.FreeClientBuffer.map(|f| f as usize) == other.FreeClientBuffer.map(|f| f as usize)
4830             && self.CopyToClientBuffer.map(|f| f as usize) == other.CopyToClientBuffer.map(|f| f as usize)
4831             && self.CopyFromClientBuffer.map(|f| f as usize) == other.CopyFromClientBuffer.map(|f| f as usize)
4832     }
4833 }
4834 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
4835 impl ::std::cmp::Eq for LSA_DISPATCH_TABLE {}
4836 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
4837 unsafe impl ::windows::runtime::Abi for LSA_DISPATCH_TABLE {
4838     type Abi = ::std::mem::ManuallyDrop<Self>;
4839     type DefaultType = Self;
4840 }
4841 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4842 #[repr(C)]
4843 #[cfg(feature = "Win32_Foundation")]
4844 pub struct LSA_ENUMERATION_INFORMATION {
4845     pub Sid: super::super::super::Foundation::PSID,
4846 }
4847 #[cfg(feature = "Win32_Foundation")]
4848 impl LSA_ENUMERATION_INFORMATION {}
4849 #[cfg(feature = "Win32_Foundation")]
4850 impl ::std::default::Default for LSA_ENUMERATION_INFORMATION {
4851     fn default() -> Self {
4852         unsafe { ::std::mem::zeroed() }
4853     }
4854 }
4855 #[cfg(feature = "Win32_Foundation")]
4856 impl ::std::fmt::Debug for LSA_ENUMERATION_INFORMATION {
4857     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4858         fmt.debug_struct("LSA_ENUMERATION_INFORMATION").field("Sid", &self.Sid).finish()
4859     }
4860 }
4861 #[cfg(feature = "Win32_Foundation")]
4862 impl ::std::cmp::PartialEq for LSA_ENUMERATION_INFORMATION {
4863     fn eq(&self, other: &Self) -> bool {
4864         self.Sid == other.Sid
4865     }
4866 }
4867 #[cfg(feature = "Win32_Foundation")]
4868 impl ::std::cmp::Eq for LSA_ENUMERATION_INFORMATION {}
4869 #[cfg(feature = "Win32_Foundation")]
4870 unsafe impl ::windows::runtime::Abi for LSA_ENUMERATION_INFORMATION {
4871     type Abi = Self;
4872     type DefaultType = Self;
4873 }
4874 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4875 #[repr(C)]
4876 pub struct LSA_FOREST_TRUST_BINARY_DATA {
4877     pub Length: u32,
4878     pub Buffer: *mut u8,
4879 }
4880 impl LSA_FOREST_TRUST_BINARY_DATA {}
4881 impl ::std::default::Default for LSA_FOREST_TRUST_BINARY_DATA {
4882     fn default() -> Self {
4883         unsafe { ::std::mem::zeroed() }
4884     }
4885 }
4886 impl ::std::fmt::Debug for LSA_FOREST_TRUST_BINARY_DATA {
4887     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4888         fmt.debug_struct("LSA_FOREST_TRUST_BINARY_DATA").field("Length", &self.Length).field("Buffer", &self.Buffer).finish()
4889     }
4890 }
4891 impl ::std::cmp::PartialEq for LSA_FOREST_TRUST_BINARY_DATA {
4892     fn eq(&self, other: &Self) -> bool {
4893         self.Length == other.Length && self.Buffer == other.Buffer
4894     }
4895 }
4896 impl ::std::cmp::Eq for LSA_FOREST_TRUST_BINARY_DATA {}
4897 unsafe impl ::windows::runtime::Abi for LSA_FOREST_TRUST_BINARY_DATA {
4898     type Abi = Self;
4899     type DefaultType = Self;
4900 }
4901 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4902 #[repr(C)]
4903 #[cfg(feature = "Win32_Foundation")]
4904 pub struct LSA_FOREST_TRUST_COLLISION_INFORMATION {
4905     pub RecordCount: u32,
4906     pub Entries: *mut *mut LSA_FOREST_TRUST_COLLISION_RECORD,
4907 }
4908 #[cfg(feature = "Win32_Foundation")]
4909 impl LSA_FOREST_TRUST_COLLISION_INFORMATION {}
4910 #[cfg(feature = "Win32_Foundation")]
4911 impl ::std::default::Default for LSA_FOREST_TRUST_COLLISION_INFORMATION {
4912     fn default() -> Self {
4913         unsafe { ::std::mem::zeroed() }
4914     }
4915 }
4916 #[cfg(feature = "Win32_Foundation")]
4917 impl ::std::fmt::Debug for LSA_FOREST_TRUST_COLLISION_INFORMATION {
4918     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4919         fmt.debug_struct("LSA_FOREST_TRUST_COLLISION_INFORMATION").field("RecordCount", &self.RecordCount).field("Entries", &self.Entries).finish()
4920     }
4921 }
4922 #[cfg(feature = "Win32_Foundation")]
4923 impl ::std::cmp::PartialEq for LSA_FOREST_TRUST_COLLISION_INFORMATION {
4924     fn eq(&self, other: &Self) -> bool {
4925         self.RecordCount == other.RecordCount && self.Entries == other.Entries
4926     }
4927 }
4928 #[cfg(feature = "Win32_Foundation")]
4929 impl ::std::cmp::Eq for LSA_FOREST_TRUST_COLLISION_INFORMATION {}
4930 #[cfg(feature = "Win32_Foundation")]
4931 unsafe impl ::windows::runtime::Abi for LSA_FOREST_TRUST_COLLISION_INFORMATION {
4932     type Abi = Self;
4933     type DefaultType = Self;
4934 }
4935 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4936 #[repr(C)]
4937 #[cfg(feature = "Win32_Foundation")]
4938 pub struct LSA_FOREST_TRUST_COLLISION_RECORD {
4939     pub Index: u32,
4940     pub Type: LSA_FOREST_TRUST_COLLISION_RECORD_TYPE,
4941     pub Flags: u32,
4942     pub Name: super::super::super::Foundation::UNICODE_STRING,
4943 }
4944 #[cfg(feature = "Win32_Foundation")]
4945 impl LSA_FOREST_TRUST_COLLISION_RECORD {}
4946 #[cfg(feature = "Win32_Foundation")]
4947 impl ::std::default::Default for LSA_FOREST_TRUST_COLLISION_RECORD {
4948     fn default() -> Self {
4949         unsafe { ::std::mem::zeroed() }
4950     }
4951 }
4952 #[cfg(feature = "Win32_Foundation")]
4953 impl ::std::fmt::Debug for LSA_FOREST_TRUST_COLLISION_RECORD {
4954     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4955         fmt.debug_struct("LSA_FOREST_TRUST_COLLISION_RECORD").field("Index", &self.Index).field("Type", &self.Type).field("Flags", &self.Flags).field("Name", &self.Name).finish()
4956     }
4957 }
4958 #[cfg(feature = "Win32_Foundation")]
4959 impl ::std::cmp::PartialEq for LSA_FOREST_TRUST_COLLISION_RECORD {
4960     fn eq(&self, other: &Self) -> bool {
4961         self.Index == other.Index && self.Type == other.Type && self.Flags == other.Flags && self.Name == other.Name
4962     }
4963 }
4964 #[cfg(feature = "Win32_Foundation")]
4965 impl ::std::cmp::Eq for LSA_FOREST_TRUST_COLLISION_RECORD {}
4966 #[cfg(feature = "Win32_Foundation")]
4967 unsafe impl ::windows::runtime::Abi for LSA_FOREST_TRUST_COLLISION_RECORD {
4968     type Abi = Self;
4969     type DefaultType = Self;
4970 }
4971 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4972 #[repr(transparent)]
4973 pub struct LSA_FOREST_TRUST_COLLISION_RECORD_TYPE(pub i32);
4974 pub const CollisionTdo: LSA_FOREST_TRUST_COLLISION_RECORD_TYPE = LSA_FOREST_TRUST_COLLISION_RECORD_TYPE(0i32);
4975 pub const CollisionXref: LSA_FOREST_TRUST_COLLISION_RECORD_TYPE = LSA_FOREST_TRUST_COLLISION_RECORD_TYPE(1i32);
4976 pub const CollisionOther: LSA_FOREST_TRUST_COLLISION_RECORD_TYPE = LSA_FOREST_TRUST_COLLISION_RECORD_TYPE(2i32);
4977 impl ::std::convert::From<i32> for LSA_FOREST_TRUST_COLLISION_RECORD_TYPE {
4978     fn from(value: i32) -> Self {
4979         Self(value)
4980     }
4981 }
4982 unsafe impl ::windows::runtime::Abi for LSA_FOREST_TRUST_COLLISION_RECORD_TYPE {
4983     type Abi = Self;
4984     type DefaultType = Self;
4985 }
4986 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4987 #[repr(C)]
4988 #[cfg(feature = "Win32_Foundation")]
4989 pub struct LSA_FOREST_TRUST_DOMAIN_INFO {
4990     pub Sid: super::super::super::Foundation::PSID,
4991     pub DnsName: super::super::super::Foundation::UNICODE_STRING,
4992     pub NetbiosName: super::super::super::Foundation::UNICODE_STRING,
4993 }
4994 #[cfg(feature = "Win32_Foundation")]
4995 impl LSA_FOREST_TRUST_DOMAIN_INFO {}
4996 #[cfg(feature = "Win32_Foundation")]
4997 impl ::std::default::Default for LSA_FOREST_TRUST_DOMAIN_INFO {
4998     fn default() -> Self {
4999         unsafe { ::std::mem::zeroed() }
5000     }
5001 }
5002 #[cfg(feature = "Win32_Foundation")]
5003 impl ::std::fmt::Debug for LSA_FOREST_TRUST_DOMAIN_INFO {
5004     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5005         fmt.debug_struct("LSA_FOREST_TRUST_DOMAIN_INFO").field("Sid", &self.Sid).field("DnsName", &self.DnsName).field("NetbiosName", &self.NetbiosName).finish()
5006     }
5007 }
5008 #[cfg(feature = "Win32_Foundation")]
5009 impl ::std::cmp::PartialEq for LSA_FOREST_TRUST_DOMAIN_INFO {
5010     fn eq(&self, other: &Self) -> bool {
5011         self.Sid == other.Sid && self.DnsName == other.DnsName && self.NetbiosName == other.NetbiosName
5012     }
5013 }
5014 #[cfg(feature = "Win32_Foundation")]
5015 impl ::std::cmp::Eq for LSA_FOREST_TRUST_DOMAIN_INFO {}
5016 #[cfg(feature = "Win32_Foundation")]
5017 unsafe impl ::windows::runtime::Abi for LSA_FOREST_TRUST_DOMAIN_INFO {
5018     type Abi = Self;
5019     type DefaultType = Self;
5020 }
5021 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5022 #[repr(C)]
5023 #[cfg(feature = "Win32_Foundation")]
5024 pub struct LSA_FOREST_TRUST_INFORMATION {
5025     pub RecordCount: u32,
5026     pub Entries: *mut *mut LSA_FOREST_TRUST_RECORD,
5027 }
5028 #[cfg(feature = "Win32_Foundation")]
5029 impl LSA_FOREST_TRUST_INFORMATION {}
5030 #[cfg(feature = "Win32_Foundation")]
5031 impl ::std::default::Default for LSA_FOREST_TRUST_INFORMATION {
5032     fn default() -> Self {
5033         unsafe { ::std::mem::zeroed() }
5034     }
5035 }
5036 #[cfg(feature = "Win32_Foundation")]
5037 impl ::std::fmt::Debug for LSA_FOREST_TRUST_INFORMATION {
5038     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5039         fmt.debug_struct("LSA_FOREST_TRUST_INFORMATION").field("RecordCount", &self.RecordCount).field("Entries", &self.Entries).finish()
5040     }
5041 }
5042 #[cfg(feature = "Win32_Foundation")]
5043 impl ::std::cmp::PartialEq for LSA_FOREST_TRUST_INFORMATION {
5044     fn eq(&self, other: &Self) -> bool {
5045         self.RecordCount == other.RecordCount && self.Entries == other.Entries
5046     }
5047 }
5048 #[cfg(feature = "Win32_Foundation")]
5049 impl ::std::cmp::Eq for LSA_FOREST_TRUST_INFORMATION {}
5050 #[cfg(feature = "Win32_Foundation")]
5051 unsafe impl ::windows::runtime::Abi for LSA_FOREST_TRUST_INFORMATION {
5052     type Abi = Self;
5053     type DefaultType = Self;
5054 }
5055 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5056 #[repr(C)]
5057 #[cfg(feature = "Win32_Foundation")]
5058 pub struct LSA_FOREST_TRUST_RECORD {
5059     pub Flags: u32,
5060     pub ForestTrustType: LSA_FOREST_TRUST_RECORD_TYPE,
5061     pub Time: i64,
5062     pub ForestTrustData: LSA_FOREST_TRUST_RECORD_0,
5063 }
5064 #[cfg(feature = "Win32_Foundation")]
5065 impl LSA_FOREST_TRUST_RECORD {}
5066 #[cfg(feature = "Win32_Foundation")]
5067 impl ::std::default::Default for LSA_FOREST_TRUST_RECORD {
5068     fn default() -> Self {
5069         unsafe { ::std::mem::zeroed() }
5070     }
5071 }
5072 #[cfg(feature = "Win32_Foundation")]
5073 impl ::std::cmp::PartialEq for LSA_FOREST_TRUST_RECORD {
5074     fn eq(&self, _other: &Self) -> bool {
5075         unimplemented!()
5076     }
5077 }
5078 #[cfg(feature = "Win32_Foundation")]
5079 impl ::std::cmp::Eq for LSA_FOREST_TRUST_RECORD {}
5080 #[cfg(feature = "Win32_Foundation")]
5081 unsafe impl ::windows::runtime::Abi for LSA_FOREST_TRUST_RECORD {
5082     type Abi = Self;
5083     type DefaultType = Self;
5084 }
5085 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5086 #[repr(C)]
5087 #[cfg(feature = "Win32_Foundation")]
5088 pub union LSA_FOREST_TRUST_RECORD_0 {
5089     pub TopLevelName: super::super::super::Foundation::UNICODE_STRING,
5090     pub DomainInfo: LSA_FOREST_TRUST_DOMAIN_INFO,
5091     pub Data: LSA_FOREST_TRUST_BINARY_DATA,
5092 }
5093 #[cfg(feature = "Win32_Foundation")]
5094 impl LSA_FOREST_TRUST_RECORD_0 {}
5095 #[cfg(feature = "Win32_Foundation")]
5096 impl ::std::default::Default for LSA_FOREST_TRUST_RECORD_0 {
5097     fn default() -> Self {
5098         unsafe { ::std::mem::zeroed() }
5099     }
5100 }
5101 #[cfg(feature = "Win32_Foundation")]
5102 impl ::std::cmp::PartialEq for LSA_FOREST_TRUST_RECORD_0 {
5103     fn eq(&self, _other: &Self) -> bool {
5104         unimplemented!()
5105     }
5106 }
5107 #[cfg(feature = "Win32_Foundation")]
5108 impl ::std::cmp::Eq for LSA_FOREST_TRUST_RECORD_0 {}
5109 #[cfg(feature = "Win32_Foundation")]
5110 unsafe impl ::windows::runtime::Abi for LSA_FOREST_TRUST_RECORD_0 {
5111     type Abi = Self;
5112     type DefaultType = Self;
5113 }
5114 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5115 #[repr(transparent)]
5116 pub struct LSA_FOREST_TRUST_RECORD_TYPE(pub i32);
5117 pub const ForestTrustTopLevelName: LSA_FOREST_TRUST_RECORD_TYPE = LSA_FOREST_TRUST_RECORD_TYPE(0i32);
5118 pub const ForestTrustTopLevelNameEx: LSA_FOREST_TRUST_RECORD_TYPE = LSA_FOREST_TRUST_RECORD_TYPE(1i32);
5119 pub const ForestTrustDomainInfo: LSA_FOREST_TRUST_RECORD_TYPE = LSA_FOREST_TRUST_RECORD_TYPE(2i32);
5120 pub const ForestTrustRecordTypeLast: LSA_FOREST_TRUST_RECORD_TYPE = LSA_FOREST_TRUST_RECORD_TYPE(2i32);
5121 impl ::std::convert::From<i32> for LSA_FOREST_TRUST_RECORD_TYPE {
5122     fn from(value: i32) -> Self {
5123         Self(value)
5124     }
5125 }
5126 unsafe impl ::windows::runtime::Abi for LSA_FOREST_TRUST_RECORD_TYPE {
5127     type Abi = Self;
5128     type DefaultType = Self;
5129 }
5130 pub const LSA_FOREST_TRUST_RECORD_TYPE_UNRECOGNIZED: u32 = 2147483648u32;
5131 pub const LSA_FTRECORD_DISABLED_REASONS: i32 = 65535i32;
5132 pub const LSA_GLOBAL_SECRET_PREFIX_LENGTH: u32 = 2u32;
5133 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5134 #[repr(C)]
5135 pub struct LSA_LAST_INTER_LOGON_INFO {
5136     pub LastSuccessfulLogon: i64,
5137     pub LastFailedLogon: i64,
5138     pub FailedAttemptCountSinceLastSuccessfulLogon: u32,
5139 }
5140 impl LSA_LAST_INTER_LOGON_INFO {}
5141 impl ::std::default::Default for LSA_LAST_INTER_LOGON_INFO {
5142     fn default() -> Self {
5143         unsafe { ::std::mem::zeroed() }
5144     }
5145 }
5146 impl ::std::fmt::Debug for LSA_LAST_INTER_LOGON_INFO {
5147     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5148         fmt.debug_struct("LSA_LAST_INTER_LOGON_INFO").field("LastSuccessfulLogon", &self.LastSuccessfulLogon).field("LastFailedLogon", &self.LastFailedLogon).field("FailedAttemptCountSinceLastSuccessfulLogon", &self.FailedAttemptCountSinceLastSuccessfulLogon).finish()
5149     }
5150 }
5151 impl ::std::cmp::PartialEq for LSA_LAST_INTER_LOGON_INFO {
5152     fn eq(&self, other: &Self) -> bool {
5153         self.LastSuccessfulLogon == other.LastSuccessfulLogon && self.LastFailedLogon == other.LastFailedLogon && self.FailedAttemptCountSinceLastSuccessfulLogon == other.FailedAttemptCountSinceLastSuccessfulLogon
5154     }
5155 }
5156 impl ::std::cmp::Eq for LSA_LAST_INTER_LOGON_INFO {}
5157 unsafe impl ::windows::runtime::Abi for LSA_LAST_INTER_LOGON_INFO {
5158     type Abi = Self;
5159     type DefaultType = Self;
5160 }
5161 pub const LSA_LOCAL_SECRET_PREFIX_LENGTH: u32 = 2u32;
5162 pub const LSA_LOOKUP_DISALLOW_CONNECTED_ACCOUNT_INTERNET_SID: u32 = 2147483648u32;
5163 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5164 #[repr(transparent)]
5165 pub struct LSA_LOOKUP_DOMAIN_INFO_CLASS(pub i32);
5166 pub const AccountDomainInformation: LSA_LOOKUP_DOMAIN_INFO_CLASS = LSA_LOOKUP_DOMAIN_INFO_CLASS(5i32);
5167 pub const DnsDomainInformation: LSA_LOOKUP_DOMAIN_INFO_CLASS = LSA_LOOKUP_DOMAIN_INFO_CLASS(12i32);
5168 impl ::std::convert::From<i32> for LSA_LOOKUP_DOMAIN_INFO_CLASS {
5169     fn from(value: i32) -> Self {
5170         Self(value)
5171     }
5172 }
5173 unsafe impl ::windows::runtime::Abi for LSA_LOOKUP_DOMAIN_INFO_CLASS {
5174     type Abi = Self;
5175     type DefaultType = Self;
5176 }
5177 pub const LSA_LOOKUP_ISOLATED_AS_LOCAL: u32 = 2147483648u32;
5178 pub const LSA_LOOKUP_PREFER_INTERNET_NAMES: u32 = 1073741824u32;
5179 pub const LSA_MAXIMUM_ENUMERATION_LENGTH: u32 = 32000u32;
5180 pub const LSA_MAXIMUM_SID_COUNT: i32 = 256i32;
5181 pub const LSA_MODE_INDIVIDUAL_ACCOUNTS: i32 = 2i32;
5182 pub const LSA_MODE_LOG_FULL: i32 = 8i32;
5183 pub const LSA_MODE_MANDATORY_ACCESS: i32 = 4i32;
5184 pub const LSA_MODE_PASSWORD_PROTECTED: i32 = 1i32;
5185 pub const LSA_NB_DISABLED_ADMIN: i32 = 4i32;
5186 pub const LSA_NB_DISABLED_CONFLICT: i32 = 8i32;
5187 pub const LSA_QUERY_CLIENT_PRELOGON_SESSION_ID: u32 = 1u32;
5188 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5189 #[repr(C)]
5190 #[cfg(feature = "Win32_Foundation")]
5191 pub struct LSA_REFERENCED_DOMAIN_LIST {
5192     pub Entries: u32,
5193     pub Domains: *mut LSA_TRUST_INFORMATION,
5194 }
5195 #[cfg(feature = "Win32_Foundation")]
5196 impl LSA_REFERENCED_DOMAIN_LIST {}
5197 #[cfg(feature = "Win32_Foundation")]
5198 impl ::std::default::Default for LSA_REFERENCED_DOMAIN_LIST {
5199     fn default() -> Self {
5200         unsafe { ::std::mem::zeroed() }
5201     }
5202 }
5203 #[cfg(feature = "Win32_Foundation")]
5204 impl ::std::fmt::Debug for LSA_REFERENCED_DOMAIN_LIST {
5205     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5206         fmt.debug_struct("LSA_REFERENCED_DOMAIN_LIST").field("Entries", &self.Entries).field("Domains", &self.Domains).finish()
5207     }
5208 }
5209 #[cfg(feature = "Win32_Foundation")]
5210 impl ::std::cmp::PartialEq for LSA_REFERENCED_DOMAIN_LIST {
5211     fn eq(&self, other: &Self) -> bool {
5212         self.Entries == other.Entries && self.Domains == other.Domains
5213     }
5214 }
5215 #[cfg(feature = "Win32_Foundation")]
5216 impl ::std::cmp::Eq for LSA_REFERENCED_DOMAIN_LIST {}
5217 #[cfg(feature = "Win32_Foundation")]
5218 unsafe impl ::windows::runtime::Abi for LSA_REFERENCED_DOMAIN_LIST {
5219     type Abi = Self;
5220     type DefaultType = Self;
5221 }
5222 #[derive(:: std :: clone :: Clone)]
5223 #[repr(C)]
5224 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials", feature = "Win32_System_Kernel", feature = "Win32_System_SystemServices"))]
5225 pub struct LSA_SECPKG_FUNCTION_TABLE {
5226     pub CreateLogonSession: ::std::option::Option<PLSA_CREATE_LOGON_SESSION>,
5227     pub DeleteLogonSession: ::std::option::Option<PLSA_DELETE_LOGON_SESSION>,
5228     pub AddCredential: ::std::option::Option<PLSA_ADD_CREDENTIAL>,
5229     pub GetCredentials: ::std::option::Option<PLSA_GET_CREDENTIALS>,
5230     pub DeleteCredential: ::std::option::Option<PLSA_DELETE_CREDENTIAL>,
5231     pub AllocateLsaHeap: ::std::option::Option<PLSA_ALLOCATE_LSA_HEAP>,
5232     pub FreeLsaHeap: ::std::option::Option<PLSA_FREE_LSA_HEAP>,
5233     pub AllocateClientBuffer: ::std::option::Option<PLSA_ALLOCATE_CLIENT_BUFFER>,
5234     pub FreeClientBuffer: ::std::option::Option<PLSA_FREE_CLIENT_BUFFER>,
5235     pub CopyToClientBuffer: ::std::option::Option<PLSA_COPY_TO_CLIENT_BUFFER>,
5236     pub CopyFromClientBuffer: ::std::option::Option<PLSA_COPY_FROM_CLIENT_BUFFER>,
5237     pub ImpersonateClient: ::std::option::Option<PLSA_IMPERSONATE_CLIENT>,
5238     pub UnloadPackage: ::std::option::Option<PLSA_UNLOAD_PACKAGE>,
5239     pub DuplicateHandle: ::std::option::Option<PLSA_DUPLICATE_HANDLE>,
5240     pub SaveSupplementalCredentials: ::std::option::Option<PLSA_SAVE_SUPPLEMENTAL_CREDENTIALS>,
5241     pub CreateThread: ::std::option::Option<PLSA_CREATE_THREAD>,
5242     pub GetClientInfo: ::std::option::Option<PLSA_GET_CLIENT_INFO>,
5243     pub RegisterNotification: ::std::option::Option<PLSA_REGISTER_NOTIFICATION>,
5244     pub CancelNotification: ::std::option::Option<PLSA_CANCEL_NOTIFICATION>,
5245     pub MapBuffer: ::std::option::Option<PLSA_MAP_BUFFER>,
5246     pub CreateToken: ::std::option::Option<PLSA_CREATE_TOKEN>,
5247     pub AuditLogon: ::std::option::Option<PLSA_AUDIT_LOGON>,
5248     pub CallPackage: ::std::option::Option<PLSA_CALL_PACKAGE>,
5249     pub FreeReturnBuffer: ::std::option::Option<PLSA_FREE_LSA_HEAP>,
5250     pub GetCallInfo: ::std::option::Option<PLSA_GET_CALL_INFO>,
5251     pub CallPackageEx: ::std::option::Option<PLSA_CALL_PACKAGEEX>,
5252     pub CreateSharedMemory: ::std::option::Option<PLSA_CREATE_SHARED_MEMORY>,
5253     pub AllocateSharedMemory: ::std::option::Option<PLSA_ALLOCATE_SHARED_MEMORY>,
5254     pub FreeSharedMemory: ::std::option::Option<PLSA_FREE_SHARED_MEMORY>,
5255     pub DeleteSharedMemory: ::std::option::Option<PLSA_DELETE_SHARED_MEMORY>,
5256     pub OpenSamUser: ::std::option::Option<PLSA_OPEN_SAM_USER>,
5257     pub GetUserCredentials: ::std::option::Option<PLSA_GET_USER_CREDENTIALS>,
5258     pub GetUserAuthData: ::std::option::Option<PLSA_GET_USER_AUTH_DATA>,
5259     pub CloseSamUser: ::std::option::Option<PLSA_CLOSE_SAM_USER>,
5260     pub ConvertAuthDataToToken: ::std::option::Option<PLSA_CONVERT_AUTH_DATA_TO_TOKEN>,
5261     pub ClientCallback: ::std::option::Option<PLSA_CLIENT_CALLBACK>,
5262     pub UpdateCredentials: ::std::option::Option<PLSA_UPDATE_PRIMARY_CREDENTIALS>,
5263     pub GetAuthDataForUser: ::std::option::Option<PLSA_GET_AUTH_DATA_FOR_USER>,
5264     pub CrackSingleName: ::std::option::Option<PLSA_CRACK_SINGLE_NAME>,
5265     pub AuditAccountLogon: ::std::option::Option<PLSA_AUDIT_ACCOUNT_LOGON>,
5266     pub CallPackagePassthrough: ::std::option::Option<PLSA_CALL_PACKAGE_PASSTHROUGH>,
5267     pub CrediRead: ::std::option::Option<CredReadFn>,
5268     pub CrediReadDomainCredentials: ::std::option::Option<CredReadDomainCredentialsFn>,
5269     pub CrediFreeCredentials: ::std::option::Option<CredFreeCredentialsFn>,
5270     pub LsaProtectMemory: ::std::option::Option<PLSA_PROTECT_MEMORY>,
5271     pub LsaUnprotectMemory: ::std::option::Option<PLSA_PROTECT_MEMORY>,
5272     pub OpenTokenByLogonId: ::std::option::Option<PLSA_OPEN_TOKEN_BY_LOGON_ID>,
5273     pub ExpandAuthDataForDomain: ::std::option::Option<PLSA_EXPAND_AUTH_DATA_FOR_DOMAIN>,
5274     pub AllocatePrivateHeap: ::std::option::Option<PLSA_ALLOCATE_PRIVATE_HEAP>,
5275     pub FreePrivateHeap: ::std::option::Option<PLSA_FREE_PRIVATE_HEAP>,
5276     pub CreateTokenEx: ::std::option::Option<PLSA_CREATE_TOKEN_EX>,
5277     pub CrediWrite: ::std::option::Option<CredWriteFn>,
5278     pub CrediUnmarshalandDecodeString: ::std::option::Option<CrediUnmarshalandDecodeStringFn>,
5279     pub DummyFunction6: ::std::option::Option<PLSA_PROTECT_MEMORY>,
5280     pub GetExtendedCallFlags: ::std::option::Option<PLSA_GET_EXTENDED_CALL_FLAGS>,
5281     pub DuplicateTokenHandle: ::std::option::Option<PLSA_DUPLICATE_HANDLE>,
5282     pub GetServiceAccountPassword: ::std::option::Option<PLSA_GET_SERVICE_ACCOUNT_PASSWORD>,
5283     pub DummyFunction7: ::std::option::Option<PLSA_PROTECT_MEMORY>,
5284     pub AuditLogonEx: ::std::option::Option<PLSA_AUDIT_LOGON_EX>,
5285     pub CheckProtectedUserByToken: ::std::option::Option<PLSA_CHECK_PROTECTED_USER_BY_TOKEN>,
5286     pub QueryClientRequest: ::std::option::Option<PLSA_QUERY_CLIENT_REQUEST>,
5287     pub GetAppModeInfo: ::std::option::Option<PLSA_GET_APP_MODE_INFO>,
5288     pub SetAppModeInfo: ::std::option::Option<PLSA_SET_APP_MODE_INFO>,
5289 }
5290 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials", feature = "Win32_System_Kernel", feature = "Win32_System_SystemServices"))]
5291 impl LSA_SECPKG_FUNCTION_TABLE {}
5292 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials", feature = "Win32_System_Kernel", feature = "Win32_System_SystemServices"))]
5293 impl ::std::default::Default for LSA_SECPKG_FUNCTION_TABLE {
5294     fn default() -> Self {
5295         unsafe { ::std::mem::zeroed() }
5296     }
5297 }
5298 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials", feature = "Win32_System_Kernel", feature = "Win32_System_SystemServices"))]
5299 impl ::std::fmt::Debug for LSA_SECPKG_FUNCTION_TABLE {
5300     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5301         fmt.debug_struct("LSA_SECPKG_FUNCTION_TABLE").finish()
5302     }
5303 }
5304 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials", feature = "Win32_System_Kernel", feature = "Win32_System_SystemServices"))]
5305 impl ::std::cmp::PartialEq for LSA_SECPKG_FUNCTION_TABLE {
5306     fn eq(&self, other: &Self) -> bool {
5307         self.CreateLogonSession.map(|f| f as usize) == other.CreateLogonSession.map(|f| f as usize)
5308             && self.DeleteLogonSession.map(|f| f as usize) == other.DeleteLogonSession.map(|f| f as usize)
5309             && self.AddCredential.map(|f| f as usize) == other.AddCredential.map(|f| f as usize)
5310             && self.GetCredentials.map(|f| f as usize) == other.GetCredentials.map(|f| f as usize)
5311             && self.DeleteCredential.map(|f| f as usize) == other.DeleteCredential.map(|f| f as usize)
5312             && self.AllocateLsaHeap.map(|f| f as usize) == other.AllocateLsaHeap.map(|f| f as usize)
5313             && self.FreeLsaHeap.map(|f| f as usize) == other.FreeLsaHeap.map(|f| f as usize)
5314             && self.AllocateClientBuffer.map(|f| f as usize) == other.AllocateClientBuffer.map(|f| f as usize)
5315             && self.FreeClientBuffer.map(|f| f as usize) == other.FreeClientBuffer.map(|f| f as usize)
5316             && self.CopyToClientBuffer.map(|f| f as usize) == other.CopyToClientBuffer.map(|f| f as usize)
5317             && self.CopyFromClientBuffer.map(|f| f as usize) == other.CopyFromClientBuffer.map(|f| f as usize)
5318             && self.ImpersonateClient.map(|f| f as usize) == other.ImpersonateClient.map(|f| f as usize)
5319             && self.UnloadPackage.map(|f| f as usize) == other.UnloadPackage.map(|f| f as usize)
5320             && self.DuplicateHandle.map(|f| f as usize) == other.DuplicateHandle.map(|f| f as usize)
5321             && self.SaveSupplementalCredentials.map(|f| f as usize) == other.SaveSupplementalCredentials.map(|f| f as usize)
5322             && self.CreateThread.map(|f| f as usize) == other.CreateThread.map(|f| f as usize)
5323             && self.GetClientInfo.map(|f| f as usize) == other.GetClientInfo.map(|f| f as usize)
5324             && self.RegisterNotification.map(|f| f as usize) == other.RegisterNotification.map(|f| f as usize)
5325             && self.CancelNotification.map(|f| f as usize) == other.CancelNotification.map(|f| f as usize)
5326             && self.MapBuffer.map(|f| f as usize) == other.MapBuffer.map(|f| f as usize)
5327             && self.CreateToken.map(|f| f as usize) == other.CreateToken.map(|f| f as usize)
5328             && self.AuditLogon.map(|f| f as usize) == other.AuditLogon.map(|f| f as usize)
5329             && self.CallPackage.map(|f| f as usize) == other.CallPackage.map(|f| f as usize)
5330             && self.FreeReturnBuffer.map(|f| f as usize) == other.FreeReturnBuffer.map(|f| f as usize)
5331             && self.GetCallInfo.map(|f| f as usize) == other.GetCallInfo.map(|f| f as usize)
5332             && self.CallPackageEx.map(|f| f as usize) == other.CallPackageEx.map(|f| f as usize)
5333             && self.CreateSharedMemory.map(|f| f as usize) == other.CreateSharedMemory.map(|f| f as usize)
5334             && self.AllocateSharedMemory.map(|f| f as usize) == other.AllocateSharedMemory.map(|f| f as usize)
5335             && self.FreeSharedMemory.map(|f| f as usize) == other.FreeSharedMemory.map(|f| f as usize)
5336             && self.DeleteSharedMemory.map(|f| f as usize) == other.DeleteSharedMemory.map(|f| f as usize)
5337             && self.OpenSamUser.map(|f| f as usize) == other.OpenSamUser.map(|f| f as usize)
5338             && self.GetUserCredentials.map(|f| f as usize) == other.GetUserCredentials.map(|f| f as usize)
5339             && self.GetUserAuthData.map(|f| f as usize) == other.GetUserAuthData.map(|f| f as usize)
5340             && self.CloseSamUser.map(|f| f as usize) == other.CloseSamUser.map(|f| f as usize)
5341             && self.ConvertAuthDataToToken.map(|f| f as usize) == other.ConvertAuthDataToToken.map(|f| f as usize)
5342             && self.ClientCallback.map(|f| f as usize) == other.ClientCallback.map(|f| f as usize)
5343             && self.UpdateCredentials.map(|f| f as usize) == other.UpdateCredentials.map(|f| f as usize)
5344             && self.GetAuthDataForUser.map(|f| f as usize) == other.GetAuthDataForUser.map(|f| f as usize)
5345             && self.CrackSingleName.map(|f| f as usize) == other.CrackSingleName.map(|f| f as usize)
5346             && self.AuditAccountLogon.map(|f| f as usize) == other.AuditAccountLogon.map(|f| f as usize)
5347             && self.CallPackagePassthrough.map(|f| f as usize) == other.CallPackagePassthrough.map(|f| f as usize)
5348             && self.CrediRead.map(|f| f as usize) == other.CrediRead.map(|f| f as usize)
5349             && self.CrediReadDomainCredentials.map(|f| f as usize) == other.CrediReadDomainCredentials.map(|f| f as usize)
5350             && self.CrediFreeCredentials.map(|f| f as usize) == other.CrediFreeCredentials.map(|f| f as usize)
5351             && self.LsaProtectMemory.map(|f| f as usize) == other.LsaProtectMemory.map(|f| f as usize)
5352             && self.LsaUnprotectMemory.map(|f| f as usize) == other.LsaUnprotectMemory.map(|f| f as usize)
5353             && self.OpenTokenByLogonId.map(|f| f as usize) == other.OpenTokenByLogonId.map(|f| f as usize)
5354             && self.ExpandAuthDataForDomain.map(|f| f as usize) == other.ExpandAuthDataForDomain.map(|f| f as usize)
5355             && self.AllocatePrivateHeap.map(|f| f as usize) == other.AllocatePrivateHeap.map(|f| f as usize)
5356             && self.FreePrivateHeap.map(|f| f as usize) == other.FreePrivateHeap.map(|f| f as usize)
5357             && self.CreateTokenEx.map(|f| f as usize) == other.CreateTokenEx.map(|f| f as usize)
5358             && self.CrediWrite.map(|f| f as usize) == other.CrediWrite.map(|f| f as usize)
5359             && self.CrediUnmarshalandDecodeString.map(|f| f as usize) == other.CrediUnmarshalandDecodeString.map(|f| f as usize)
5360             && self.DummyFunction6.map(|f| f as usize) == other.DummyFunction6.map(|f| f as usize)
5361             && self.GetExtendedCallFlags.map(|f| f as usize) == other.GetExtendedCallFlags.map(|f| f as usize)
5362             && self.DuplicateTokenHandle.map(|f| f as usize) == other.DuplicateTokenHandle.map(|f| f as usize)
5363             && self.GetServiceAccountPassword.map(|f| f as usize) == other.GetServiceAccountPassword.map(|f| f as usize)
5364             && self.DummyFunction7.map(|f| f as usize) == other.DummyFunction7.map(|f| f as usize)
5365             && self.AuditLogonEx.map(|f| f as usize) == other.AuditLogonEx.map(|f| f as usize)
5366             && self.CheckProtectedUserByToken.map(|f| f as usize) == other.CheckProtectedUserByToken.map(|f| f as usize)
5367             && self.QueryClientRequest.map(|f| f as usize) == other.QueryClientRequest.map(|f| f as usize)
5368             && self.GetAppModeInfo.map(|f| f as usize) == other.GetAppModeInfo.map(|f| f as usize)
5369             && self.SetAppModeInfo.map(|f| f as usize) == other.SetAppModeInfo.map(|f| f as usize)
5370     }
5371 }
5372 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials", feature = "Win32_System_Kernel", feature = "Win32_System_SystemServices"))]
5373 impl ::std::cmp::Eq for LSA_SECPKG_FUNCTION_TABLE {}
5374 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials", feature = "Win32_System_Kernel", feature = "Win32_System_SystemServices"))]
5375 unsafe impl ::windows::runtime::Abi for LSA_SECPKG_FUNCTION_TABLE {
5376     type Abi = ::std::mem::ManuallyDrop<Self>;
5377     type DefaultType = Self;
5378 }
5379 pub const LSA_SECRET_MAXIMUM_COUNT: i32 = 4096i32;
5380 pub const LSA_SECRET_MAXIMUM_LENGTH: i32 = 512i32;
5381 pub const LSA_SID_DISABLED_ADMIN: i32 = 1i32;
5382 pub const LSA_SID_DISABLED_CONFLICT: i32 = 2i32;
5383 pub const LSA_TLN_DISABLED_ADMIN: i32 = 2i32;
5384 pub const LSA_TLN_DISABLED_CONFLICT: i32 = 4i32;
5385 pub const LSA_TLN_DISABLED_NEW: i32 = 1i32;
5386 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5387 #[repr(C)]
5388 #[cfg(feature = "Win32_Foundation")]
5389 pub struct LSA_TOKEN_INFORMATION_NULL {
5390     pub ExpirationTime: i64,
5391     pub Groups: *mut super::super::TOKEN_GROUPS,
5392 }
5393 #[cfg(feature = "Win32_Foundation")]
5394 impl LSA_TOKEN_INFORMATION_NULL {}
5395 #[cfg(feature = "Win32_Foundation")]
5396 impl ::std::default::Default for LSA_TOKEN_INFORMATION_NULL {
5397     fn default() -> Self {
5398         unsafe { ::std::mem::zeroed() }
5399     }
5400 }
5401 #[cfg(feature = "Win32_Foundation")]
5402 impl ::std::fmt::Debug for LSA_TOKEN_INFORMATION_NULL {
5403     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5404         fmt.debug_struct("LSA_TOKEN_INFORMATION_NULL").field("ExpirationTime", &self.ExpirationTime).field("Groups", &self.Groups).finish()
5405     }
5406 }
5407 #[cfg(feature = "Win32_Foundation")]
5408 impl ::std::cmp::PartialEq for LSA_TOKEN_INFORMATION_NULL {
5409     fn eq(&self, other: &Self) -> bool {
5410         self.ExpirationTime == other.ExpirationTime && self.Groups == other.Groups
5411     }
5412 }
5413 #[cfg(feature = "Win32_Foundation")]
5414 impl ::std::cmp::Eq for LSA_TOKEN_INFORMATION_NULL {}
5415 #[cfg(feature = "Win32_Foundation")]
5416 unsafe impl ::windows::runtime::Abi for LSA_TOKEN_INFORMATION_NULL {
5417     type Abi = Self;
5418     type DefaultType = Self;
5419 }
5420 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5421 #[repr(transparent)]
5422 pub struct LSA_TOKEN_INFORMATION_TYPE(pub i32);
5423 pub const LsaTokenInformationNull: LSA_TOKEN_INFORMATION_TYPE = LSA_TOKEN_INFORMATION_TYPE(0i32);
5424 pub const LsaTokenInformationV1: LSA_TOKEN_INFORMATION_TYPE = LSA_TOKEN_INFORMATION_TYPE(1i32);
5425 pub const LsaTokenInformationV2: LSA_TOKEN_INFORMATION_TYPE = LSA_TOKEN_INFORMATION_TYPE(2i32);
5426 pub const LsaTokenInformationV3: LSA_TOKEN_INFORMATION_TYPE = LSA_TOKEN_INFORMATION_TYPE(3i32);
5427 impl ::std::convert::From<i32> for LSA_TOKEN_INFORMATION_TYPE {
5428     fn from(value: i32) -> Self {
5429         Self(value)
5430     }
5431 }
5432 unsafe impl ::windows::runtime::Abi for LSA_TOKEN_INFORMATION_TYPE {
5433     type Abi = Self;
5434     type DefaultType = Self;
5435 }
5436 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5437 #[repr(C)]
5438 #[cfg(feature = "Win32_Foundation")]
5439 pub struct LSA_TOKEN_INFORMATION_V1 {
5440     pub ExpirationTime: i64,
5441     pub User: super::super::TOKEN_USER,
5442     pub Groups: *mut super::super::TOKEN_GROUPS,
5443     pub PrimaryGroup: super::super::TOKEN_PRIMARY_GROUP,
5444     pub Privileges: *mut super::super::TOKEN_PRIVILEGES,
5445     pub Owner: super::super::TOKEN_OWNER,
5446     pub DefaultDacl: super::super::TOKEN_DEFAULT_DACL,
5447 }
5448 #[cfg(feature = "Win32_Foundation")]
5449 impl LSA_TOKEN_INFORMATION_V1 {}
5450 #[cfg(feature = "Win32_Foundation")]
5451 impl ::std::default::Default for LSA_TOKEN_INFORMATION_V1 {
5452     fn default() -> Self {
5453         unsafe { ::std::mem::zeroed() }
5454     }
5455 }
5456 #[cfg(feature = "Win32_Foundation")]
5457 impl ::std::fmt::Debug for LSA_TOKEN_INFORMATION_V1 {
5458     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5459         fmt.debug_struct("LSA_TOKEN_INFORMATION_V1")
5460             .field("ExpirationTime", &self.ExpirationTime)
5461             .field("User", &self.User)
5462             .field("Groups", &self.Groups)
5463             .field("PrimaryGroup", &self.PrimaryGroup)
5464             .field("Privileges", &self.Privileges)
5465             .field("Owner", &self.Owner)
5466             .field("DefaultDacl", &self.DefaultDacl)
5467             .finish()
5468     }
5469 }
5470 #[cfg(feature = "Win32_Foundation")]
5471 impl ::std::cmp::PartialEq for LSA_TOKEN_INFORMATION_V1 {
5472     fn eq(&self, other: &Self) -> bool {
5473         self.ExpirationTime == other.ExpirationTime && self.User == other.User && self.Groups == other.Groups && self.PrimaryGroup == other.PrimaryGroup && self.Privileges == other.Privileges && self.Owner == other.Owner && self.DefaultDacl == other.DefaultDacl
5474     }
5475 }
5476 #[cfg(feature = "Win32_Foundation")]
5477 impl ::std::cmp::Eq for LSA_TOKEN_INFORMATION_V1 {}
5478 #[cfg(feature = "Win32_Foundation")]
5479 unsafe impl ::windows::runtime::Abi for LSA_TOKEN_INFORMATION_V1 {
5480     type Abi = Self;
5481     type DefaultType = Self;
5482 }
5483 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5484 #[repr(C)]
5485 #[cfg(feature = "Win32_Foundation")]
5486 pub struct LSA_TOKEN_INFORMATION_V3 {
5487     pub ExpirationTime: i64,
5488     pub User: super::super::TOKEN_USER,
5489     pub Groups: *mut super::super::TOKEN_GROUPS,
5490     pub PrimaryGroup: super::super::TOKEN_PRIMARY_GROUP,
5491     pub Privileges: *mut super::super::TOKEN_PRIVILEGES,
5492     pub Owner: super::super::TOKEN_OWNER,
5493     pub DefaultDacl: super::super::TOKEN_DEFAULT_DACL,
5494     pub UserClaims: super::super::TOKEN_USER_CLAIMS,
5495     pub DeviceClaims: super::super::TOKEN_DEVICE_CLAIMS,
5496     pub DeviceGroups: *mut super::super::TOKEN_GROUPS,
5497 }
5498 #[cfg(feature = "Win32_Foundation")]
5499 impl LSA_TOKEN_INFORMATION_V3 {}
5500 #[cfg(feature = "Win32_Foundation")]
5501 impl ::std::default::Default for LSA_TOKEN_INFORMATION_V3 {
5502     fn default() -> Self {
5503         unsafe { ::std::mem::zeroed() }
5504     }
5505 }
5506 #[cfg(feature = "Win32_Foundation")]
5507 impl ::std::fmt::Debug for LSA_TOKEN_INFORMATION_V3 {
5508     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5509         fmt.debug_struct("LSA_TOKEN_INFORMATION_V3")
5510             .field("ExpirationTime", &self.ExpirationTime)
5511             .field("User", &self.User)
5512             .field("Groups", &self.Groups)
5513             .field("PrimaryGroup", &self.PrimaryGroup)
5514             .field("Privileges", &self.Privileges)
5515             .field("Owner", &self.Owner)
5516             .field("DefaultDacl", &self.DefaultDacl)
5517             .field("UserClaims", &self.UserClaims)
5518             .field("DeviceClaims", &self.DeviceClaims)
5519             .field("DeviceGroups", &self.DeviceGroups)
5520             .finish()
5521     }
5522 }
5523 #[cfg(feature = "Win32_Foundation")]
5524 impl ::std::cmp::PartialEq for LSA_TOKEN_INFORMATION_V3 {
5525     fn eq(&self, other: &Self) -> bool {
5526         self.ExpirationTime == other.ExpirationTime && self.User == other.User && self.Groups == other.Groups && self.PrimaryGroup == other.PrimaryGroup && self.Privileges == other.Privileges && self.Owner == other.Owner && self.DefaultDacl == other.DefaultDacl && self.UserClaims == other.UserClaims && self.DeviceClaims == other.DeviceClaims && self.DeviceGroups == other.DeviceGroups
5527     }
5528 }
5529 #[cfg(feature = "Win32_Foundation")]
5530 impl ::std::cmp::Eq for LSA_TOKEN_INFORMATION_V3 {}
5531 #[cfg(feature = "Win32_Foundation")]
5532 unsafe impl ::windows::runtime::Abi for LSA_TOKEN_INFORMATION_V3 {
5533     type Abi = Self;
5534     type DefaultType = Self;
5535 }
5536 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5537 #[repr(C)]
5538 #[cfg(feature = "Win32_Foundation")]
5539 pub struct LSA_TRANSLATED_NAME {
5540     pub Use: super::super::SID_NAME_USE,
5541     pub Name: super::super::super::Foundation::UNICODE_STRING,
5542     pub DomainIndex: i32,
5543 }
5544 #[cfg(feature = "Win32_Foundation")]
5545 impl LSA_TRANSLATED_NAME {}
5546 #[cfg(feature = "Win32_Foundation")]
5547 impl ::std::default::Default for LSA_TRANSLATED_NAME {
5548     fn default() -> Self {
5549         unsafe { ::std::mem::zeroed() }
5550     }
5551 }
5552 #[cfg(feature = "Win32_Foundation")]
5553 impl ::std::fmt::Debug for LSA_TRANSLATED_NAME {
5554     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5555         fmt.debug_struct("LSA_TRANSLATED_NAME").field("Use", &self.Use).field("Name", &self.Name).field("DomainIndex", &self.DomainIndex).finish()
5556     }
5557 }
5558 #[cfg(feature = "Win32_Foundation")]
5559 impl ::std::cmp::PartialEq for LSA_TRANSLATED_NAME {
5560     fn eq(&self, other: &Self) -> bool {
5561         self.Use == other.Use && self.Name == other.Name && self.DomainIndex == other.DomainIndex
5562     }
5563 }
5564 #[cfg(feature = "Win32_Foundation")]
5565 impl ::std::cmp::Eq for LSA_TRANSLATED_NAME {}
5566 #[cfg(feature = "Win32_Foundation")]
5567 unsafe impl ::windows::runtime::Abi for LSA_TRANSLATED_NAME {
5568     type Abi = Self;
5569     type DefaultType = Self;
5570 }
5571 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5572 #[repr(C)]
5573 pub struct LSA_TRANSLATED_SID {
5574     pub Use: super::super::SID_NAME_USE,
5575     pub RelativeId: u32,
5576     pub DomainIndex: i32,
5577 }
5578 impl LSA_TRANSLATED_SID {}
5579 impl ::std::default::Default for LSA_TRANSLATED_SID {
5580     fn default() -> Self {
5581         unsafe { ::std::mem::zeroed() }
5582     }
5583 }
5584 impl ::std::fmt::Debug for LSA_TRANSLATED_SID {
5585     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5586         fmt.debug_struct("LSA_TRANSLATED_SID").field("Use", &self.Use).field("RelativeId", &self.RelativeId).field("DomainIndex", &self.DomainIndex).finish()
5587     }
5588 }
5589 impl ::std::cmp::PartialEq for LSA_TRANSLATED_SID {
5590     fn eq(&self, other: &Self) -> bool {
5591         self.Use == other.Use && self.RelativeId == other.RelativeId && self.DomainIndex == other.DomainIndex
5592     }
5593 }
5594 impl ::std::cmp::Eq for LSA_TRANSLATED_SID {}
5595 unsafe impl ::windows::runtime::Abi for LSA_TRANSLATED_SID {
5596     type Abi = Self;
5597     type DefaultType = Self;
5598 }
5599 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5600 #[repr(C)]
5601 #[cfg(feature = "Win32_Foundation")]
5602 pub struct LSA_TRANSLATED_SID2 {
5603     pub Use: super::super::SID_NAME_USE,
5604     pub Sid: super::super::super::Foundation::PSID,
5605     pub DomainIndex: i32,
5606     pub Flags: u32,
5607 }
5608 #[cfg(feature = "Win32_Foundation")]
5609 impl LSA_TRANSLATED_SID2 {}
5610 #[cfg(feature = "Win32_Foundation")]
5611 impl ::std::default::Default for LSA_TRANSLATED_SID2 {
5612     fn default() -> Self {
5613         unsafe { ::std::mem::zeroed() }
5614     }
5615 }
5616 #[cfg(feature = "Win32_Foundation")]
5617 impl ::std::fmt::Debug for LSA_TRANSLATED_SID2 {
5618     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5619         fmt.debug_struct("LSA_TRANSLATED_SID2").field("Use", &self.Use).field("Sid", &self.Sid).field("DomainIndex", &self.DomainIndex).field("Flags", &self.Flags).finish()
5620     }
5621 }
5622 #[cfg(feature = "Win32_Foundation")]
5623 impl ::std::cmp::PartialEq for LSA_TRANSLATED_SID2 {
5624     fn eq(&self, other: &Self) -> bool {
5625         self.Use == other.Use && self.Sid == other.Sid && self.DomainIndex == other.DomainIndex && self.Flags == other.Flags
5626     }
5627 }
5628 #[cfg(feature = "Win32_Foundation")]
5629 impl ::std::cmp::Eq for LSA_TRANSLATED_SID2 {}
5630 #[cfg(feature = "Win32_Foundation")]
5631 unsafe impl ::windows::runtime::Abi for LSA_TRANSLATED_SID2 {
5632     type Abi = Self;
5633     type DefaultType = Self;
5634 }
5635 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5636 #[repr(C)]
5637 #[cfg(feature = "Win32_Foundation")]
5638 pub struct LSA_TRUST_INFORMATION {
5639     pub Name: super::super::super::Foundation::UNICODE_STRING,
5640     pub Sid: super::super::super::Foundation::PSID,
5641 }
5642 #[cfg(feature = "Win32_Foundation")]
5643 impl LSA_TRUST_INFORMATION {}
5644 #[cfg(feature = "Win32_Foundation")]
5645 impl ::std::default::Default for LSA_TRUST_INFORMATION {
5646     fn default() -> Self {
5647         unsafe { ::std::mem::zeroed() }
5648     }
5649 }
5650 #[cfg(feature = "Win32_Foundation")]
5651 impl ::std::fmt::Debug for LSA_TRUST_INFORMATION {
5652     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5653         fmt.debug_struct("LSA_TRUST_INFORMATION").field("Name", &self.Name).field("Sid", &self.Sid).finish()
5654     }
5655 }
5656 #[cfg(feature = "Win32_Foundation")]
5657 impl ::std::cmp::PartialEq for LSA_TRUST_INFORMATION {
5658     fn eq(&self, other: &Self) -> bool {
5659         self.Name == other.Name && self.Sid == other.Sid
5660     }
5661 }
5662 #[cfg(feature = "Win32_Foundation")]
5663 impl ::std::cmp::Eq for LSA_TRUST_INFORMATION {}
5664 #[cfg(feature = "Win32_Foundation")]
5665 unsafe impl ::windows::runtime::Abi for LSA_TRUST_INFORMATION {
5666     type Abi = Self;
5667     type DefaultType = Self;
5668 }
5669 #[cfg(feature = "Win32_Foundation")]
5670 #[inline]
5671 pub unsafe fn LsaAddAccountRights<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSID>>(policyhandle: *const ::std::ffi::c_void, accountsid: Param1, userrights: *const super::super::super::Foundation::UNICODE_STRING, countofrights: u32) -> ::windows::runtime::Result<()> {
5672     #[cfg(windows)]
5673     {
5674         #[link(name = "windows")]
5675         extern "system" {
5676             fn LsaAddAccountRights(policyhandle: *const ::std::ffi::c_void, accountsid: super::super::super::Foundation::PSID, userrights: *const super::super::super::Foundation::UNICODE_STRING, countofrights: u32) -> super::super::super::Foundation::NTSTATUS;
5677         }
5678         LsaAddAccountRights(::std::mem::transmute(policyhandle), accountsid.into_param().abi(), ::std::mem::transmute(userrights), ::std::mem::transmute(countofrights)).ok()
5679     }
5680     #[cfg(not(windows))]
5681     unimplemented!("Unsupported target OS");
5682 }
5683 #[cfg(feature = "Win32_Foundation")]
5684 #[inline]
5685 pub unsafe fn LsaCallAuthenticationPackage<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HANDLE>>(lsahandle: Param0, authenticationpackage: u32, protocolsubmitbuffer: *const ::std::ffi::c_void, submitbufferlength: u32, protocolreturnbuffer: *mut *mut ::std::ffi::c_void, returnbufferlength: *mut u32, protocolstatus: *mut i32) -> ::windows::runtime::Result<()> {
5686     #[cfg(windows)]
5687     {
5688         #[link(name = "windows")]
5689         extern "system" {
5690             fn LsaCallAuthenticationPackage(lsahandle: super::super::super::Foundation::HANDLE, authenticationpackage: u32, protocolsubmitbuffer: *const ::std::ffi::c_void, submitbufferlength: u32, protocolreturnbuffer: *mut *mut ::std::ffi::c_void, returnbufferlength: *mut u32, protocolstatus: *mut i32) -> super::super::super::Foundation::NTSTATUS;
5691         }
5692         LsaCallAuthenticationPackage(lsahandle.into_param().abi(), ::std::mem::transmute(authenticationpackage), ::std::mem::transmute(protocolsubmitbuffer), ::std::mem::transmute(submitbufferlength), ::std::mem::transmute(protocolreturnbuffer), ::std::mem::transmute(returnbufferlength), ::std::mem::transmute(protocolstatus)).ok()
5693     }
5694     #[cfg(not(windows))]
5695     unimplemented!("Unsupported target OS");
5696 }
5697 #[cfg(feature = "Win32_Foundation")]
5698 #[inline]
5699 pub unsafe fn LsaClose(objecthandle: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
5700     #[cfg(windows)]
5701     {
5702         #[link(name = "windows")]
5703         extern "system" {
5704             fn LsaClose(objecthandle: *const ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
5705         }
5706         LsaClose(::std::mem::transmute(objecthandle)).ok()
5707     }
5708     #[cfg(not(windows))]
5709     unimplemented!("Unsupported target OS");
5710 }
5711 #[cfg(feature = "Win32_Foundation")]
5712 #[inline]
5713 pub unsafe fn LsaConnectUntrusted(lsahandle: *mut super::super::super::Foundation::HANDLE) -> ::windows::runtime::Result<()> {
5714     #[cfg(windows)]
5715     {
5716         #[link(name = "windows")]
5717         extern "system" {
5718             fn LsaConnectUntrusted(lsahandle: *mut super::super::super::Foundation::HANDLE) -> super::super::super::Foundation::NTSTATUS;
5719         }
5720         LsaConnectUntrusted(::std::mem::transmute(lsahandle)).ok()
5721     }
5722     #[cfg(not(windows))]
5723     unimplemented!("Unsupported target OS");
5724 }
5725 #[cfg(feature = "Win32_Foundation")]
5726 #[inline]
5727 pub unsafe fn LsaCreateTrustedDomainEx(policyhandle: *const ::std::ffi::c_void, trusteddomaininformation: *const TRUSTED_DOMAIN_INFORMATION_EX, authenticationinformation: *const TRUSTED_DOMAIN_AUTH_INFORMATION, desiredaccess: u32, trusteddomainhandle: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
5728     #[cfg(windows)]
5729     {
5730         #[link(name = "windows")]
5731         extern "system" {
5732             fn LsaCreateTrustedDomainEx(policyhandle: *const ::std::ffi::c_void, trusteddomaininformation: *const TRUSTED_DOMAIN_INFORMATION_EX, authenticationinformation: *const TRUSTED_DOMAIN_AUTH_INFORMATION, desiredaccess: u32, trusteddomainhandle: *mut *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
5733         }
5734         LsaCreateTrustedDomainEx(::std::mem::transmute(policyhandle), ::std::mem::transmute(trusteddomaininformation), ::std::mem::transmute(authenticationinformation), ::std::mem::transmute(desiredaccess), ::std::mem::transmute(trusteddomainhandle)).ok()
5735     }
5736     #[cfg(not(windows))]
5737     unimplemented!("Unsupported target OS");
5738 }
5739 #[cfg(feature = "Win32_Foundation")]
5740 #[inline]
5741 pub unsafe fn LsaDeleteTrustedDomain<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSID>>(policyhandle: *const ::std::ffi::c_void, trusteddomainsid: Param1) -> ::windows::runtime::Result<()> {
5742     #[cfg(windows)]
5743     {
5744         #[link(name = "windows")]
5745         extern "system" {
5746             fn LsaDeleteTrustedDomain(policyhandle: *const ::std::ffi::c_void, trusteddomainsid: super::super::super::Foundation::PSID) -> super::super::super::Foundation::NTSTATUS;
5747         }
5748         LsaDeleteTrustedDomain(::std::mem::transmute(policyhandle), trusteddomainsid.into_param().abi()).ok()
5749     }
5750     #[cfg(not(windows))]
5751     unimplemented!("Unsupported target OS");
5752 }
5753 #[cfg(feature = "Win32_Foundation")]
5754 #[inline]
5755 pub unsafe fn LsaDeregisterLogonProcess<'a, Param0: ::windows::runtime::IntoParam<'a, LsaHandle>>(lsahandle: Param0) -> ::windows::runtime::Result<()> {
5756     #[cfg(windows)]
5757     {
5758         #[link(name = "windows")]
5759         extern "system" {
5760             fn LsaDeregisterLogonProcess(lsahandle: LsaHandle) -> super::super::super::Foundation::NTSTATUS;
5761         }
5762         LsaDeregisterLogonProcess(lsahandle.into_param().abi()).ok()
5763     }
5764     #[cfg(not(windows))]
5765     unimplemented!("Unsupported target OS");
5766 }
5767 #[cfg(feature = "Win32_Foundation")]
5768 #[inline]
5769 pub unsafe fn LsaEnumerateAccountRights<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSID>>(policyhandle: *const ::std::ffi::c_void, accountsid: Param1, userrights: *mut *mut super::super::super::Foundation::UNICODE_STRING, countofrights: *mut u32) -> ::windows::runtime::Result<()> {
5770     #[cfg(windows)]
5771     {
5772         #[link(name = "windows")]
5773         extern "system" {
5774             fn LsaEnumerateAccountRights(policyhandle: *const ::std::ffi::c_void, accountsid: super::super::super::Foundation::PSID, userrights: *mut *mut super::super::super::Foundation::UNICODE_STRING, countofrights: *mut u32) -> super::super::super::Foundation::NTSTATUS;
5775         }
5776         LsaEnumerateAccountRights(::std::mem::transmute(policyhandle), accountsid.into_param().abi(), ::std::mem::transmute(userrights), ::std::mem::transmute(countofrights)).ok()
5777     }
5778     #[cfg(not(windows))]
5779     unimplemented!("Unsupported target OS");
5780 }
5781 #[cfg(feature = "Win32_Foundation")]
5782 #[inline]
5783 pub unsafe fn LsaEnumerateAccountsWithUserRight(policyhandle: *const ::std::ffi::c_void, userright: *const super::super::super::Foundation::UNICODE_STRING, buffer: *mut *mut ::std::ffi::c_void, countreturned: *mut u32) -> ::windows::runtime::Result<()> {
5784     #[cfg(windows)]
5785     {
5786         #[link(name = "windows")]
5787         extern "system" {
5788             fn LsaEnumerateAccountsWithUserRight(policyhandle: *const ::std::ffi::c_void, userright: *const super::super::super::Foundation::UNICODE_STRING, buffer: *mut *mut ::std::ffi::c_void, countreturned: *mut u32) -> super::super::super::Foundation::NTSTATUS;
5789         }
5790         LsaEnumerateAccountsWithUserRight(::std::mem::transmute(policyhandle), ::std::mem::transmute(userright), ::std::mem::transmute(buffer), ::std::mem::transmute(countreturned)).ok()
5791     }
5792     #[cfg(not(windows))]
5793     unimplemented!("Unsupported target OS");
5794 }
5795 #[cfg(feature = "Win32_Foundation")]
5796 #[inline]
5797 pub unsafe fn LsaEnumerateLogonSessions(logonsessioncount: *mut u32, logonsessionlist: *mut *mut super::super::super::Foundation::LUID) -> ::windows::runtime::Result<()> {
5798     #[cfg(windows)]
5799     {
5800         #[link(name = "windows")]
5801         extern "system" {
5802             fn LsaEnumerateLogonSessions(logonsessioncount: *mut u32, logonsessionlist: *mut *mut super::super::super::Foundation::LUID) -> super::super::super::Foundation::NTSTATUS;
5803         }
5804         LsaEnumerateLogonSessions(::std::mem::transmute(logonsessioncount), ::std::mem::transmute(logonsessionlist)).ok()
5805     }
5806     #[cfg(not(windows))]
5807     unimplemented!("Unsupported target OS");
5808 }
5809 #[cfg(feature = "Win32_Foundation")]
5810 #[inline]
5811 pub unsafe fn LsaEnumerateTrustedDomains(policyhandle: *const ::std::ffi::c_void, enumerationcontext: *mut u32, buffer: *mut *mut ::std::ffi::c_void, preferedmaximumlength: u32, countreturned: *mut u32) -> ::windows::runtime::Result<()> {
5812     #[cfg(windows)]
5813     {
5814         #[link(name = "windows")]
5815         extern "system" {
5816             fn LsaEnumerateTrustedDomains(policyhandle: *const ::std::ffi::c_void, enumerationcontext: *mut u32, buffer: *mut *mut ::std::ffi::c_void, preferedmaximumlength: u32, countreturned: *mut u32) -> super::super::super::Foundation::NTSTATUS;
5817         }
5818         LsaEnumerateTrustedDomains(::std::mem::transmute(policyhandle), ::std::mem::transmute(enumerationcontext), ::std::mem::transmute(buffer), ::std::mem::transmute(preferedmaximumlength), ::std::mem::transmute(countreturned)).ok()
5819     }
5820     #[cfg(not(windows))]
5821     unimplemented!("Unsupported target OS");
5822 }
5823 #[cfg(feature = "Win32_Foundation")]
5824 #[inline]
5825 pub unsafe fn LsaEnumerateTrustedDomainsEx(policyhandle: *const ::std::ffi::c_void, enumerationcontext: *mut u32, buffer: *mut *mut ::std::ffi::c_void, preferedmaximumlength: u32, countreturned: *mut u32) -> ::windows::runtime::Result<()> {
5826     #[cfg(windows)]
5827     {
5828         #[link(name = "windows")]
5829         extern "system" {
5830             fn LsaEnumerateTrustedDomainsEx(policyhandle: *const ::std::ffi::c_void, enumerationcontext: *mut u32, buffer: *mut *mut ::std::ffi::c_void, preferedmaximumlength: u32, countreturned: *mut u32) -> super::super::super::Foundation::NTSTATUS;
5831         }
5832         LsaEnumerateTrustedDomainsEx(::std::mem::transmute(policyhandle), ::std::mem::transmute(enumerationcontext), ::std::mem::transmute(buffer), ::std::mem::transmute(preferedmaximumlength), ::std::mem::transmute(countreturned)).ok()
5833     }
5834     #[cfg(not(windows))]
5835     unimplemented!("Unsupported target OS");
5836 }
5837 #[cfg(feature = "Win32_Foundation")]
5838 #[inline]
5839 pub unsafe fn LsaFreeMemory(buffer: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
5840     #[cfg(windows)]
5841     {
5842         #[link(name = "windows")]
5843         extern "system" {
5844             fn LsaFreeMemory(buffer: *const ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
5845         }
5846         LsaFreeMemory(::std::mem::transmute(buffer)).ok()
5847     }
5848     #[cfg(not(windows))]
5849     unimplemented!("Unsupported target OS");
5850 }
5851 #[cfg(feature = "Win32_Foundation")]
5852 #[inline]
5853 pub unsafe fn LsaFreeReturnBuffer(buffer: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
5854     #[cfg(windows)]
5855     {
5856         #[link(name = "windows")]
5857         extern "system" {
5858             fn LsaFreeReturnBuffer(buffer: *const ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
5859         }
5860         LsaFreeReturnBuffer(::std::mem::transmute(buffer)).ok()
5861     }
5862     #[cfg(not(windows))]
5863     unimplemented!("Unsupported target OS");
5864 }
5865 #[cfg(feature = "Win32_Foundation")]
5866 #[inline]
5867 pub unsafe fn LsaGetAppliedCAPIDs(systemname: *const super::super::super::Foundation::UNICODE_STRING, capids: *mut *mut super::super::super::Foundation::PSID, capidcount: *mut u32) -> ::windows::runtime::Result<()> {
5868     #[cfg(windows)]
5869     {
5870         #[link(name = "windows")]
5871         extern "system" {
5872             fn LsaGetAppliedCAPIDs(systemname: *const super::super::super::Foundation::UNICODE_STRING, capids: *mut *mut super::super::super::Foundation::PSID, capidcount: *mut u32) -> super::super::super::Foundation::NTSTATUS;
5873         }
5874         LsaGetAppliedCAPIDs(::std::mem::transmute(systemname), ::std::mem::transmute(capids), ::std::mem::transmute(capidcount)).ok()
5875     }
5876     #[cfg(not(windows))]
5877     unimplemented!("Unsupported target OS");
5878 }
5879 #[cfg(feature = "Win32_Foundation")]
5880 #[inline]
5881 pub unsafe fn LsaGetLogonSessionData(logonid: *const super::super::super::Foundation::LUID, pplogonsessiondata: *mut *mut SECURITY_LOGON_SESSION_DATA) -> ::windows::runtime::Result<()> {
5882     #[cfg(windows)]
5883     {
5884         #[link(name = "windows")]
5885         extern "system" {
5886             fn LsaGetLogonSessionData(logonid: *const super::super::super::Foundation::LUID, pplogonsessiondata: *mut *mut SECURITY_LOGON_SESSION_DATA) -> super::super::super::Foundation::NTSTATUS;
5887         }
5888         LsaGetLogonSessionData(::std::mem::transmute(logonid), ::std::mem::transmute(pplogonsessiondata)).ok()
5889     }
5890     #[cfg(not(windows))]
5891     unimplemented!("Unsupported target OS");
5892 }
5893 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
5894 #[repr(transparent)]
5895 pub struct LsaHandle(pub isize);
5896 impl ::std::default::Default for LsaHandle {
5897     fn default() -> Self {
5898         unsafe { ::std::mem::zeroed() }
5899     }
5900 }
5901 unsafe impl ::windows::runtime::Handle for LsaHandle {}
5902 unsafe impl ::windows::runtime::Abi for LsaHandle {
5903     type Abi = Self;
5904     type DefaultType = Self;
5905 }
5906 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
5907 #[inline]
5908 pub unsafe fn LsaLogonUser<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HANDLE>>(
5909     lsahandle: Param0,
5910     originname: *const super::super::super::System::Kernel::STRING,
5911     logontype: SECURITY_LOGON_TYPE,
5912     authenticationpackage: u32,
5913     authenticationinformation: *const ::std::ffi::c_void,
5914     authenticationinformationlength: u32,
5915     localgroups: *const super::super::TOKEN_GROUPS,
5916     sourcecontext: *const super::super::TOKEN_SOURCE,
5917     profilebuffer: *mut *mut ::std::ffi::c_void,
5918     profilebufferlength: *mut u32,
5919     logonid: *mut super::super::super::Foundation::LUID,
5920     token: *mut super::super::super::Foundation::HANDLE,
5921     quotas: *mut super::super::QUOTA_LIMITS,
5922     substatus: *mut i32,
5923 ) -> ::windows::runtime::Result<()> {
5924     #[cfg(windows)]
5925     {
5926         #[link(name = "windows")]
5927         extern "system" {
5928             fn LsaLogonUser(
5929                 lsahandle: super::super::super::Foundation::HANDLE,
5930                 originname: *const super::super::super::System::Kernel::STRING,
5931                 logontype: SECURITY_LOGON_TYPE,
5932                 authenticationpackage: u32,
5933                 authenticationinformation: *const ::std::ffi::c_void,
5934                 authenticationinformationlength: u32,
5935                 localgroups: *const super::super::TOKEN_GROUPS,
5936                 sourcecontext: *const super::super::TOKEN_SOURCE,
5937                 profilebuffer: *mut *mut ::std::ffi::c_void,
5938                 profilebufferlength: *mut u32,
5939                 logonid: *mut super::super::super::Foundation::LUID,
5940                 token: *mut super::super::super::Foundation::HANDLE,
5941                 quotas: *mut super::super::QUOTA_LIMITS,
5942                 substatus: *mut i32,
5943             ) -> super::super::super::Foundation::NTSTATUS;
5944         }
5945         LsaLogonUser(
5946             lsahandle.into_param().abi(),
5947             ::std::mem::transmute(originname),
5948             ::std::mem::transmute(logontype),
5949             ::std::mem::transmute(authenticationpackage),
5950             ::std::mem::transmute(authenticationinformation),
5951             ::std::mem::transmute(authenticationinformationlength),
5952             ::std::mem::transmute(localgroups),
5953             ::std::mem::transmute(sourcecontext),
5954             ::std::mem::transmute(profilebuffer),
5955             ::std::mem::transmute(profilebufferlength),
5956             ::std::mem::transmute(logonid),
5957             ::std::mem::transmute(token),
5958             ::std::mem::transmute(quotas),
5959             ::std::mem::transmute(substatus),
5960         )
5961         .ok()
5962     }
5963     #[cfg(not(windows))]
5964     unimplemented!("Unsupported target OS");
5965 }
5966 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
5967 #[inline]
5968 pub unsafe fn LsaLookupAuthenticationPackage<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HANDLE>>(lsahandle: Param0, packagename: *const super::super::super::System::Kernel::STRING, authenticationpackage: *mut u32) -> ::windows::runtime::Result<()> {
5969     #[cfg(windows)]
5970     {
5971         #[link(name = "windows")]
5972         extern "system" {
5973             fn LsaLookupAuthenticationPackage(lsahandle: super::super::super::Foundation::HANDLE, packagename: *const super::super::super::System::Kernel::STRING, authenticationpackage: *mut u32) -> super::super::super::Foundation::NTSTATUS;
5974         }
5975         LsaLookupAuthenticationPackage(lsahandle.into_param().abi(), ::std::mem::transmute(packagename), ::std::mem::transmute(authenticationpackage)).ok()
5976     }
5977     #[cfg(not(windows))]
5978     unimplemented!("Unsupported target OS");
5979 }
5980 #[cfg(feature = "Win32_Foundation")]
5981 #[inline]
5982 pub unsafe fn LsaLookupNames(policyhandle: *const ::std::ffi::c_void, count: u32, names: *const super::super::super::Foundation::UNICODE_STRING, referenceddomains: *mut *mut LSA_REFERENCED_DOMAIN_LIST, sids: *mut *mut LSA_TRANSLATED_SID) -> ::windows::runtime::Result<()> {
5983     #[cfg(windows)]
5984     {
5985         #[link(name = "windows")]
5986         extern "system" {
5987             fn LsaLookupNames(policyhandle: *const ::std::ffi::c_void, count: u32, names: *const super::super::super::Foundation::UNICODE_STRING, referenceddomains: *mut *mut LSA_REFERENCED_DOMAIN_LIST, sids: *mut *mut LSA_TRANSLATED_SID) -> super::super::super::Foundation::NTSTATUS;
5988         }
5989         LsaLookupNames(::std::mem::transmute(policyhandle), ::std::mem::transmute(count), ::std::mem::transmute(names), ::std::mem::transmute(referenceddomains), ::std::mem::transmute(sids)).ok()
5990     }
5991     #[cfg(not(windows))]
5992     unimplemented!("Unsupported target OS");
5993 }
5994 #[cfg(feature = "Win32_Foundation")]
5995 #[inline]
5996 pub unsafe fn LsaLookupNames2(policyhandle: *const ::std::ffi::c_void, flags: u32, count: u32, names: *const super::super::super::Foundation::UNICODE_STRING, referenceddomains: *mut *mut LSA_REFERENCED_DOMAIN_LIST, sids: *mut *mut LSA_TRANSLATED_SID2) -> ::windows::runtime::Result<()> {
5997     #[cfg(windows)]
5998     {
5999         #[link(name = "windows")]
6000         extern "system" {
6001             fn LsaLookupNames2(policyhandle: *const ::std::ffi::c_void, flags: u32, count: u32, names: *const super::super::super::Foundation::UNICODE_STRING, referenceddomains: *mut *mut LSA_REFERENCED_DOMAIN_LIST, sids: *mut *mut LSA_TRANSLATED_SID2) -> super::super::super::Foundation::NTSTATUS;
6002         }
6003         LsaLookupNames2(::std::mem::transmute(policyhandle), ::std::mem::transmute(flags), ::std::mem::transmute(count), ::std::mem::transmute(names), ::std::mem::transmute(referenceddomains), ::std::mem::transmute(sids)).ok()
6004     }
6005     #[cfg(not(windows))]
6006     unimplemented!("Unsupported target OS");
6007 }
6008 #[cfg(feature = "Win32_Foundation")]
6009 #[inline]
6010 pub unsafe fn LsaLookupSids(policyhandle: *const ::std::ffi::c_void, count: u32, sids: *const super::super::super::Foundation::PSID, referenceddomains: *mut *mut LSA_REFERENCED_DOMAIN_LIST, names: *mut *mut LSA_TRANSLATED_NAME) -> ::windows::runtime::Result<()> {
6011     #[cfg(windows)]
6012     {
6013         #[link(name = "windows")]
6014         extern "system" {
6015             fn LsaLookupSids(policyhandle: *const ::std::ffi::c_void, count: u32, sids: *const super::super::super::Foundation::PSID, referenceddomains: *mut *mut LSA_REFERENCED_DOMAIN_LIST, names: *mut *mut LSA_TRANSLATED_NAME) -> super::super::super::Foundation::NTSTATUS;
6016         }
6017         LsaLookupSids(::std::mem::transmute(policyhandle), ::std::mem::transmute(count), ::std::mem::transmute(sids), ::std::mem::transmute(referenceddomains), ::std::mem::transmute(names)).ok()
6018     }
6019     #[cfg(not(windows))]
6020     unimplemented!("Unsupported target OS");
6021 }
6022 #[cfg(feature = "Win32_Foundation")]
6023 #[inline]
6024 pub unsafe fn LsaLookupSids2(policyhandle: *const ::std::ffi::c_void, lookupoptions: u32, count: u32, sids: *const super::super::super::Foundation::PSID, referenceddomains: *mut *mut LSA_REFERENCED_DOMAIN_LIST, names: *mut *mut LSA_TRANSLATED_NAME) -> ::windows::runtime::Result<()> {
6025     #[cfg(windows)]
6026     {
6027         #[link(name = "windows")]
6028         extern "system" {
6029             fn LsaLookupSids2(policyhandle: *const ::std::ffi::c_void, lookupoptions: u32, count: u32, sids: *const super::super::super::Foundation::PSID, referenceddomains: *mut *mut LSA_REFERENCED_DOMAIN_LIST, names: *mut *mut LSA_TRANSLATED_NAME) -> super::super::super::Foundation::NTSTATUS;
6030         }
6031         LsaLookupSids2(::std::mem::transmute(policyhandle), ::std::mem::transmute(lookupoptions), ::std::mem::transmute(count), ::std::mem::transmute(sids), ::std::mem::transmute(referenceddomains), ::std::mem::transmute(names)).ok()
6032     }
6033     #[cfg(not(windows))]
6034     unimplemented!("Unsupported target OS");
6035 }
6036 #[cfg(feature = "Win32_Foundation")]
6037 #[inline]
6038 pub unsafe fn LsaNtStatusToWinError<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::NTSTATUS>>(status: Param0) -> u32 {
6039     #[cfg(windows)]
6040     {
6041         #[link(name = "windows")]
6042         extern "system" {
6043             fn LsaNtStatusToWinError(status: super::super::super::Foundation::NTSTATUS) -> u32;
6044         }
6045         ::std::mem::transmute(LsaNtStatusToWinError(status.into_param().abi()))
6046     }
6047     #[cfg(not(windows))]
6048     unimplemented!("Unsupported target OS");
6049 }
6050 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_WindowsProgramming"))]
6051 #[inline]
6052 pub unsafe fn LsaOpenPolicy(systemname: *const super::super::super::Foundation::UNICODE_STRING, objectattributes: *const super::super::super::System::WindowsProgramming::OBJECT_ATTRIBUTES, desiredaccess: u32, policyhandle: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6053     #[cfg(windows)]
6054     {
6055         #[link(name = "windows")]
6056         extern "system" {
6057             fn LsaOpenPolicy(systemname: *const super::super::super::Foundation::UNICODE_STRING, objectattributes: *const super::super::super::System::WindowsProgramming::OBJECT_ATTRIBUTES, desiredaccess: u32, policyhandle: *mut *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
6058         }
6059         LsaOpenPolicy(::std::mem::transmute(systemname), ::std::mem::transmute(objectattributes), ::std::mem::transmute(desiredaccess), ::std::mem::transmute(policyhandle)).ok()
6060     }
6061     #[cfg(not(windows))]
6062     unimplemented!("Unsupported target OS");
6063 }
6064 #[cfg(feature = "Win32_Foundation")]
6065 #[inline]
6066 pub unsafe fn LsaOpenTrustedDomainByName(policyhandle: *const ::std::ffi::c_void, trusteddomainname: *const super::super::super::Foundation::UNICODE_STRING, desiredaccess: u32, trusteddomainhandle: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6067     #[cfg(windows)]
6068     {
6069         #[link(name = "windows")]
6070         extern "system" {
6071             fn LsaOpenTrustedDomainByName(policyhandle: *const ::std::ffi::c_void, trusteddomainname: *const super::super::super::Foundation::UNICODE_STRING, desiredaccess: u32, trusteddomainhandle: *mut *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
6072         }
6073         LsaOpenTrustedDomainByName(::std::mem::transmute(policyhandle), ::std::mem::transmute(trusteddomainname), ::std::mem::transmute(desiredaccess), ::std::mem::transmute(trusteddomainhandle)).ok()
6074     }
6075     #[cfg(not(windows))]
6076     unimplemented!("Unsupported target OS");
6077 }
6078 #[cfg(feature = "Win32_Foundation")]
6079 #[inline]
6080 pub unsafe fn LsaQueryCAPs(capids: *const super::super::super::Foundation::PSID, capidcount: u32, caps: *mut *mut CENTRAL_ACCESS_POLICY, capcount: *mut u32) -> ::windows::runtime::Result<()> {
6081     #[cfg(windows)]
6082     {
6083         #[link(name = "windows")]
6084         extern "system" {
6085             fn LsaQueryCAPs(capids: *const super::super::super::Foundation::PSID, capidcount: u32, caps: *mut *mut CENTRAL_ACCESS_POLICY, capcount: *mut u32) -> super::super::super::Foundation::NTSTATUS;
6086         }
6087         LsaQueryCAPs(::std::mem::transmute(capids), ::std::mem::transmute(capidcount), ::std::mem::transmute(caps), ::std::mem::transmute(capcount)).ok()
6088     }
6089     #[cfg(not(windows))]
6090     unimplemented!("Unsupported target OS");
6091 }
6092 #[cfg(feature = "Win32_Foundation")]
6093 #[inline]
6094 pub unsafe fn LsaQueryDomainInformationPolicy(policyhandle: *const ::std::ffi::c_void, informationclass: POLICY_DOMAIN_INFORMATION_CLASS, buffer: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6095     #[cfg(windows)]
6096     {
6097         #[link(name = "windows")]
6098         extern "system" {
6099             fn LsaQueryDomainInformationPolicy(policyhandle: *const ::std::ffi::c_void, informationclass: POLICY_DOMAIN_INFORMATION_CLASS, buffer: *mut *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
6100         }
6101         LsaQueryDomainInformationPolicy(::std::mem::transmute(policyhandle), ::std::mem::transmute(informationclass), ::std::mem::transmute(buffer)).ok()
6102     }
6103     #[cfg(not(windows))]
6104     unimplemented!("Unsupported target OS");
6105 }
6106 #[cfg(feature = "Win32_Foundation")]
6107 #[inline]
6108 pub unsafe fn LsaQueryForestTrustInformation(policyhandle: *const ::std::ffi::c_void, trusteddomainname: *const super::super::super::Foundation::UNICODE_STRING, foresttrustinfo: *mut *mut LSA_FOREST_TRUST_INFORMATION) -> ::windows::runtime::Result<()> {
6109     #[cfg(windows)]
6110     {
6111         #[link(name = "windows")]
6112         extern "system" {
6113             fn LsaQueryForestTrustInformation(policyhandle: *const ::std::ffi::c_void, trusteddomainname: *const super::super::super::Foundation::UNICODE_STRING, foresttrustinfo: *mut *mut LSA_FOREST_TRUST_INFORMATION) -> super::super::super::Foundation::NTSTATUS;
6114         }
6115         LsaQueryForestTrustInformation(::std::mem::transmute(policyhandle), ::std::mem::transmute(trusteddomainname), ::std::mem::transmute(foresttrustinfo)).ok()
6116     }
6117     #[cfg(not(windows))]
6118     unimplemented!("Unsupported target OS");
6119 }
6120 #[cfg(feature = "Win32_Foundation")]
6121 #[inline]
6122 pub unsafe fn LsaQueryInformationPolicy(policyhandle: *const ::std::ffi::c_void, informationclass: POLICY_INFORMATION_CLASS, buffer: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6123     #[cfg(windows)]
6124     {
6125         #[link(name = "windows")]
6126         extern "system" {
6127             fn LsaQueryInformationPolicy(policyhandle: *const ::std::ffi::c_void, informationclass: POLICY_INFORMATION_CLASS, buffer: *mut *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
6128         }
6129         LsaQueryInformationPolicy(::std::mem::transmute(policyhandle), ::std::mem::transmute(informationclass), ::std::mem::transmute(buffer)).ok()
6130     }
6131     #[cfg(not(windows))]
6132     unimplemented!("Unsupported target OS");
6133 }
6134 #[cfg(feature = "Win32_Foundation")]
6135 #[inline]
6136 pub unsafe fn LsaQueryTrustedDomainInfo<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSID>>(policyhandle: *const ::std::ffi::c_void, trusteddomainsid: Param1, informationclass: TRUSTED_INFORMATION_CLASS, buffer: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6137     #[cfg(windows)]
6138     {
6139         #[link(name = "windows")]
6140         extern "system" {
6141             fn LsaQueryTrustedDomainInfo(policyhandle: *const ::std::ffi::c_void, trusteddomainsid: super::super::super::Foundation::PSID, informationclass: TRUSTED_INFORMATION_CLASS, buffer: *mut *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
6142         }
6143         LsaQueryTrustedDomainInfo(::std::mem::transmute(policyhandle), trusteddomainsid.into_param().abi(), ::std::mem::transmute(informationclass), ::std::mem::transmute(buffer)).ok()
6144     }
6145     #[cfg(not(windows))]
6146     unimplemented!("Unsupported target OS");
6147 }
6148 #[cfg(feature = "Win32_Foundation")]
6149 #[inline]
6150 pub unsafe fn LsaQueryTrustedDomainInfoByName(policyhandle: *const ::std::ffi::c_void, trusteddomainname: *const super::super::super::Foundation::UNICODE_STRING, informationclass: TRUSTED_INFORMATION_CLASS, buffer: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6151     #[cfg(windows)]
6152     {
6153         #[link(name = "windows")]
6154         extern "system" {
6155             fn LsaQueryTrustedDomainInfoByName(policyhandle: *const ::std::ffi::c_void, trusteddomainname: *const super::super::super::Foundation::UNICODE_STRING, informationclass: TRUSTED_INFORMATION_CLASS, buffer: *mut *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
6156         }
6157         LsaQueryTrustedDomainInfoByName(::std::mem::transmute(policyhandle), ::std::mem::transmute(trusteddomainname), ::std::mem::transmute(informationclass), ::std::mem::transmute(buffer)).ok()
6158     }
6159     #[cfg(not(windows))]
6160     unimplemented!("Unsupported target OS");
6161 }
6162 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
6163 #[inline]
6164 pub unsafe fn LsaRegisterLogonProcess(logonprocessname: *const super::super::super::System::Kernel::STRING, lsahandle: *mut LsaHandle, securitymode: *mut u32) -> ::windows::runtime::Result<()> {
6165     #[cfg(windows)]
6166     {
6167         #[link(name = "windows")]
6168         extern "system" {
6169             fn LsaRegisterLogonProcess(logonprocessname: *const super::super::super::System::Kernel::STRING, lsahandle: *mut LsaHandle, securitymode: *mut u32) -> super::super::super::Foundation::NTSTATUS;
6170         }
6171         LsaRegisterLogonProcess(::std::mem::transmute(logonprocessname), ::std::mem::transmute(lsahandle), ::std::mem::transmute(securitymode)).ok()
6172     }
6173     #[cfg(not(windows))]
6174     unimplemented!("Unsupported target OS");
6175 }
6176 #[cfg(feature = "Win32_Foundation")]
6177 #[inline]
6178 pub unsafe fn LsaRegisterPolicyChangeNotification<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HANDLE>>(informationclass: POLICY_NOTIFICATION_INFORMATION_CLASS, notificationeventhandle: Param1) -> ::windows::runtime::Result<()> {
6179     #[cfg(windows)]
6180     {
6181         #[link(name = "windows")]
6182         extern "system" {
6183             fn LsaRegisterPolicyChangeNotification(informationclass: POLICY_NOTIFICATION_INFORMATION_CLASS, notificationeventhandle: super::super::super::Foundation::HANDLE) -> super::super::super::Foundation::NTSTATUS;
6184         }
6185         LsaRegisterPolicyChangeNotification(::std::mem::transmute(informationclass), notificationeventhandle.into_param().abi()).ok()
6186     }
6187     #[cfg(not(windows))]
6188     unimplemented!("Unsupported target OS");
6189 }
6190 #[cfg(feature = "Win32_Foundation")]
6191 #[inline]
6192 pub unsafe fn LsaRemoveAccountRights<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSID>, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOLEAN>>(policyhandle: *const ::std::ffi::c_void, accountsid: Param1, allrights: Param2, userrights: *const super::super::super::Foundation::UNICODE_STRING, countofrights: u32) -> ::windows::runtime::Result<()> {
6193     #[cfg(windows)]
6194     {
6195         #[link(name = "windows")]
6196         extern "system" {
6197             fn LsaRemoveAccountRights(policyhandle: *const ::std::ffi::c_void, accountsid: super::super::super::Foundation::PSID, allrights: super::super::super::Foundation::BOOLEAN, userrights: *const super::super::super::Foundation::UNICODE_STRING, countofrights: u32) -> super::super::super::Foundation::NTSTATUS;
6198         }
6199         LsaRemoveAccountRights(::std::mem::transmute(policyhandle), accountsid.into_param().abi(), allrights.into_param().abi(), ::std::mem::transmute(userrights), ::std::mem::transmute(countofrights)).ok()
6200     }
6201     #[cfg(not(windows))]
6202     unimplemented!("Unsupported target OS");
6203 }
6204 #[cfg(feature = "Win32_Foundation")]
6205 #[inline]
6206 pub unsafe fn LsaRetrievePrivateData(policyhandle: *const ::std::ffi::c_void, keyname: *const super::super::super::Foundation::UNICODE_STRING, privatedata: *mut *mut super::super::super::Foundation::UNICODE_STRING) -> ::windows::runtime::Result<()> {
6207     #[cfg(windows)]
6208     {
6209         #[link(name = "windows")]
6210         extern "system" {
6211             fn LsaRetrievePrivateData(policyhandle: *const ::std::ffi::c_void, keyname: *const super::super::super::Foundation::UNICODE_STRING, privatedata: *mut *mut super::super::super::Foundation::UNICODE_STRING) -> super::super::super::Foundation::NTSTATUS;
6212         }
6213         LsaRetrievePrivateData(::std::mem::transmute(policyhandle), ::std::mem::transmute(keyname), ::std::mem::transmute(privatedata)).ok()
6214     }
6215     #[cfg(not(windows))]
6216     unimplemented!("Unsupported target OS");
6217 }
6218 #[cfg(feature = "Win32_Foundation")]
6219 #[inline]
6220 pub unsafe fn LsaSetCAPs(capdns: *const super::super::super::Foundation::UNICODE_STRING, capdncount: u32, flags: u32) -> ::windows::runtime::Result<()> {
6221     #[cfg(windows)]
6222     {
6223         #[link(name = "windows")]
6224         extern "system" {
6225             fn LsaSetCAPs(capdns: *const super::super::super::Foundation::UNICODE_STRING, capdncount: u32, flags: u32) -> super::super::super::Foundation::NTSTATUS;
6226         }
6227         LsaSetCAPs(::std::mem::transmute(capdns), ::std::mem::transmute(capdncount), ::std::mem::transmute(flags)).ok()
6228     }
6229     #[cfg(not(windows))]
6230     unimplemented!("Unsupported target OS");
6231 }
6232 #[cfg(feature = "Win32_Foundation")]
6233 #[inline]
6234 pub unsafe fn LsaSetDomainInformationPolicy(policyhandle: *const ::std::ffi::c_void, informationclass: POLICY_DOMAIN_INFORMATION_CLASS, buffer: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6235     #[cfg(windows)]
6236     {
6237         #[link(name = "windows")]
6238         extern "system" {
6239             fn LsaSetDomainInformationPolicy(policyhandle: *const ::std::ffi::c_void, informationclass: POLICY_DOMAIN_INFORMATION_CLASS, buffer: *const ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
6240         }
6241         LsaSetDomainInformationPolicy(::std::mem::transmute(policyhandle), ::std::mem::transmute(informationclass), ::std::mem::transmute(buffer)).ok()
6242     }
6243     #[cfg(not(windows))]
6244     unimplemented!("Unsupported target OS");
6245 }
6246 #[cfg(feature = "Win32_Foundation")]
6247 #[inline]
6248 pub unsafe fn LsaSetForestTrustInformation<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOLEAN>>(policyhandle: *const ::std::ffi::c_void, trusteddomainname: *const super::super::super::Foundation::UNICODE_STRING, foresttrustinfo: *const LSA_FOREST_TRUST_INFORMATION, checkonly: Param3, collisioninfo: *mut *mut LSA_FOREST_TRUST_COLLISION_INFORMATION) -> ::windows::runtime::Result<()> {
6249     #[cfg(windows)]
6250     {
6251         #[link(name = "windows")]
6252         extern "system" {
6253             fn LsaSetForestTrustInformation(policyhandle: *const ::std::ffi::c_void, trusteddomainname: *const super::super::super::Foundation::UNICODE_STRING, foresttrustinfo: *const LSA_FOREST_TRUST_INFORMATION, checkonly: super::super::super::Foundation::BOOLEAN, collisioninfo: *mut *mut LSA_FOREST_TRUST_COLLISION_INFORMATION) -> super::super::super::Foundation::NTSTATUS;
6254         }
6255         LsaSetForestTrustInformation(::std::mem::transmute(policyhandle), ::std::mem::transmute(trusteddomainname), ::std::mem::transmute(foresttrustinfo), checkonly.into_param().abi(), ::std::mem::transmute(collisioninfo)).ok()
6256     }
6257     #[cfg(not(windows))]
6258     unimplemented!("Unsupported target OS");
6259 }
6260 #[cfg(feature = "Win32_Foundation")]
6261 #[inline]
6262 pub unsafe fn LsaSetInformationPolicy(policyhandle: *const ::std::ffi::c_void, informationclass: POLICY_INFORMATION_CLASS, buffer: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6263     #[cfg(windows)]
6264     {
6265         #[link(name = "windows")]
6266         extern "system" {
6267             fn LsaSetInformationPolicy(policyhandle: *const ::std::ffi::c_void, informationclass: POLICY_INFORMATION_CLASS, buffer: *const ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
6268         }
6269         LsaSetInformationPolicy(::std::mem::transmute(policyhandle), ::std::mem::transmute(informationclass), ::std::mem::transmute(buffer)).ok()
6270     }
6271     #[cfg(not(windows))]
6272     unimplemented!("Unsupported target OS");
6273 }
6274 #[cfg(feature = "Win32_Foundation")]
6275 #[inline]
6276 pub unsafe fn LsaSetTrustedDomainInfoByName(policyhandle: *const ::std::ffi::c_void, trusteddomainname: *const super::super::super::Foundation::UNICODE_STRING, informationclass: TRUSTED_INFORMATION_CLASS, buffer: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6277     #[cfg(windows)]
6278     {
6279         #[link(name = "windows")]
6280         extern "system" {
6281             fn LsaSetTrustedDomainInfoByName(policyhandle: *const ::std::ffi::c_void, trusteddomainname: *const super::super::super::Foundation::UNICODE_STRING, informationclass: TRUSTED_INFORMATION_CLASS, buffer: *const ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
6282         }
6283         LsaSetTrustedDomainInfoByName(::std::mem::transmute(policyhandle), ::std::mem::transmute(trusteddomainname), ::std::mem::transmute(informationclass), ::std::mem::transmute(buffer)).ok()
6284     }
6285     #[cfg(not(windows))]
6286     unimplemented!("Unsupported target OS");
6287 }
6288 #[cfg(feature = "Win32_Foundation")]
6289 #[inline]
6290 pub unsafe fn LsaSetTrustedDomainInformation<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSID>>(policyhandle: *const ::std::ffi::c_void, trusteddomainsid: Param1, informationclass: TRUSTED_INFORMATION_CLASS, buffer: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6291     #[cfg(windows)]
6292     {
6293         #[link(name = "windows")]
6294         extern "system" {
6295             fn LsaSetTrustedDomainInformation(policyhandle: *const ::std::ffi::c_void, trusteddomainsid: super::super::super::Foundation::PSID, informationclass: TRUSTED_INFORMATION_CLASS, buffer: *const ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
6296         }
6297         LsaSetTrustedDomainInformation(::std::mem::transmute(policyhandle), trusteddomainsid.into_param().abi(), ::std::mem::transmute(informationclass), ::std::mem::transmute(buffer)).ok()
6298     }
6299     #[cfg(not(windows))]
6300     unimplemented!("Unsupported target OS");
6301 }
6302 #[cfg(feature = "Win32_Foundation")]
6303 #[inline]
6304 pub unsafe fn LsaStorePrivateData(policyhandle: *const ::std::ffi::c_void, keyname: *const super::super::super::Foundation::UNICODE_STRING, privatedata: *const super::super::super::Foundation::UNICODE_STRING) -> ::windows::runtime::Result<()> {
6305     #[cfg(windows)]
6306     {
6307         #[link(name = "windows")]
6308         extern "system" {
6309             fn LsaStorePrivateData(policyhandle: *const ::std::ffi::c_void, keyname: *const super::super::super::Foundation::UNICODE_STRING, privatedata: *const super::super::super::Foundation::UNICODE_STRING) -> super::super::super::Foundation::NTSTATUS;
6310         }
6311         LsaStorePrivateData(::std::mem::transmute(policyhandle), ::std::mem::transmute(keyname), ::std::mem::transmute(privatedata)).ok()
6312     }
6313     #[cfg(not(windows))]
6314     unimplemented!("Unsupported target OS");
6315 }
6316 #[cfg(feature = "Win32_Foundation")]
6317 #[inline]
6318 pub unsafe fn LsaUnregisterPolicyChangeNotification<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HANDLE>>(informationclass: POLICY_NOTIFICATION_INFORMATION_CLASS, notificationeventhandle: Param1) -> ::windows::runtime::Result<()> {
6319     #[cfg(windows)]
6320     {
6321         #[link(name = "windows")]
6322         extern "system" {
6323             fn LsaUnregisterPolicyChangeNotification(informationclass: POLICY_NOTIFICATION_INFORMATION_CLASS, notificationeventhandle: super::super::super::Foundation::HANDLE) -> super::super::super::Foundation::NTSTATUS;
6324         }
6325         LsaUnregisterPolicyChangeNotification(::std::mem::transmute(informationclass), notificationeventhandle.into_param().abi()).ok()
6326     }
6327     #[cfg(not(windows))]
6328     unimplemented!("Unsupported target OS");
6329 }
6330 #[cfg(feature = "Win32_Security_Credentials")]
6331 pub type MAKE_SIGNATURE_FN = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: u32, param2: *mut SecBufferDesc, param3: u32) -> i32;
6332 pub const MAXIMUM_CAPES_PER_CAP: u32 = 127u32;
6333 pub const MAX_CRED_SIZE: u32 = 1024u32;
6334 pub const MAX_PROTOCOL_ID_SIZE: u32 = 255u32;
6335 pub const MAX_RECORDS_IN_FOREST_TRUST_INFO: u32 = 4000u32;
6336 pub const MAX_USER_RECORDS: u32 = 1000u32;
6337 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6338 #[repr(transparent)]
6339 pub struct MSV1_0(pub u32);
6340 pub const MSV1_0_PASSTHRU: MSV1_0 = MSV1_0(1u32);
6341 pub const MSV1_0_GUEST_LOGON: MSV1_0 = MSV1_0(2u32);
6342 impl ::std::convert::From<u32> for MSV1_0 {
6343     fn from(value: u32) -> Self {
6344         Self(value)
6345     }
6346 }
6347 unsafe impl ::windows::runtime::Abi for MSV1_0 {
6348     type Abi = Self;
6349     type DefaultType = Self;
6350 }
6351 impl ::std::ops::BitOr for MSV1_0 {
6352     type Output = Self;
6353     fn bitor(self, rhs: Self) -> Self {
6354         Self(self.0 | rhs.0)
6355     }
6356 }
6357 impl ::std::ops::BitAnd for MSV1_0 {
6358     type Output = Self;
6359     fn bitand(self, rhs: Self) -> Self {
6360         Self(self.0 & rhs.0)
6361     }
6362 }
6363 impl ::std::ops::BitOrAssign for MSV1_0 {
6364     fn bitor_assign(&mut self, rhs: Self) {
6365         self.0.bitor_assign(rhs.0)
6366     }
6367 }
6368 impl ::std::ops::BitAndAssign for MSV1_0 {
6369     fn bitand_assign(&mut self, rhs: Self) {
6370         self.0.bitand_assign(rhs.0)
6371     }
6372 }
6373 impl ::std::ops::Not for MSV1_0 {
6374     type Output = Self;
6375     fn not(self) -> Self {
6376         Self(self.0.not())
6377     }
6378 }
6379 pub const MSV1_0_ALLOW_FORCE_GUEST: u32 = 8192u32;
6380 pub const MSV1_0_ALLOW_MSVCHAPV2: u32 = 65536u32;
6381 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6382 #[repr(transparent)]
6383 pub struct MSV1_0_AVID(pub i32);
6384 pub const MsvAvEOL: MSV1_0_AVID = MSV1_0_AVID(0i32);
6385 pub const MsvAvNbComputerName: MSV1_0_AVID = MSV1_0_AVID(1i32);
6386 pub const MsvAvNbDomainName: MSV1_0_AVID = MSV1_0_AVID(2i32);
6387 pub const MsvAvDnsComputerName: MSV1_0_AVID = MSV1_0_AVID(3i32);
6388 pub const MsvAvDnsDomainName: MSV1_0_AVID = MSV1_0_AVID(4i32);
6389 pub const MsvAvDnsTreeName: MSV1_0_AVID = MSV1_0_AVID(5i32);
6390 pub const MsvAvFlags: MSV1_0_AVID = MSV1_0_AVID(6i32);
6391 pub const MsvAvTimestamp: MSV1_0_AVID = MSV1_0_AVID(7i32);
6392 pub const MsvAvRestrictions: MSV1_0_AVID = MSV1_0_AVID(8i32);
6393 pub const MsvAvTargetName: MSV1_0_AVID = MSV1_0_AVID(9i32);
6394 pub const MsvAvChannelBindings: MSV1_0_AVID = MSV1_0_AVID(10i32);
6395 impl ::std::convert::From<i32> for MSV1_0_AVID {
6396     fn from(value: i32) -> Self {
6397         Self(value)
6398     }
6399 }
6400 unsafe impl ::windows::runtime::Abi for MSV1_0_AVID {
6401     type Abi = Self;
6402     type DefaultType = Self;
6403 }
6404 pub const MSV1_0_AV_FLAG_FORCE_GUEST: u32 = 1u32;
6405 pub const MSV1_0_AV_FLAG_MIC_HANDSHAKE_MESSAGES: u32 = 2u32;
6406 pub const MSV1_0_AV_FLAG_UNVERIFIED_TARGET: u32 = 4u32;
6407 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6408 #[repr(C)]
6409 pub struct MSV1_0_AV_PAIR {
6410     pub AvId: u16,
6411     pub AvLen: u16,
6412 }
6413 impl MSV1_0_AV_PAIR {}
6414 impl ::std::default::Default for MSV1_0_AV_PAIR {
6415     fn default() -> Self {
6416         unsafe { ::std::mem::zeroed() }
6417     }
6418 }
6419 impl ::std::fmt::Debug for MSV1_0_AV_PAIR {
6420     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6421         fmt.debug_struct("MSV1_0_AV_PAIR").field("AvId", &self.AvId).field("AvLen", &self.AvLen).finish()
6422     }
6423 }
6424 impl ::std::cmp::PartialEq for MSV1_0_AV_PAIR {
6425     fn eq(&self, other: &Self) -> bool {
6426         self.AvId == other.AvId && self.AvLen == other.AvLen
6427     }
6428 }
6429 impl ::std::cmp::Eq for MSV1_0_AV_PAIR {}
6430 unsafe impl ::windows::runtime::Abi for MSV1_0_AV_PAIR {
6431     type Abi = Self;
6432     type DefaultType = Self;
6433 }
6434 pub const MSV1_0_CHALLENGE_LENGTH: u32 = 8u32;
6435 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6436 #[repr(C)]
6437 #[cfg(feature = "Win32_Foundation")]
6438 pub struct MSV1_0_CHANGEPASSWORD_REQUEST {
6439     pub MessageType: MSV1_0_PROTOCOL_MESSAGE_TYPE,
6440     pub DomainName: super::super::super::Foundation::UNICODE_STRING,
6441     pub AccountName: super::super::super::Foundation::UNICODE_STRING,
6442     pub OldPassword: super::super::super::Foundation::UNICODE_STRING,
6443     pub NewPassword: super::super::super::Foundation::UNICODE_STRING,
6444     pub Impersonating: super::super::super::Foundation::BOOLEAN,
6445 }
6446 #[cfg(feature = "Win32_Foundation")]
6447 impl MSV1_0_CHANGEPASSWORD_REQUEST {}
6448 #[cfg(feature = "Win32_Foundation")]
6449 impl ::std::default::Default for MSV1_0_CHANGEPASSWORD_REQUEST {
6450     fn default() -> Self {
6451         unsafe { ::std::mem::zeroed() }
6452     }
6453 }
6454 #[cfg(feature = "Win32_Foundation")]
6455 impl ::std::fmt::Debug for MSV1_0_CHANGEPASSWORD_REQUEST {
6456     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6457         fmt.debug_struct("MSV1_0_CHANGEPASSWORD_REQUEST").field("MessageType", &self.MessageType).field("DomainName", &self.DomainName).field("AccountName", &self.AccountName).field("OldPassword", &self.OldPassword).field("NewPassword", &self.NewPassword).field("Impersonating", &self.Impersonating).finish()
6458     }
6459 }
6460 #[cfg(feature = "Win32_Foundation")]
6461 impl ::std::cmp::PartialEq for MSV1_0_CHANGEPASSWORD_REQUEST {
6462     fn eq(&self, other: &Self) -> bool {
6463         self.MessageType == other.MessageType && self.DomainName == other.DomainName && self.AccountName == other.AccountName && self.OldPassword == other.OldPassword && self.NewPassword == other.NewPassword && self.Impersonating == other.Impersonating
6464     }
6465 }
6466 #[cfg(feature = "Win32_Foundation")]
6467 impl ::std::cmp::Eq for MSV1_0_CHANGEPASSWORD_REQUEST {}
6468 #[cfg(feature = "Win32_Foundation")]
6469 unsafe impl ::windows::runtime::Abi for MSV1_0_CHANGEPASSWORD_REQUEST {
6470     type Abi = Self;
6471     type DefaultType = Self;
6472 }
6473 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6474 #[repr(C)]
6475 #[cfg(feature = "Win32_Foundation")]
6476 pub struct MSV1_0_CHANGEPASSWORD_RESPONSE {
6477     pub MessageType: MSV1_0_PROTOCOL_MESSAGE_TYPE,
6478     pub PasswordInfoValid: super::super::super::Foundation::BOOLEAN,
6479     pub DomainPasswordInfo: DOMAIN_PASSWORD_INFORMATION,
6480 }
6481 #[cfg(feature = "Win32_Foundation")]
6482 impl MSV1_0_CHANGEPASSWORD_RESPONSE {}
6483 #[cfg(feature = "Win32_Foundation")]
6484 impl ::std::default::Default for MSV1_0_CHANGEPASSWORD_RESPONSE {
6485     fn default() -> Self {
6486         unsafe { ::std::mem::zeroed() }
6487     }
6488 }
6489 #[cfg(feature = "Win32_Foundation")]
6490 impl ::std::fmt::Debug for MSV1_0_CHANGEPASSWORD_RESPONSE {
6491     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6492         fmt.debug_struct("MSV1_0_CHANGEPASSWORD_RESPONSE").field("MessageType", &self.MessageType).field("PasswordInfoValid", &self.PasswordInfoValid).field("DomainPasswordInfo", &self.DomainPasswordInfo).finish()
6493     }
6494 }
6495 #[cfg(feature = "Win32_Foundation")]
6496 impl ::std::cmp::PartialEq for MSV1_0_CHANGEPASSWORD_RESPONSE {
6497     fn eq(&self, other: &Self) -> bool {
6498         self.MessageType == other.MessageType && self.PasswordInfoValid == other.PasswordInfoValid && self.DomainPasswordInfo == other.DomainPasswordInfo
6499     }
6500 }
6501 #[cfg(feature = "Win32_Foundation")]
6502 impl ::std::cmp::Eq for MSV1_0_CHANGEPASSWORD_RESPONSE {}
6503 #[cfg(feature = "Win32_Foundation")]
6504 unsafe impl ::windows::runtime::Abi for MSV1_0_CHANGEPASSWORD_RESPONSE {
6505     type Abi = Self;
6506     type DefaultType = Self;
6507 }
6508 pub const MSV1_0_CHECK_LOGONHOURS_FOR_S4U: u32 = 262144u32;
6509 pub const MSV1_0_CLEARTEXT_PASSWORD_SUPPLIED: u32 = 16384u32;
6510 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6511 #[repr(C)]
6512 pub struct MSV1_0_CREDENTIAL_KEY {
6513     pub Data: [u8; 20],
6514 }
6515 impl MSV1_0_CREDENTIAL_KEY {}
6516 impl ::std::default::Default for MSV1_0_CREDENTIAL_KEY {
6517     fn default() -> Self {
6518         unsafe { ::std::mem::zeroed() }
6519     }
6520 }
6521 impl ::std::fmt::Debug for MSV1_0_CREDENTIAL_KEY {
6522     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6523         fmt.debug_struct("MSV1_0_CREDENTIAL_KEY").field("Data", &self.Data).finish()
6524     }
6525 }
6526 impl ::std::cmp::PartialEq for MSV1_0_CREDENTIAL_KEY {
6527     fn eq(&self, other: &Self) -> bool {
6528         self.Data == other.Data
6529     }
6530 }
6531 impl ::std::cmp::Eq for MSV1_0_CREDENTIAL_KEY {}
6532 unsafe impl ::windows::runtime::Abi for MSV1_0_CREDENTIAL_KEY {
6533     type Abi = Self;
6534     type DefaultType = Self;
6535 }
6536 pub const MSV1_0_CREDENTIAL_KEY_LENGTH: u32 = 20u32;
6537 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6538 #[repr(transparent)]
6539 pub struct MSV1_0_CREDENTIAL_KEY_TYPE(pub i32);
6540 pub const InvalidCredKey: MSV1_0_CREDENTIAL_KEY_TYPE = MSV1_0_CREDENTIAL_KEY_TYPE(0i32);
6541 pub const DeprecatedIUMCredKey: MSV1_0_CREDENTIAL_KEY_TYPE = MSV1_0_CREDENTIAL_KEY_TYPE(1i32);
6542 pub const DomainUserCredKey: MSV1_0_CREDENTIAL_KEY_TYPE = MSV1_0_CREDENTIAL_KEY_TYPE(2i32);
6543 pub const LocalUserCredKey: MSV1_0_CREDENTIAL_KEY_TYPE = MSV1_0_CREDENTIAL_KEY_TYPE(3i32);
6544 pub const ExternallySuppliedCredKey: MSV1_0_CREDENTIAL_KEY_TYPE = MSV1_0_CREDENTIAL_KEY_TYPE(4i32);
6545 impl ::std::convert::From<i32> for MSV1_0_CREDENTIAL_KEY_TYPE {
6546     fn from(value: i32) -> Self {
6547         Self(value)
6548     }
6549 }
6550 unsafe impl ::windows::runtime::Abi for MSV1_0_CREDENTIAL_KEY_TYPE {
6551     type Abi = Self;
6552     type DefaultType = Self;
6553 }
6554 pub const MSV1_0_CRED_CREDKEY_PRESENT: u32 = 8u32;
6555 pub const MSV1_0_CRED_REMOVED: u32 = 4u32;
6556 pub const MSV1_0_CRED_SHA_PRESENT: u32 = 16u32;
6557 pub const MSV1_0_CRED_VERSION_ARSO: u32 = 4294901763u32;
6558 pub const MSV1_0_CRED_VERSION_INVALID: u32 = 4294967295u32;
6559 pub const MSV1_0_CRED_VERSION_IUM: u32 = 4294901761u32;
6560 pub const MSV1_0_CRED_VERSION_REMOTE: u32 = 4294901762u32;
6561 pub const MSV1_0_CRED_VERSION_RESERVED_1: u32 = 4294967294u32;
6562 pub const MSV1_0_CRED_VERSION_V2: u32 = 2u32;
6563 pub const MSV1_0_CRED_VERSION_V3: u32 = 4u32;
6564 pub const MSV1_0_DISABLE_PERSONAL_FALLBACK: u32 = 4096u32;
6565 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6566 #[repr(C)]
6567 #[cfg(feature = "Win32_Foundation")]
6568 pub struct MSV1_0_INTERACTIVE_LOGON {
6569     pub MessageType: MSV1_0_LOGON_SUBMIT_TYPE,
6570     pub LogonDomainName: super::super::super::Foundation::UNICODE_STRING,
6571     pub UserName: super::super::super::Foundation::UNICODE_STRING,
6572     pub Password: super::super::super::Foundation::UNICODE_STRING,
6573 }
6574 #[cfg(feature = "Win32_Foundation")]
6575 impl MSV1_0_INTERACTIVE_LOGON {}
6576 #[cfg(feature = "Win32_Foundation")]
6577 impl ::std::default::Default for MSV1_0_INTERACTIVE_LOGON {
6578     fn default() -> Self {
6579         unsafe { ::std::mem::zeroed() }
6580     }
6581 }
6582 #[cfg(feature = "Win32_Foundation")]
6583 impl ::std::fmt::Debug for MSV1_0_INTERACTIVE_LOGON {
6584     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6585         fmt.debug_struct("MSV1_0_INTERACTIVE_LOGON").field("MessageType", &self.MessageType).field("LogonDomainName", &self.LogonDomainName).field("UserName", &self.UserName).field("Password", &self.Password).finish()
6586     }
6587 }
6588 #[cfg(feature = "Win32_Foundation")]
6589 impl ::std::cmp::PartialEq for MSV1_0_INTERACTIVE_LOGON {
6590     fn eq(&self, other: &Self) -> bool {
6591         self.MessageType == other.MessageType && self.LogonDomainName == other.LogonDomainName && self.UserName == other.UserName && self.Password == other.Password
6592     }
6593 }
6594 #[cfg(feature = "Win32_Foundation")]
6595 impl ::std::cmp::Eq for MSV1_0_INTERACTIVE_LOGON {}
6596 #[cfg(feature = "Win32_Foundation")]
6597 unsafe impl ::windows::runtime::Abi for MSV1_0_INTERACTIVE_LOGON {
6598     type Abi = Self;
6599     type DefaultType = Self;
6600 }
6601 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6602 #[repr(C)]
6603 #[cfg(feature = "Win32_Foundation")]
6604 pub struct MSV1_0_INTERACTIVE_PROFILE {
6605     pub MessageType: MSV1_0_PROFILE_BUFFER_TYPE,
6606     pub LogonCount: u16,
6607     pub BadPasswordCount: u16,
6608     pub LogonTime: i64,
6609     pub LogoffTime: i64,
6610     pub KickOffTime: i64,
6611     pub PasswordLastSet: i64,
6612     pub PasswordCanChange: i64,
6613     pub PasswordMustChange: i64,
6614     pub LogonScript: super::super::super::Foundation::UNICODE_STRING,
6615     pub HomeDirectory: super::super::super::Foundation::UNICODE_STRING,
6616     pub FullName: super::super::super::Foundation::UNICODE_STRING,
6617     pub ProfilePath: super::super::super::Foundation::UNICODE_STRING,
6618     pub HomeDirectoryDrive: super::super::super::Foundation::UNICODE_STRING,
6619     pub LogonServer: super::super::super::Foundation::UNICODE_STRING,
6620     pub UserFlags: u32,
6621 }
6622 #[cfg(feature = "Win32_Foundation")]
6623 impl MSV1_0_INTERACTIVE_PROFILE {}
6624 #[cfg(feature = "Win32_Foundation")]
6625 impl ::std::default::Default for MSV1_0_INTERACTIVE_PROFILE {
6626     fn default() -> Self {
6627         unsafe { ::std::mem::zeroed() }
6628     }
6629 }
6630 #[cfg(feature = "Win32_Foundation")]
6631 impl ::std::fmt::Debug for MSV1_0_INTERACTIVE_PROFILE {
6632     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6633         fmt.debug_struct("MSV1_0_INTERACTIVE_PROFILE")
6634             .field("MessageType", &self.MessageType)
6635             .field("LogonCount", &self.LogonCount)
6636             .field("BadPasswordCount", &self.BadPasswordCount)
6637             .field("LogonTime", &self.LogonTime)
6638             .field("LogoffTime", &self.LogoffTime)
6639             .field("KickOffTime", &self.KickOffTime)
6640             .field("PasswordLastSet", &self.PasswordLastSet)
6641             .field("PasswordCanChange", &self.PasswordCanChange)
6642             .field("PasswordMustChange", &self.PasswordMustChange)
6643             .field("LogonScript", &self.LogonScript)
6644             .field("HomeDirectory", &self.HomeDirectory)
6645             .field("FullName", &self.FullName)
6646             .field("ProfilePath", &self.ProfilePath)
6647             .field("HomeDirectoryDrive", &self.HomeDirectoryDrive)
6648             .field("LogonServer", &self.LogonServer)
6649             .field("UserFlags", &self.UserFlags)
6650             .finish()
6651     }
6652 }
6653 #[cfg(feature = "Win32_Foundation")]
6654 impl ::std::cmp::PartialEq for MSV1_0_INTERACTIVE_PROFILE {
6655     fn eq(&self, other: &Self) -> bool {
6656         self.MessageType == other.MessageType
6657             && self.LogonCount == other.LogonCount
6658             && self.BadPasswordCount == other.BadPasswordCount
6659             && self.LogonTime == other.LogonTime
6660             && self.LogoffTime == other.LogoffTime
6661             && self.KickOffTime == other.KickOffTime
6662             && self.PasswordLastSet == other.PasswordLastSet
6663             && self.PasswordCanChange == other.PasswordCanChange
6664             && self.PasswordMustChange == other.PasswordMustChange
6665             && self.LogonScript == other.LogonScript
6666             && self.HomeDirectory == other.HomeDirectory
6667             && self.FullName == other.FullName
6668             && self.ProfilePath == other.ProfilePath
6669             && self.HomeDirectoryDrive == other.HomeDirectoryDrive
6670             && self.LogonServer == other.LogonServer
6671             && self.UserFlags == other.UserFlags
6672     }
6673 }
6674 #[cfg(feature = "Win32_Foundation")]
6675 impl ::std::cmp::Eq for MSV1_0_INTERACTIVE_PROFILE {}
6676 #[cfg(feature = "Win32_Foundation")]
6677 unsafe impl ::windows::runtime::Abi for MSV1_0_INTERACTIVE_PROFILE {
6678     type Abi = Self;
6679     type DefaultType = Self;
6680 }
6681 pub const MSV1_0_INTERNET_DOMAIN: u32 = 524288u32;
6682 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6683 #[repr(C)]
6684 pub struct MSV1_0_IUM_SUPPLEMENTAL_CREDENTIAL {
6685     pub Version: u32,
6686     pub EncryptedCredsSize: u32,
6687     pub EncryptedCreds: [u8; 1],
6688 }
6689 impl MSV1_0_IUM_SUPPLEMENTAL_CREDENTIAL {}
6690 impl ::std::default::Default for MSV1_0_IUM_SUPPLEMENTAL_CREDENTIAL {
6691     fn default() -> Self {
6692         unsafe { ::std::mem::zeroed() }
6693     }
6694 }
6695 impl ::std::fmt::Debug for MSV1_0_IUM_SUPPLEMENTAL_CREDENTIAL {
6696     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6697         fmt.debug_struct("MSV1_0_IUM_SUPPLEMENTAL_CREDENTIAL").field("Version", &self.Version).field("EncryptedCredsSize", &self.EncryptedCredsSize).field("EncryptedCreds", &self.EncryptedCreds).finish()
6698     }
6699 }
6700 impl ::std::cmp::PartialEq for MSV1_0_IUM_SUPPLEMENTAL_CREDENTIAL {
6701     fn eq(&self, other: &Self) -> bool {
6702         self.Version == other.Version && self.EncryptedCredsSize == other.EncryptedCredsSize && self.EncryptedCreds == other.EncryptedCreds
6703     }
6704 }
6705 impl ::std::cmp::Eq for MSV1_0_IUM_SUPPLEMENTAL_CREDENTIAL {}
6706 unsafe impl ::windows::runtime::Abi for MSV1_0_IUM_SUPPLEMENTAL_CREDENTIAL {
6707     type Abi = Self;
6708     type DefaultType = Self;
6709 }
6710 pub const MSV1_0_LANMAN_SESSION_KEY_LENGTH: u32 = 8u32;
6711 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6712 #[repr(C)]
6713 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
6714 pub struct MSV1_0_LM20_LOGON {
6715     pub MessageType: MSV1_0_LOGON_SUBMIT_TYPE,
6716     pub LogonDomainName: super::super::super::Foundation::UNICODE_STRING,
6717     pub UserName: super::super::super::Foundation::UNICODE_STRING,
6718     pub Workstation: super::super::super::Foundation::UNICODE_STRING,
6719     pub ChallengeToClient: [u8; 8],
6720     pub CaseSensitiveChallengeResponse: super::super::super::System::Kernel::STRING,
6721     pub CaseInsensitiveChallengeResponse: super::super::super::System::Kernel::STRING,
6722     pub ParameterControl: u32,
6723 }
6724 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
6725 impl MSV1_0_LM20_LOGON {}
6726 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
6727 impl ::std::default::Default for MSV1_0_LM20_LOGON {
6728     fn default() -> Self {
6729         unsafe { ::std::mem::zeroed() }
6730     }
6731 }
6732 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
6733 impl ::std::fmt::Debug for MSV1_0_LM20_LOGON {
6734     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6735         fmt.debug_struct("MSV1_0_LM20_LOGON")
6736             .field("MessageType", &self.MessageType)
6737             .field("LogonDomainName", &self.LogonDomainName)
6738             .field("UserName", &self.UserName)
6739             .field("Workstation", &self.Workstation)
6740             .field("ChallengeToClient", &self.ChallengeToClient)
6741             .field("CaseSensitiveChallengeResponse", &self.CaseSensitiveChallengeResponse)
6742             .field("CaseInsensitiveChallengeResponse", &self.CaseInsensitiveChallengeResponse)
6743             .field("ParameterControl", &self.ParameterControl)
6744             .finish()
6745     }
6746 }
6747 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
6748 impl ::std::cmp::PartialEq for MSV1_0_LM20_LOGON {
6749     fn eq(&self, other: &Self) -> bool {
6750         self.MessageType == other.MessageType && self.LogonDomainName == other.LogonDomainName && self.UserName == other.UserName && self.Workstation == other.Workstation && self.ChallengeToClient == other.ChallengeToClient && self.CaseSensitiveChallengeResponse == other.CaseSensitiveChallengeResponse && self.CaseInsensitiveChallengeResponse == other.CaseInsensitiveChallengeResponse && self.ParameterControl == other.ParameterControl
6751     }
6752 }
6753 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
6754 impl ::std::cmp::Eq for MSV1_0_LM20_LOGON {}
6755 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
6756 unsafe impl ::windows::runtime::Abi for MSV1_0_LM20_LOGON {
6757     type Abi = Self;
6758     type DefaultType = Self;
6759 }
6760 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6761 #[repr(C)]
6762 #[cfg(feature = "Win32_Foundation")]
6763 pub struct MSV1_0_LM20_LOGON_PROFILE {
6764     pub MessageType: MSV1_0_PROFILE_BUFFER_TYPE,
6765     pub KickOffTime: i64,
6766     pub LogoffTime: i64,
6767     pub UserFlags: MSV_SUB_AUTHENTICATION_FILTER,
6768     pub UserSessionKey: [u8; 16],
6769     pub LogonDomainName: super::super::super::Foundation::UNICODE_STRING,
6770     pub LanmanSessionKey: [u8; 8],
6771     pub LogonServer: super::super::super::Foundation::UNICODE_STRING,
6772     pub UserParameters: super::super::super::Foundation::UNICODE_STRING,
6773 }
6774 #[cfg(feature = "Win32_Foundation")]
6775 impl MSV1_0_LM20_LOGON_PROFILE {}
6776 #[cfg(feature = "Win32_Foundation")]
6777 impl ::std::default::Default for MSV1_0_LM20_LOGON_PROFILE {
6778     fn default() -> Self {
6779         unsafe { ::std::mem::zeroed() }
6780     }
6781 }
6782 #[cfg(feature = "Win32_Foundation")]
6783 impl ::std::fmt::Debug for MSV1_0_LM20_LOGON_PROFILE {
6784     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6785         fmt.debug_struct("MSV1_0_LM20_LOGON_PROFILE")
6786             .field("MessageType", &self.MessageType)
6787             .field("KickOffTime", &self.KickOffTime)
6788             .field("LogoffTime", &self.LogoffTime)
6789             .field("UserFlags", &self.UserFlags)
6790             .field("UserSessionKey", &self.UserSessionKey)
6791             .field("LogonDomainName", &self.LogonDomainName)
6792             .field("LanmanSessionKey", &self.LanmanSessionKey)
6793             .field("LogonServer", &self.LogonServer)
6794             .field("UserParameters", &self.UserParameters)
6795             .finish()
6796     }
6797 }
6798 #[cfg(feature = "Win32_Foundation")]
6799 impl ::std::cmp::PartialEq for MSV1_0_LM20_LOGON_PROFILE {
6800     fn eq(&self, other: &Self) -> bool {
6801         self.MessageType == other.MessageType && self.KickOffTime == other.KickOffTime && self.LogoffTime == other.LogoffTime && self.UserFlags == other.UserFlags && self.UserSessionKey == other.UserSessionKey && self.LogonDomainName == other.LogonDomainName && self.LanmanSessionKey == other.LanmanSessionKey && self.LogonServer == other.LogonServer && self.UserParameters == other.UserParameters
6802     }
6803 }
6804 #[cfg(feature = "Win32_Foundation")]
6805 impl ::std::cmp::Eq for MSV1_0_LM20_LOGON_PROFILE {}
6806 #[cfg(feature = "Win32_Foundation")]
6807 unsafe impl ::windows::runtime::Abi for MSV1_0_LM20_LOGON_PROFILE {
6808     type Abi = Self;
6809     type DefaultType = Self;
6810 }
6811 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6812 #[repr(transparent)]
6813 pub struct MSV1_0_LOGON_SUBMIT_TYPE(pub i32);
6814 pub const MsV1_0InteractiveLogon: MSV1_0_LOGON_SUBMIT_TYPE = MSV1_0_LOGON_SUBMIT_TYPE(2i32);
6815 pub const MsV1_0Lm20Logon: MSV1_0_LOGON_SUBMIT_TYPE = MSV1_0_LOGON_SUBMIT_TYPE(3i32);
6816 pub const MsV1_0NetworkLogon: MSV1_0_LOGON_SUBMIT_TYPE = MSV1_0_LOGON_SUBMIT_TYPE(4i32);
6817 pub const MsV1_0SubAuthLogon: MSV1_0_LOGON_SUBMIT_TYPE = MSV1_0_LOGON_SUBMIT_TYPE(5i32);
6818 pub const MsV1_0WorkstationUnlockLogon: MSV1_0_LOGON_SUBMIT_TYPE = MSV1_0_LOGON_SUBMIT_TYPE(7i32);
6819 pub const MsV1_0S4ULogon: MSV1_0_LOGON_SUBMIT_TYPE = MSV1_0_LOGON_SUBMIT_TYPE(12i32);
6820 pub const MsV1_0VirtualLogon: MSV1_0_LOGON_SUBMIT_TYPE = MSV1_0_LOGON_SUBMIT_TYPE(82i32);
6821 pub const MsV1_0NoElevationLogon: MSV1_0_LOGON_SUBMIT_TYPE = MSV1_0_LOGON_SUBMIT_TYPE(83i32);
6822 pub const MsV1_0LuidLogon: MSV1_0_LOGON_SUBMIT_TYPE = MSV1_0_LOGON_SUBMIT_TYPE(84i32);
6823 impl ::std::convert::From<i32> for MSV1_0_LOGON_SUBMIT_TYPE {
6824     fn from(value: i32) -> Self {
6825         Self(value)
6826     }
6827 }
6828 unsafe impl ::windows::runtime::Abi for MSV1_0_LOGON_SUBMIT_TYPE {
6829     type Abi = Self;
6830     type DefaultType = Self;
6831 }
6832 pub const MSV1_0_MAX_AVL_SIZE: u32 = 64000u32;
6833 pub const MSV1_0_MAX_NTLM3_LIFE: u32 = 1800u32;
6834 pub const MSV1_0_MNS_LOGON: u32 = 16777216u32;
6835 pub const MSV1_0_NTLM3_OWF_LENGTH: u32 = 16u32;
6836 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6837 #[repr(C)]
6838 pub struct MSV1_0_NTLM3_RESPONSE {
6839     pub Response: [u8; 16],
6840     pub RespType: u8,
6841     pub HiRespType: u8,
6842     pub Flags: u16,
6843     pub MsgWord: u32,
6844     pub TimeStamp: u64,
6845     pub ChallengeFromClient: [u8; 8],
6846     pub AvPairsOff: u32,
6847     pub Buffer: [u8; 1],
6848 }
6849 impl MSV1_0_NTLM3_RESPONSE {}
6850 impl ::std::default::Default for MSV1_0_NTLM3_RESPONSE {
6851     fn default() -> Self {
6852         unsafe { ::std::mem::zeroed() }
6853     }
6854 }
6855 impl ::std::fmt::Debug for MSV1_0_NTLM3_RESPONSE {
6856     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6857         fmt.debug_struct("MSV1_0_NTLM3_RESPONSE")
6858             .field("Response", &self.Response)
6859             .field("RespType", &self.RespType)
6860             .field("HiRespType", &self.HiRespType)
6861             .field("Flags", &self.Flags)
6862             .field("MsgWord", &self.MsgWord)
6863             .field("TimeStamp", &self.TimeStamp)
6864             .field("ChallengeFromClient", &self.ChallengeFromClient)
6865             .field("AvPairsOff", &self.AvPairsOff)
6866             .field("Buffer", &self.Buffer)
6867             .finish()
6868     }
6869 }
6870 impl ::std::cmp::PartialEq for MSV1_0_NTLM3_RESPONSE {
6871     fn eq(&self, other: &Self) -> bool {
6872         self.Response == other.Response && self.RespType == other.RespType && self.HiRespType == other.HiRespType && self.Flags == other.Flags && self.MsgWord == other.MsgWord && self.TimeStamp == other.TimeStamp && self.ChallengeFromClient == other.ChallengeFromClient && self.AvPairsOff == other.AvPairsOff && self.Buffer == other.Buffer
6873     }
6874 }
6875 impl ::std::cmp::Eq for MSV1_0_NTLM3_RESPONSE {}
6876 unsafe impl ::windows::runtime::Abi for MSV1_0_NTLM3_RESPONSE {
6877     type Abi = Self;
6878     type DefaultType = Self;
6879 }
6880 pub const MSV1_0_NTLM3_RESPONSE_LENGTH: u32 = 16u32;
6881 pub const MSV1_0_OWF_PASSWORD_LENGTH: u32 = 16u32;
6882 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6883 #[repr(C)]
6884 #[cfg(feature = "Win32_Foundation")]
6885 pub struct MSV1_0_PASSTHROUGH_REQUEST {
6886     pub MessageType: MSV1_0_PROTOCOL_MESSAGE_TYPE,
6887     pub DomainName: super::super::super::Foundation::UNICODE_STRING,
6888     pub PackageName: super::super::super::Foundation::UNICODE_STRING,
6889     pub DataLength: u32,
6890     pub LogonData: *mut u8,
6891     pub Pad: u32,
6892 }
6893 #[cfg(feature = "Win32_Foundation")]
6894 impl MSV1_0_PASSTHROUGH_REQUEST {}
6895 #[cfg(feature = "Win32_Foundation")]
6896 impl ::std::default::Default for MSV1_0_PASSTHROUGH_REQUEST {
6897     fn default() -> Self {
6898         unsafe { ::std::mem::zeroed() }
6899     }
6900 }
6901 #[cfg(feature = "Win32_Foundation")]
6902 impl ::std::fmt::Debug for MSV1_0_PASSTHROUGH_REQUEST {
6903     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6904         fmt.debug_struct("MSV1_0_PASSTHROUGH_REQUEST").field("MessageType", &self.MessageType).field("DomainName", &self.DomainName).field("PackageName", &self.PackageName).field("DataLength", &self.DataLength).field("LogonData", &self.LogonData).field("Pad", &self.Pad).finish()
6905     }
6906 }
6907 #[cfg(feature = "Win32_Foundation")]
6908 impl ::std::cmp::PartialEq for MSV1_0_PASSTHROUGH_REQUEST {
6909     fn eq(&self, other: &Self) -> bool {
6910         self.MessageType == other.MessageType && self.DomainName == other.DomainName && self.PackageName == other.PackageName && self.DataLength == other.DataLength && self.LogonData == other.LogonData && self.Pad == other.Pad
6911     }
6912 }
6913 #[cfg(feature = "Win32_Foundation")]
6914 impl ::std::cmp::Eq for MSV1_0_PASSTHROUGH_REQUEST {}
6915 #[cfg(feature = "Win32_Foundation")]
6916 unsafe impl ::windows::runtime::Abi for MSV1_0_PASSTHROUGH_REQUEST {
6917     type Abi = Self;
6918     type DefaultType = Self;
6919 }
6920 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6921 #[repr(C)]
6922 pub struct MSV1_0_PASSTHROUGH_RESPONSE {
6923     pub MessageType: MSV1_0_PROTOCOL_MESSAGE_TYPE,
6924     pub Pad: u32,
6925     pub DataLength: u32,
6926     pub ValidationData: *mut u8,
6927 }
6928 impl MSV1_0_PASSTHROUGH_RESPONSE {}
6929 impl ::std::default::Default for MSV1_0_PASSTHROUGH_RESPONSE {
6930     fn default() -> Self {
6931         unsafe { ::std::mem::zeroed() }
6932     }
6933 }
6934 impl ::std::fmt::Debug for MSV1_0_PASSTHROUGH_RESPONSE {
6935     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6936         fmt.debug_struct("MSV1_0_PASSTHROUGH_RESPONSE").field("MessageType", &self.MessageType).field("Pad", &self.Pad).field("DataLength", &self.DataLength).field("ValidationData", &self.ValidationData).finish()
6937     }
6938 }
6939 impl ::std::cmp::PartialEq for MSV1_0_PASSTHROUGH_RESPONSE {
6940     fn eq(&self, other: &Self) -> bool {
6941         self.MessageType == other.MessageType && self.Pad == other.Pad && self.DataLength == other.DataLength && self.ValidationData == other.ValidationData
6942     }
6943 }
6944 impl ::std::cmp::Eq for MSV1_0_PASSTHROUGH_RESPONSE {}
6945 unsafe impl ::windows::runtime::Abi for MSV1_0_PASSTHROUGH_RESPONSE {
6946     type Abi = Self;
6947     type DefaultType = Self;
6948 }
6949 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6950 #[repr(transparent)]
6951 pub struct MSV1_0_PROFILE_BUFFER_TYPE(pub i32);
6952 pub const MsV1_0InteractiveProfile: MSV1_0_PROFILE_BUFFER_TYPE = MSV1_0_PROFILE_BUFFER_TYPE(2i32);
6953 pub const MsV1_0Lm20LogonProfile: MSV1_0_PROFILE_BUFFER_TYPE = MSV1_0_PROFILE_BUFFER_TYPE(3i32);
6954 pub const MsV1_0SmartCardProfile: MSV1_0_PROFILE_BUFFER_TYPE = MSV1_0_PROFILE_BUFFER_TYPE(4i32);
6955 impl ::std::convert::From<i32> for MSV1_0_PROFILE_BUFFER_TYPE {
6956     fn from(value: i32) -> Self {
6957         Self(value)
6958     }
6959 }
6960 unsafe impl ::windows::runtime::Abi for MSV1_0_PROFILE_BUFFER_TYPE {
6961     type Abi = Self;
6962     type DefaultType = Self;
6963 }
6964 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6965 #[repr(transparent)]
6966 pub struct MSV1_0_PROTOCOL_MESSAGE_TYPE(pub i32);
6967 pub const MsV1_0Lm20ChallengeRequest: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(0i32);
6968 pub const MsV1_0Lm20GetChallengeResponse: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(1i32);
6969 pub const MsV1_0EnumerateUsers: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(2i32);
6970 pub const MsV1_0GetUserInfo: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(3i32);
6971 pub const MsV1_0ReLogonUsers: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(4i32);
6972 pub const MsV1_0ChangePassword: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(5i32);
6973 pub const MsV1_0ChangeCachedPassword: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(6i32);
6974 pub const MsV1_0GenericPassthrough: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(7i32);
6975 pub const MsV1_0CacheLogon: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(8i32);
6976 pub const MsV1_0SubAuth: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(9i32);
6977 pub const MsV1_0DeriveCredential: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(10i32);
6978 pub const MsV1_0CacheLookup: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(11i32);
6979 pub const MsV1_0SetProcessOption: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(12i32);
6980 pub const MsV1_0ConfigLocalAliases: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(13i32);
6981 pub const MsV1_0ClearCachedCredentials: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(14i32);
6982 pub const MsV1_0LookupToken: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(15i32);
6983 pub const MsV1_0ValidateAuth: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(16i32);
6984 pub const MsV1_0CacheLookupEx: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(17i32);
6985 pub const MsV1_0GetCredentialKey: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(18i32);
6986 pub const MsV1_0SetThreadOption: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(19i32);
6987 pub const MsV1_0DecryptDpapiMasterKey: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(20i32);
6988 pub const MsV1_0GetStrongCredentialKey: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(21i32);
6989 pub const MsV1_0TransferCred: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(22i32);
6990 pub const MsV1_0ProvisionTbal: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(23i32);
6991 pub const MsV1_0DeleteTbalSecrets: MSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE(24i32);
6992 impl ::std::convert::From<i32> for MSV1_0_PROTOCOL_MESSAGE_TYPE {
6993     fn from(value: i32) -> Self {
6994         Self(value)
6995     }
6996 }
6997 unsafe impl ::windows::runtime::Abi for MSV1_0_PROTOCOL_MESSAGE_TYPE {
6998     type Abi = Self;
6999     type DefaultType = Self;
7000 }
7001 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7002 #[repr(C, packed(1))]
7003 pub struct MSV1_0_REMOTE_SUPPLEMENTAL_CREDENTIAL {
7004     pub Version: u32,
7005     pub Flags: u32,
7006     pub CredentialKey: MSV1_0_CREDENTIAL_KEY,
7007     pub CredentialKeyType: MSV1_0_CREDENTIAL_KEY_TYPE,
7008     pub EncryptedCredsSize: u32,
7009     pub EncryptedCreds: [u8; 1],
7010 }
7011 impl MSV1_0_REMOTE_SUPPLEMENTAL_CREDENTIAL {}
7012 impl ::std::default::Default for MSV1_0_REMOTE_SUPPLEMENTAL_CREDENTIAL {
7013     fn default() -> Self {
7014         unsafe { ::std::mem::zeroed() }
7015     }
7016 }
7017 impl ::std::cmp::PartialEq for MSV1_0_REMOTE_SUPPLEMENTAL_CREDENTIAL {
7018     fn eq(&self, _other: &Self) -> bool {
7019         unimplemented!()
7020     }
7021 }
7022 impl ::std::cmp::Eq for MSV1_0_REMOTE_SUPPLEMENTAL_CREDENTIAL {}
7023 unsafe impl ::windows::runtime::Abi for MSV1_0_REMOTE_SUPPLEMENTAL_CREDENTIAL {
7024     type Abi = Self;
7025     type DefaultType = Self;
7026 }
7027 pub const MSV1_0_S4U2SELF: u32 = 131072u32;
7028 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7029 #[repr(C)]
7030 #[cfg(feature = "Win32_Foundation")]
7031 pub struct MSV1_0_S4U_LOGON {
7032     pub MessageType: MSV1_0_LOGON_SUBMIT_TYPE,
7033     pub Flags: u32,
7034     pub UserPrincipalName: super::super::super::Foundation::UNICODE_STRING,
7035     pub DomainName: super::super::super::Foundation::UNICODE_STRING,
7036 }
7037 #[cfg(feature = "Win32_Foundation")]
7038 impl MSV1_0_S4U_LOGON {}
7039 #[cfg(feature = "Win32_Foundation")]
7040 impl ::std::default::Default for MSV1_0_S4U_LOGON {
7041     fn default() -> Self {
7042         unsafe { ::std::mem::zeroed() }
7043     }
7044 }
7045 #[cfg(feature = "Win32_Foundation")]
7046 impl ::std::fmt::Debug for MSV1_0_S4U_LOGON {
7047     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7048         fmt.debug_struct("MSV1_0_S4U_LOGON").field("MessageType", &self.MessageType).field("Flags", &self.Flags).field("UserPrincipalName", &self.UserPrincipalName).field("DomainName", &self.DomainName).finish()
7049     }
7050 }
7051 #[cfg(feature = "Win32_Foundation")]
7052 impl ::std::cmp::PartialEq for MSV1_0_S4U_LOGON {
7053     fn eq(&self, other: &Self) -> bool {
7054         self.MessageType == other.MessageType && self.Flags == other.Flags && self.UserPrincipalName == other.UserPrincipalName && self.DomainName == other.DomainName
7055     }
7056 }
7057 #[cfg(feature = "Win32_Foundation")]
7058 impl ::std::cmp::Eq for MSV1_0_S4U_LOGON {}
7059 #[cfg(feature = "Win32_Foundation")]
7060 unsafe impl ::windows::runtime::Abi for MSV1_0_S4U_LOGON {
7061     type Abi = Self;
7062     type DefaultType = Self;
7063 }
7064 pub const MSV1_0_S4U_LOGON_FLAG_CHECK_LOGONHOURS: u32 = 2u32;
7065 pub const MSV1_0_SHA_PASSWORD_LENGTH: u32 = 20u32;
7066 pub const MSV1_0_SUBAUTHENTICATION_DLL: u32 = 4278190080u32;
7067 pub const MSV1_0_SUBAUTHENTICATION_DLL_EX: u32 = 1048576u32;
7068 pub const MSV1_0_SUBAUTHENTICATION_DLL_IIS: u32 = 132u32;
7069 pub const MSV1_0_SUBAUTHENTICATION_DLL_RAS: u32 = 2u32;
7070 pub const MSV1_0_SUBAUTHENTICATION_DLL_SHIFT: u32 = 24u32;
7071 pub const MSV1_0_SUBAUTHENTICATION_FLAGS: u32 = 4278190080u32;
7072 pub const MSV1_0_SUBAUTH_ACCOUNT_DISABLED: u32 = 1u32;
7073 pub const MSV1_0_SUBAUTH_ACCOUNT_EXPIRY: u32 = 16u32;
7074 pub const MSV1_0_SUBAUTH_ACCOUNT_TYPE: u32 = 64u32;
7075 pub const MSV1_0_SUBAUTH_LOCKOUT: u32 = 128u32;
7076 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7077 #[repr(C)]
7078 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
7079 pub struct MSV1_0_SUBAUTH_LOGON {
7080     pub MessageType: MSV1_0_LOGON_SUBMIT_TYPE,
7081     pub LogonDomainName: super::super::super::Foundation::UNICODE_STRING,
7082     pub UserName: super::super::super::Foundation::UNICODE_STRING,
7083     pub Workstation: super::super::super::Foundation::UNICODE_STRING,
7084     pub ChallengeToClient: [u8; 8],
7085     pub AuthenticationInfo1: super::super::super::System::Kernel::STRING,
7086     pub AuthenticationInfo2: super::super::super::System::Kernel::STRING,
7087     pub ParameterControl: MSV_SUBAUTH_LOGON_PARAMETER_CONTROL,
7088     pub SubAuthPackageId: u32,
7089 }
7090 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
7091 impl MSV1_0_SUBAUTH_LOGON {}
7092 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
7093 impl ::std::default::Default for MSV1_0_SUBAUTH_LOGON {
7094     fn default() -> Self {
7095         unsafe { ::std::mem::zeroed() }
7096     }
7097 }
7098 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
7099 impl ::std::fmt::Debug for MSV1_0_SUBAUTH_LOGON {
7100     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7101         fmt.debug_struct("MSV1_0_SUBAUTH_LOGON")
7102             .field("MessageType", &self.MessageType)
7103             .field("LogonDomainName", &self.LogonDomainName)
7104             .field("UserName", &self.UserName)
7105             .field("Workstation", &self.Workstation)
7106             .field("ChallengeToClient", &self.ChallengeToClient)
7107             .field("AuthenticationInfo1", &self.AuthenticationInfo1)
7108             .field("AuthenticationInfo2", &self.AuthenticationInfo2)
7109             .field("ParameterControl", &self.ParameterControl)
7110             .field("SubAuthPackageId", &self.SubAuthPackageId)
7111             .finish()
7112     }
7113 }
7114 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
7115 impl ::std::cmp::PartialEq for MSV1_0_SUBAUTH_LOGON {
7116     fn eq(&self, other: &Self) -> bool {
7117         self.MessageType == other.MessageType && self.LogonDomainName == other.LogonDomainName && self.UserName == other.UserName && self.Workstation == other.Workstation && self.ChallengeToClient == other.ChallengeToClient && self.AuthenticationInfo1 == other.AuthenticationInfo1 && self.AuthenticationInfo2 == other.AuthenticationInfo2 && self.ParameterControl == other.ParameterControl && self.SubAuthPackageId == other.SubAuthPackageId
7118     }
7119 }
7120 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
7121 impl ::std::cmp::Eq for MSV1_0_SUBAUTH_LOGON {}
7122 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
7123 unsafe impl ::windows::runtime::Abi for MSV1_0_SUBAUTH_LOGON {
7124     type Abi = Self;
7125     type DefaultType = Self;
7126 }
7127 pub const MSV1_0_SUBAUTH_LOGON_HOURS: u32 = 8u32;
7128 pub const MSV1_0_SUBAUTH_PASSWORD: u32 = 2u32;
7129 pub const MSV1_0_SUBAUTH_PASSWORD_EXPIRY: u32 = 32u32;
7130 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7131 #[repr(C)]
7132 pub struct MSV1_0_SUBAUTH_REQUEST {
7133     pub MessageType: MSV1_0_PROTOCOL_MESSAGE_TYPE,
7134     pub SubAuthPackageId: u32,
7135     pub SubAuthInfoLength: u32,
7136     pub SubAuthSubmitBuffer: *mut u8,
7137 }
7138 impl MSV1_0_SUBAUTH_REQUEST {}
7139 impl ::std::default::Default for MSV1_0_SUBAUTH_REQUEST {
7140     fn default() -> Self {
7141         unsafe { ::std::mem::zeroed() }
7142     }
7143 }
7144 impl ::std::fmt::Debug for MSV1_0_SUBAUTH_REQUEST {
7145     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7146         fmt.debug_struct("MSV1_0_SUBAUTH_REQUEST").field("MessageType", &self.MessageType).field("SubAuthPackageId", &self.SubAuthPackageId).field("SubAuthInfoLength", &self.SubAuthInfoLength).field("SubAuthSubmitBuffer", &self.SubAuthSubmitBuffer).finish()
7147     }
7148 }
7149 impl ::std::cmp::PartialEq for MSV1_0_SUBAUTH_REQUEST {
7150     fn eq(&self, other: &Self) -> bool {
7151         self.MessageType == other.MessageType && self.SubAuthPackageId == other.SubAuthPackageId && self.SubAuthInfoLength == other.SubAuthInfoLength && self.SubAuthSubmitBuffer == other.SubAuthSubmitBuffer
7152     }
7153 }
7154 impl ::std::cmp::Eq for MSV1_0_SUBAUTH_REQUEST {}
7155 unsafe impl ::windows::runtime::Abi for MSV1_0_SUBAUTH_REQUEST {
7156     type Abi = Self;
7157     type DefaultType = Self;
7158 }
7159 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7160 #[repr(C)]
7161 pub struct MSV1_0_SUBAUTH_RESPONSE {
7162     pub MessageType: MSV1_0_PROTOCOL_MESSAGE_TYPE,
7163     pub SubAuthInfoLength: u32,
7164     pub SubAuthReturnBuffer: *mut u8,
7165 }
7166 impl MSV1_0_SUBAUTH_RESPONSE {}
7167 impl ::std::default::Default for MSV1_0_SUBAUTH_RESPONSE {
7168     fn default() -> Self {
7169         unsafe { ::std::mem::zeroed() }
7170     }
7171 }
7172 impl ::std::fmt::Debug for MSV1_0_SUBAUTH_RESPONSE {
7173     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7174         fmt.debug_struct("MSV1_0_SUBAUTH_RESPONSE").field("MessageType", &self.MessageType).field("SubAuthInfoLength", &self.SubAuthInfoLength).field("SubAuthReturnBuffer", &self.SubAuthReturnBuffer).finish()
7175     }
7176 }
7177 impl ::std::cmp::PartialEq for MSV1_0_SUBAUTH_RESPONSE {
7178     fn eq(&self, other: &Self) -> bool {
7179         self.MessageType == other.MessageType && self.SubAuthInfoLength == other.SubAuthInfoLength && self.SubAuthReturnBuffer == other.SubAuthReturnBuffer
7180     }
7181 }
7182 impl ::std::cmp::Eq for MSV1_0_SUBAUTH_RESPONSE {}
7183 unsafe impl ::windows::runtime::Abi for MSV1_0_SUBAUTH_RESPONSE {
7184     type Abi = Self;
7185     type DefaultType = Self;
7186 }
7187 pub const MSV1_0_SUBAUTH_WORKSTATIONS: u32 = 4u32;
7188 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7189 #[repr(C)]
7190 pub struct MSV1_0_SUPPLEMENTAL_CREDENTIAL {
7191     pub Version: u32,
7192     pub Flags: MSV_SUPPLEMENTAL_CREDENTIAL_FLAGS,
7193     pub LmPassword: [u8; 16],
7194     pub NtPassword: [u8; 16],
7195 }
7196 impl MSV1_0_SUPPLEMENTAL_CREDENTIAL {}
7197 impl ::std::default::Default for MSV1_0_SUPPLEMENTAL_CREDENTIAL {
7198     fn default() -> Self {
7199         unsafe { ::std::mem::zeroed() }
7200     }
7201 }
7202 impl ::std::fmt::Debug for MSV1_0_SUPPLEMENTAL_CREDENTIAL {
7203     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7204         fmt.debug_struct("MSV1_0_SUPPLEMENTAL_CREDENTIAL").field("Version", &self.Version).field("Flags", &self.Flags).field("LmPassword", &self.LmPassword).field("NtPassword", &self.NtPassword).finish()
7205     }
7206 }
7207 impl ::std::cmp::PartialEq for MSV1_0_SUPPLEMENTAL_CREDENTIAL {
7208     fn eq(&self, other: &Self) -> bool {
7209         self.Version == other.Version && self.Flags == other.Flags && self.LmPassword == other.LmPassword && self.NtPassword == other.NtPassword
7210     }
7211 }
7212 impl ::std::cmp::Eq for MSV1_0_SUPPLEMENTAL_CREDENTIAL {}
7213 unsafe impl ::windows::runtime::Abi for MSV1_0_SUPPLEMENTAL_CREDENTIAL {
7214     type Abi = Self;
7215     type DefaultType = Self;
7216 }
7217 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7218 #[repr(C)]
7219 pub struct MSV1_0_SUPPLEMENTAL_CREDENTIAL_V2 {
7220     pub Version: u32,
7221     pub Flags: u32,
7222     pub NtPassword: [u8; 16],
7223     pub CredentialKey: MSV1_0_CREDENTIAL_KEY,
7224 }
7225 impl MSV1_0_SUPPLEMENTAL_CREDENTIAL_V2 {}
7226 impl ::std::default::Default for MSV1_0_SUPPLEMENTAL_CREDENTIAL_V2 {
7227     fn default() -> Self {
7228         unsafe { ::std::mem::zeroed() }
7229     }
7230 }
7231 impl ::std::fmt::Debug for MSV1_0_SUPPLEMENTAL_CREDENTIAL_V2 {
7232     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7233         fmt.debug_struct("MSV1_0_SUPPLEMENTAL_CREDENTIAL_V2").field("Version", &self.Version).field("Flags", &self.Flags).field("NtPassword", &self.NtPassword).field("CredentialKey", &self.CredentialKey).finish()
7234     }
7235 }
7236 impl ::std::cmp::PartialEq for MSV1_0_SUPPLEMENTAL_CREDENTIAL_V2 {
7237     fn eq(&self, other: &Self) -> bool {
7238         self.Version == other.Version && self.Flags == other.Flags && self.NtPassword == other.NtPassword && self.CredentialKey == other.CredentialKey
7239     }
7240 }
7241 impl ::std::cmp::Eq for MSV1_0_SUPPLEMENTAL_CREDENTIAL_V2 {}
7242 unsafe impl ::windows::runtime::Abi for MSV1_0_SUPPLEMENTAL_CREDENTIAL_V2 {
7243     type Abi = Self;
7244     type DefaultType = Self;
7245 }
7246 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7247 #[repr(C)]
7248 pub struct MSV1_0_SUPPLEMENTAL_CREDENTIAL_V3 {
7249     pub Version: u32,
7250     pub Flags: u32,
7251     pub CredentialKeyType: MSV1_0_CREDENTIAL_KEY_TYPE,
7252     pub NtPassword: [u8; 16],
7253     pub CredentialKey: MSV1_0_CREDENTIAL_KEY,
7254     pub ShaPassword: [u8; 20],
7255 }
7256 impl MSV1_0_SUPPLEMENTAL_CREDENTIAL_V3 {}
7257 impl ::std::default::Default for MSV1_0_SUPPLEMENTAL_CREDENTIAL_V3 {
7258     fn default() -> Self {
7259         unsafe { ::std::mem::zeroed() }
7260     }
7261 }
7262 impl ::std::fmt::Debug for MSV1_0_SUPPLEMENTAL_CREDENTIAL_V3 {
7263     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7264         fmt.debug_struct("MSV1_0_SUPPLEMENTAL_CREDENTIAL_V3").field("Version", &self.Version).field("Flags", &self.Flags).field("CredentialKeyType", &self.CredentialKeyType).field("NtPassword", &self.NtPassword).field("CredentialKey", &self.CredentialKey).field("ShaPassword", &self.ShaPassword).finish()
7265     }
7266 }
7267 impl ::std::cmp::PartialEq for MSV1_0_SUPPLEMENTAL_CREDENTIAL_V3 {
7268     fn eq(&self, other: &Self) -> bool {
7269         self.Version == other.Version && self.Flags == other.Flags && self.CredentialKeyType == other.CredentialKeyType && self.NtPassword == other.NtPassword && self.CredentialKey == other.CredentialKey && self.ShaPassword == other.ShaPassword
7270     }
7271 }
7272 impl ::std::cmp::Eq for MSV1_0_SUPPLEMENTAL_CREDENTIAL_V3 {}
7273 unsafe impl ::windows::runtime::Abi for MSV1_0_SUPPLEMENTAL_CREDENTIAL_V3 {
7274     type Abi = Self;
7275     type DefaultType = Self;
7276 }
7277 pub const MSV1_0_USER_SESSION_KEY_LENGTH: u32 = 16u32;
7278 pub const MSV1_0_USE_CLIENT_CHALLENGE: u32 = 128u32;
7279 pub const MSV1_0_USE_DOMAIN_FOR_ROUTING_ONLY: u32 = 32768u32;
7280 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7281 #[repr(C)]
7282 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7283 pub struct MSV1_0_VALIDATION_INFO {
7284     pub LogoffTime: i64,
7285     pub KickoffTime: i64,
7286     pub LogonServer: super::super::super::Foundation::UNICODE_STRING,
7287     pub LogonDomainName: super::super::super::Foundation::UNICODE_STRING,
7288     pub SessionKey: USER_SESSION_KEY,
7289     pub Authoritative: super::super::super::Foundation::BOOLEAN,
7290     pub UserFlags: u32,
7291     pub WhichFields: u32,
7292     pub UserId: u32,
7293 }
7294 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7295 impl MSV1_0_VALIDATION_INFO {}
7296 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7297 impl ::std::default::Default for MSV1_0_VALIDATION_INFO {
7298     fn default() -> Self {
7299         unsafe { ::std::mem::zeroed() }
7300     }
7301 }
7302 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7303 impl ::std::fmt::Debug for MSV1_0_VALIDATION_INFO {
7304     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7305         fmt.debug_struct("MSV1_0_VALIDATION_INFO")
7306             .field("LogoffTime", &self.LogoffTime)
7307             .field("KickoffTime", &self.KickoffTime)
7308             .field("LogonServer", &self.LogonServer)
7309             .field("LogonDomainName", &self.LogonDomainName)
7310             .field("SessionKey", &self.SessionKey)
7311             .field("Authoritative", &self.Authoritative)
7312             .field("UserFlags", &self.UserFlags)
7313             .field("WhichFields", &self.WhichFields)
7314             .field("UserId", &self.UserId)
7315             .finish()
7316     }
7317 }
7318 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7319 impl ::std::cmp::PartialEq for MSV1_0_VALIDATION_INFO {
7320     fn eq(&self, other: &Self) -> bool {
7321         self.LogoffTime == other.LogoffTime && self.KickoffTime == other.KickoffTime && self.LogonServer == other.LogonServer && self.LogonDomainName == other.LogonDomainName && self.SessionKey == other.SessionKey && self.Authoritative == other.Authoritative && self.UserFlags == other.UserFlags && self.WhichFields == other.WhichFields && self.UserId == other.UserId
7322     }
7323 }
7324 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7325 impl ::std::cmp::Eq for MSV1_0_VALIDATION_INFO {}
7326 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7327 unsafe impl ::windows::runtime::Abi for MSV1_0_VALIDATION_INFO {
7328     type Abi = Self;
7329     type DefaultType = Self;
7330 }
7331 pub const MSV1_0_VALIDATION_KICKOFF_TIME: u32 = 2u32;
7332 pub const MSV1_0_VALIDATION_LOGOFF_TIME: u32 = 1u32;
7333 pub const MSV1_0_VALIDATION_LOGON_DOMAIN: u32 = 8u32;
7334 pub const MSV1_0_VALIDATION_LOGON_SERVER: u32 = 4u32;
7335 pub const MSV1_0_VALIDATION_SESSION_KEY: u32 = 16u32;
7336 pub const MSV1_0_VALIDATION_USER_FLAGS: u32 = 32u32;
7337 pub const MSV1_0_VALIDATION_USER_ID: u32 = 64u32;
7338 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7339 #[repr(transparent)]
7340 pub struct MSV_SUBAUTH_LOGON_PARAMETER_CONTROL(pub u32);
7341 pub const MSV1_0_CLEARTEXT_PASSWORD_ALLOWED: MSV_SUBAUTH_LOGON_PARAMETER_CONTROL = MSV_SUBAUTH_LOGON_PARAMETER_CONTROL(2u32);
7342 pub const MSV1_0_UPDATE_LOGON_STATISTICS: MSV_SUBAUTH_LOGON_PARAMETER_CONTROL = MSV_SUBAUTH_LOGON_PARAMETER_CONTROL(4u32);
7343 pub const MSV1_0_RETURN_USER_PARAMETERS: MSV_SUBAUTH_LOGON_PARAMETER_CONTROL = MSV_SUBAUTH_LOGON_PARAMETER_CONTROL(8u32);
7344 pub const MSV1_0_DONT_TRY_GUEST_ACCOUNT: MSV_SUBAUTH_LOGON_PARAMETER_CONTROL = MSV_SUBAUTH_LOGON_PARAMETER_CONTROL(16u32);
7345 pub const MSV1_0_ALLOW_SERVER_TRUST_ACCOUNT: MSV_SUBAUTH_LOGON_PARAMETER_CONTROL = MSV_SUBAUTH_LOGON_PARAMETER_CONTROL(32u32);
7346 pub const MSV1_0_RETURN_PASSWORD_EXPIRY: MSV_SUBAUTH_LOGON_PARAMETER_CONTROL = MSV_SUBAUTH_LOGON_PARAMETER_CONTROL(64u32);
7347 pub const MSV1_0_ALLOW_WORKSTATION_TRUST_ACCOUNT: MSV_SUBAUTH_LOGON_PARAMETER_CONTROL = MSV_SUBAUTH_LOGON_PARAMETER_CONTROL(2048u32);
7348 pub const MSV1_0_TRY_GUEST_ACCOUNT_ONLY: MSV_SUBAUTH_LOGON_PARAMETER_CONTROL = MSV_SUBAUTH_LOGON_PARAMETER_CONTROL(256u32);
7349 pub const MSV1_0_RETURN_PROFILE_PATH: MSV_SUBAUTH_LOGON_PARAMETER_CONTROL = MSV_SUBAUTH_LOGON_PARAMETER_CONTROL(512u32);
7350 pub const MSV1_0_TRY_SPECIFIED_DOMAIN_ONLY: MSV_SUBAUTH_LOGON_PARAMETER_CONTROL = MSV_SUBAUTH_LOGON_PARAMETER_CONTROL(1024u32);
7351 impl ::std::convert::From<u32> for MSV_SUBAUTH_LOGON_PARAMETER_CONTROL {
7352     fn from(value: u32) -> Self {
7353         Self(value)
7354     }
7355 }
7356 unsafe impl ::windows::runtime::Abi for MSV_SUBAUTH_LOGON_PARAMETER_CONTROL {
7357     type Abi = Self;
7358     type DefaultType = Self;
7359 }
7360 impl ::std::ops::BitOr for MSV_SUBAUTH_LOGON_PARAMETER_CONTROL {
7361     type Output = Self;
7362     fn bitor(self, rhs: Self) -> Self {
7363         Self(self.0 | rhs.0)
7364     }
7365 }
7366 impl ::std::ops::BitAnd for MSV_SUBAUTH_LOGON_PARAMETER_CONTROL {
7367     type Output = Self;
7368     fn bitand(self, rhs: Self) -> Self {
7369         Self(self.0 & rhs.0)
7370     }
7371 }
7372 impl ::std::ops::BitOrAssign for MSV_SUBAUTH_LOGON_PARAMETER_CONTROL {
7373     fn bitor_assign(&mut self, rhs: Self) {
7374         self.0.bitor_assign(rhs.0)
7375     }
7376 }
7377 impl ::std::ops::BitAndAssign for MSV_SUBAUTH_LOGON_PARAMETER_CONTROL {
7378     fn bitand_assign(&mut self, rhs: Self) {
7379         self.0.bitand_assign(rhs.0)
7380     }
7381 }
7382 impl ::std::ops::Not for MSV_SUBAUTH_LOGON_PARAMETER_CONTROL {
7383     type Output = Self;
7384     fn not(self) -> Self {
7385         Self(self.0.not())
7386     }
7387 }
7388 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7389 #[repr(transparent)]
7390 pub struct MSV_SUB_AUTHENTICATION_FILTER(pub u32);
7391 pub const LOGON_GUEST: MSV_SUB_AUTHENTICATION_FILTER = MSV_SUB_AUTHENTICATION_FILTER(1u32);
7392 pub const LOGON_NOENCRYPTION: MSV_SUB_AUTHENTICATION_FILTER = MSV_SUB_AUTHENTICATION_FILTER(2u32);
7393 pub const LOGON_CACHED_ACCOUNT: MSV_SUB_AUTHENTICATION_FILTER = MSV_SUB_AUTHENTICATION_FILTER(4u32);
7394 pub const LOGON_USED_LM_PASSWORD: MSV_SUB_AUTHENTICATION_FILTER = MSV_SUB_AUTHENTICATION_FILTER(8u32);
7395 pub const LOGON_EXTRA_SIDS: MSV_SUB_AUTHENTICATION_FILTER = MSV_SUB_AUTHENTICATION_FILTER(32u32);
7396 pub const LOGON_SUBAUTH_SESSION_KEY: MSV_SUB_AUTHENTICATION_FILTER = MSV_SUB_AUTHENTICATION_FILTER(64u32);
7397 pub const LOGON_SERVER_TRUST_ACCOUNT: MSV_SUB_AUTHENTICATION_FILTER = MSV_SUB_AUTHENTICATION_FILTER(128u32);
7398 pub const LOGON_PROFILE_PATH_RETURNED: MSV_SUB_AUTHENTICATION_FILTER = MSV_SUB_AUTHENTICATION_FILTER(1024u32);
7399 pub const LOGON_RESOURCE_GROUPS: MSV_SUB_AUTHENTICATION_FILTER = MSV_SUB_AUTHENTICATION_FILTER(512u32);
7400 impl ::std::convert::From<u32> for MSV_SUB_AUTHENTICATION_FILTER {
7401     fn from(value: u32) -> Self {
7402         Self(value)
7403     }
7404 }
7405 unsafe impl ::windows::runtime::Abi for MSV_SUB_AUTHENTICATION_FILTER {
7406     type Abi = Self;
7407     type DefaultType = Self;
7408 }
7409 impl ::std::ops::BitOr for MSV_SUB_AUTHENTICATION_FILTER {
7410     type Output = Self;
7411     fn bitor(self, rhs: Self) -> Self {
7412         Self(self.0 | rhs.0)
7413     }
7414 }
7415 impl ::std::ops::BitAnd for MSV_SUB_AUTHENTICATION_FILTER {
7416     type Output = Self;
7417     fn bitand(self, rhs: Self) -> Self {
7418         Self(self.0 & rhs.0)
7419     }
7420 }
7421 impl ::std::ops::BitOrAssign for MSV_SUB_AUTHENTICATION_FILTER {
7422     fn bitor_assign(&mut self, rhs: Self) {
7423         self.0.bitor_assign(rhs.0)
7424     }
7425 }
7426 impl ::std::ops::BitAndAssign for MSV_SUB_AUTHENTICATION_FILTER {
7427     fn bitand_assign(&mut self, rhs: Self) {
7428         self.0.bitand_assign(rhs.0)
7429     }
7430 }
7431 impl ::std::ops::Not for MSV_SUB_AUTHENTICATION_FILTER {
7432     type Output = Self;
7433     fn not(self) -> Self {
7434         Self(self.0.not())
7435     }
7436 }
7437 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7438 #[repr(transparent)]
7439 pub struct MSV_SUPPLEMENTAL_CREDENTIAL_FLAGS(pub u32);
7440 pub const MSV1_0_CRED_LM_PRESENT: MSV_SUPPLEMENTAL_CREDENTIAL_FLAGS = MSV_SUPPLEMENTAL_CREDENTIAL_FLAGS(1u32);
7441 pub const MSV1_0_CRED_NT_PRESENT: MSV_SUPPLEMENTAL_CREDENTIAL_FLAGS = MSV_SUPPLEMENTAL_CREDENTIAL_FLAGS(2u32);
7442 pub const MSV1_0_CRED_VERSION: MSV_SUPPLEMENTAL_CREDENTIAL_FLAGS = MSV_SUPPLEMENTAL_CREDENTIAL_FLAGS(0u32);
7443 impl ::std::convert::From<u32> for MSV_SUPPLEMENTAL_CREDENTIAL_FLAGS {
7444     fn from(value: u32) -> Self {
7445         Self(value)
7446     }
7447 }
7448 unsafe impl ::windows::runtime::Abi for MSV_SUPPLEMENTAL_CREDENTIAL_FLAGS {
7449     type Abi = Self;
7450     type DefaultType = Self;
7451 }
7452 impl ::std::ops::BitOr for MSV_SUPPLEMENTAL_CREDENTIAL_FLAGS {
7453     type Output = Self;
7454     fn bitor(self, rhs: Self) -> Self {
7455         Self(self.0 | rhs.0)
7456     }
7457 }
7458 impl ::std::ops::BitAnd for MSV_SUPPLEMENTAL_CREDENTIAL_FLAGS {
7459     type Output = Self;
7460     fn bitand(self, rhs: Self) -> Self {
7461         Self(self.0 & rhs.0)
7462     }
7463 }
7464 impl ::std::ops::BitOrAssign for MSV_SUPPLEMENTAL_CREDENTIAL_FLAGS {
7465     fn bitor_assign(&mut self, rhs: Self) {
7466         self.0.bitor_assign(rhs.0)
7467     }
7468 }
7469 impl ::std::ops::BitAndAssign for MSV_SUPPLEMENTAL_CREDENTIAL_FLAGS {
7470     fn bitand_assign(&mut self, rhs: Self) {
7471         self.0.bitand_assign(rhs.0)
7472     }
7473 }
7474 impl ::std::ops::Not for MSV_SUPPLEMENTAL_CREDENTIAL_FLAGS {
7475     type Output = Self;
7476     fn not(self) -> Self {
7477         Self(self.0.not())
7478     }
7479 }
7480 #[cfg(feature = "Win32_Security_Credentials")]
7481 #[inline]
7482 pub unsafe fn MakeSignature(phcontext: *const super::super::Credentials::SecHandle, fqop: u32, pmessage: *const SecBufferDesc, messageseqno: u32) -> i32 {
7483     #[cfg(windows)]
7484     {
7485         #[link(name = "windows")]
7486         extern "system" {
7487             fn MakeSignature(phcontext: *const super::super::Credentials::SecHandle, fqop: u32, pmessage: *const SecBufferDesc, messageseqno: u32) -> i32;
7488         }
7489         ::std::mem::transmute(MakeSignature(::std::mem::transmute(phcontext), ::std::mem::transmute(fqop), ::std::mem::transmute(pmessage), ::std::mem::transmute(messageseqno)))
7490     }
7491     #[cfg(not(windows))]
7492     unimplemented!("Unsupported target OS");
7493 }
7494 pub const NEGOTIATE_ALLOW_NTLM: u32 = 268435456u32;
7495 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7496 #[repr(C)]
7497 #[cfg(feature = "Win32_Foundation")]
7498 pub struct NEGOTIATE_CALLER_NAME_REQUEST {
7499     pub MessageType: u32,
7500     pub LogonId: super::super::super::Foundation::LUID,
7501 }
7502 #[cfg(feature = "Win32_Foundation")]
7503 impl NEGOTIATE_CALLER_NAME_REQUEST {}
7504 #[cfg(feature = "Win32_Foundation")]
7505 impl ::std::default::Default for NEGOTIATE_CALLER_NAME_REQUEST {
7506     fn default() -> Self {
7507         unsafe { ::std::mem::zeroed() }
7508     }
7509 }
7510 #[cfg(feature = "Win32_Foundation")]
7511 impl ::std::fmt::Debug for NEGOTIATE_CALLER_NAME_REQUEST {
7512     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7513         fmt.debug_struct("NEGOTIATE_CALLER_NAME_REQUEST").field("MessageType", &self.MessageType).field("LogonId", &self.LogonId).finish()
7514     }
7515 }
7516 #[cfg(feature = "Win32_Foundation")]
7517 impl ::std::cmp::PartialEq for NEGOTIATE_CALLER_NAME_REQUEST {
7518     fn eq(&self, other: &Self) -> bool {
7519         self.MessageType == other.MessageType && self.LogonId == other.LogonId
7520     }
7521 }
7522 #[cfg(feature = "Win32_Foundation")]
7523 impl ::std::cmp::Eq for NEGOTIATE_CALLER_NAME_REQUEST {}
7524 #[cfg(feature = "Win32_Foundation")]
7525 unsafe impl ::windows::runtime::Abi for NEGOTIATE_CALLER_NAME_REQUEST {
7526     type Abi = Self;
7527     type DefaultType = Self;
7528 }
7529 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7530 #[repr(C)]
7531 #[cfg(feature = "Win32_Foundation")]
7532 pub struct NEGOTIATE_CALLER_NAME_RESPONSE {
7533     pub MessageType: u32,
7534     pub CallerName: super::super::super::Foundation::PWSTR,
7535 }
7536 #[cfg(feature = "Win32_Foundation")]
7537 impl NEGOTIATE_CALLER_NAME_RESPONSE {}
7538 #[cfg(feature = "Win32_Foundation")]
7539 impl ::std::default::Default for NEGOTIATE_CALLER_NAME_RESPONSE {
7540     fn default() -> Self {
7541         unsafe { ::std::mem::zeroed() }
7542     }
7543 }
7544 #[cfg(feature = "Win32_Foundation")]
7545 impl ::std::fmt::Debug for NEGOTIATE_CALLER_NAME_RESPONSE {
7546     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7547         fmt.debug_struct("NEGOTIATE_CALLER_NAME_RESPONSE").field("MessageType", &self.MessageType).field("CallerName", &self.CallerName).finish()
7548     }
7549 }
7550 #[cfg(feature = "Win32_Foundation")]
7551 impl ::std::cmp::PartialEq for NEGOTIATE_CALLER_NAME_RESPONSE {
7552     fn eq(&self, other: &Self) -> bool {
7553         self.MessageType == other.MessageType && self.CallerName == other.CallerName
7554     }
7555 }
7556 #[cfg(feature = "Win32_Foundation")]
7557 impl ::std::cmp::Eq for NEGOTIATE_CALLER_NAME_RESPONSE {}
7558 #[cfg(feature = "Win32_Foundation")]
7559 unsafe impl ::windows::runtime::Abi for NEGOTIATE_CALLER_NAME_RESPONSE {
7560     type Abi = Self;
7561     type DefaultType = Self;
7562 }
7563 pub const NEGOTIATE_MAX_PREFIX: u32 = 32u32;
7564 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7565 #[repr(transparent)]
7566 pub struct NEGOTIATE_MESSAGES(pub i32);
7567 pub const NegEnumPackagePrefixes: NEGOTIATE_MESSAGES = NEGOTIATE_MESSAGES(0i32);
7568 pub const NegGetCallerName: NEGOTIATE_MESSAGES = NEGOTIATE_MESSAGES(1i32);
7569 pub const NegTransferCredentials: NEGOTIATE_MESSAGES = NEGOTIATE_MESSAGES(2i32);
7570 pub const NegMsgReserved1: NEGOTIATE_MESSAGES = NEGOTIATE_MESSAGES(3i32);
7571 pub const NegCallPackageMax: NEGOTIATE_MESSAGES = NEGOTIATE_MESSAGES(4i32);
7572 impl ::std::convert::From<i32> for NEGOTIATE_MESSAGES {
7573     fn from(value: i32) -> Self {
7574         Self(value)
7575     }
7576 }
7577 unsafe impl ::windows::runtime::Abi for NEGOTIATE_MESSAGES {
7578     type Abi = Self;
7579     type DefaultType = Self;
7580 }
7581 pub const NEGOTIATE_NEG_NTLM: u32 = 536870912u32;
7582 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7583 #[repr(C)]
7584 pub struct NEGOTIATE_PACKAGE_PREFIX {
7585     pub PackageId: usize,
7586     pub PackageDataA: *mut ::std::ffi::c_void,
7587     pub PackageDataW: *mut ::std::ffi::c_void,
7588     pub PrefixLen: usize,
7589     pub Prefix: [u8; 32],
7590 }
7591 impl NEGOTIATE_PACKAGE_PREFIX {}
7592 impl ::std::default::Default for NEGOTIATE_PACKAGE_PREFIX {
7593     fn default() -> Self {
7594         unsafe { ::std::mem::zeroed() }
7595     }
7596 }
7597 impl ::std::fmt::Debug for NEGOTIATE_PACKAGE_PREFIX {
7598     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7599         fmt.debug_struct("NEGOTIATE_PACKAGE_PREFIX").field("PackageId", &self.PackageId).field("PackageDataA", &self.PackageDataA).field("PackageDataW", &self.PackageDataW).field("PrefixLen", &self.PrefixLen).field("Prefix", &self.Prefix).finish()
7600     }
7601 }
7602 impl ::std::cmp::PartialEq for NEGOTIATE_PACKAGE_PREFIX {
7603     fn eq(&self, other: &Self) -> bool {
7604         self.PackageId == other.PackageId && self.PackageDataA == other.PackageDataA && self.PackageDataW == other.PackageDataW && self.PrefixLen == other.PrefixLen && self.Prefix == other.Prefix
7605     }
7606 }
7607 impl ::std::cmp::Eq for NEGOTIATE_PACKAGE_PREFIX {}
7608 unsafe impl ::windows::runtime::Abi for NEGOTIATE_PACKAGE_PREFIX {
7609     type Abi = Self;
7610     type DefaultType = Self;
7611 }
7612 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7613 #[repr(C)]
7614 pub struct NEGOTIATE_PACKAGE_PREFIXES {
7615     pub MessageType: u32,
7616     pub PrefixCount: u32,
7617     pub Offset: u32,
7618     pub Pad: u32,
7619 }
7620 impl NEGOTIATE_PACKAGE_PREFIXES {}
7621 impl ::std::default::Default for NEGOTIATE_PACKAGE_PREFIXES {
7622     fn default() -> Self {
7623         unsafe { ::std::mem::zeroed() }
7624     }
7625 }
7626 impl ::std::fmt::Debug for NEGOTIATE_PACKAGE_PREFIXES {
7627     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7628         fmt.debug_struct("NEGOTIATE_PACKAGE_PREFIXES").field("MessageType", &self.MessageType).field("PrefixCount", &self.PrefixCount).field("Offset", &self.Offset).field("Pad", &self.Pad).finish()
7629     }
7630 }
7631 impl ::std::cmp::PartialEq for NEGOTIATE_PACKAGE_PREFIXES {
7632     fn eq(&self, other: &Self) -> bool {
7633         self.MessageType == other.MessageType && self.PrefixCount == other.PrefixCount && self.Offset == other.Offset && self.Pad == other.Pad
7634     }
7635 }
7636 impl ::std::cmp::Eq for NEGOTIATE_PACKAGE_PREFIXES {}
7637 unsafe impl ::windows::runtime::Abi for NEGOTIATE_PACKAGE_PREFIXES {
7638     type Abi = Self;
7639     type DefaultType = Self;
7640 }
7641 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7642 #[repr(C)]
7643 #[cfg(feature = "Win32_Foundation")]
7644 pub struct NETLOGON_GENERIC_INFO {
7645     pub Identity: NETLOGON_LOGON_IDENTITY_INFO,
7646     pub PackageName: super::super::super::Foundation::UNICODE_STRING,
7647     pub DataLength: u32,
7648     pub LogonData: *mut u8,
7649 }
7650 #[cfg(feature = "Win32_Foundation")]
7651 impl NETLOGON_GENERIC_INFO {}
7652 #[cfg(feature = "Win32_Foundation")]
7653 impl ::std::default::Default for NETLOGON_GENERIC_INFO {
7654     fn default() -> Self {
7655         unsafe { ::std::mem::zeroed() }
7656     }
7657 }
7658 #[cfg(feature = "Win32_Foundation")]
7659 impl ::std::fmt::Debug for NETLOGON_GENERIC_INFO {
7660     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7661         fmt.debug_struct("NETLOGON_GENERIC_INFO").field("Identity", &self.Identity).field("PackageName", &self.PackageName).field("DataLength", &self.DataLength).field("LogonData", &self.LogonData).finish()
7662     }
7663 }
7664 #[cfg(feature = "Win32_Foundation")]
7665 impl ::std::cmp::PartialEq for NETLOGON_GENERIC_INFO {
7666     fn eq(&self, other: &Self) -> bool {
7667         self.Identity == other.Identity && self.PackageName == other.PackageName && self.DataLength == other.DataLength && self.LogonData == other.LogonData
7668     }
7669 }
7670 #[cfg(feature = "Win32_Foundation")]
7671 impl ::std::cmp::Eq for NETLOGON_GENERIC_INFO {}
7672 #[cfg(feature = "Win32_Foundation")]
7673 unsafe impl ::windows::runtime::Abi for NETLOGON_GENERIC_INFO {
7674     type Abi = Self;
7675     type DefaultType = Self;
7676 }
7677 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7678 #[repr(C)]
7679 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7680 pub struct NETLOGON_INTERACTIVE_INFO {
7681     pub Identity: NETLOGON_LOGON_IDENTITY_INFO,
7682     pub LmOwfPassword: super::super::super::System::PasswordManagement::LM_OWF_PASSWORD,
7683     pub NtOwfPassword: super::super::super::System::PasswordManagement::LM_OWF_PASSWORD,
7684 }
7685 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7686 impl NETLOGON_INTERACTIVE_INFO {}
7687 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7688 impl ::std::default::Default for NETLOGON_INTERACTIVE_INFO {
7689     fn default() -> Self {
7690         unsafe { ::std::mem::zeroed() }
7691     }
7692 }
7693 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7694 impl ::std::fmt::Debug for NETLOGON_INTERACTIVE_INFO {
7695     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7696         fmt.debug_struct("NETLOGON_INTERACTIVE_INFO").field("Identity", &self.Identity).field("LmOwfPassword", &self.LmOwfPassword).field("NtOwfPassword", &self.NtOwfPassword).finish()
7697     }
7698 }
7699 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7700 impl ::std::cmp::PartialEq for NETLOGON_INTERACTIVE_INFO {
7701     fn eq(&self, other: &Self) -> bool {
7702         self.Identity == other.Identity && self.LmOwfPassword == other.LmOwfPassword && self.NtOwfPassword == other.NtOwfPassword
7703     }
7704 }
7705 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7706 impl ::std::cmp::Eq for NETLOGON_INTERACTIVE_INFO {}
7707 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7708 unsafe impl ::windows::runtime::Abi for NETLOGON_INTERACTIVE_INFO {
7709     type Abi = Self;
7710     type DefaultType = Self;
7711 }
7712 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7713 #[repr(C)]
7714 #[cfg(feature = "Win32_Foundation")]
7715 pub struct NETLOGON_LOGON_IDENTITY_INFO {
7716     pub LogonDomainName: super::super::super::Foundation::UNICODE_STRING,
7717     pub ParameterControl: u32,
7718     pub LogonId: i64,
7719     pub UserName: super::super::super::Foundation::UNICODE_STRING,
7720     pub Workstation: super::super::super::Foundation::UNICODE_STRING,
7721 }
7722 #[cfg(feature = "Win32_Foundation")]
7723 impl NETLOGON_LOGON_IDENTITY_INFO {}
7724 #[cfg(feature = "Win32_Foundation")]
7725 impl ::std::default::Default for NETLOGON_LOGON_IDENTITY_INFO {
7726     fn default() -> Self {
7727         unsafe { ::std::mem::zeroed() }
7728     }
7729 }
7730 #[cfg(feature = "Win32_Foundation")]
7731 impl ::std::fmt::Debug for NETLOGON_LOGON_IDENTITY_INFO {
7732     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7733         fmt.debug_struct("NETLOGON_LOGON_IDENTITY_INFO").field("LogonDomainName", &self.LogonDomainName).field("ParameterControl", &self.ParameterControl).field("LogonId", &self.LogonId).field("UserName", &self.UserName).field("Workstation", &self.Workstation).finish()
7734     }
7735 }
7736 #[cfg(feature = "Win32_Foundation")]
7737 impl ::std::cmp::PartialEq for NETLOGON_LOGON_IDENTITY_INFO {
7738     fn eq(&self, other: &Self) -> bool {
7739         self.LogonDomainName == other.LogonDomainName && self.ParameterControl == other.ParameterControl && self.LogonId == other.LogonId && self.UserName == other.UserName && self.Workstation == other.Workstation
7740     }
7741 }
7742 #[cfg(feature = "Win32_Foundation")]
7743 impl ::std::cmp::Eq for NETLOGON_LOGON_IDENTITY_INFO {}
7744 #[cfg(feature = "Win32_Foundation")]
7745 unsafe impl ::windows::runtime::Abi for NETLOGON_LOGON_IDENTITY_INFO {
7746     type Abi = Self;
7747     type DefaultType = Self;
7748 }
7749 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7750 #[repr(transparent)]
7751 pub struct NETLOGON_LOGON_INFO_CLASS(pub i32);
7752 pub const NetlogonInteractiveInformation: NETLOGON_LOGON_INFO_CLASS = NETLOGON_LOGON_INFO_CLASS(1i32);
7753 pub const NetlogonNetworkInformation: NETLOGON_LOGON_INFO_CLASS = NETLOGON_LOGON_INFO_CLASS(2i32);
7754 pub const NetlogonServiceInformation: NETLOGON_LOGON_INFO_CLASS = NETLOGON_LOGON_INFO_CLASS(3i32);
7755 pub const NetlogonGenericInformation: NETLOGON_LOGON_INFO_CLASS = NETLOGON_LOGON_INFO_CLASS(4i32);
7756 pub const NetlogonInteractiveTransitiveInformation: NETLOGON_LOGON_INFO_CLASS = NETLOGON_LOGON_INFO_CLASS(5i32);
7757 pub const NetlogonNetworkTransitiveInformation: NETLOGON_LOGON_INFO_CLASS = NETLOGON_LOGON_INFO_CLASS(6i32);
7758 pub const NetlogonServiceTransitiveInformation: NETLOGON_LOGON_INFO_CLASS = NETLOGON_LOGON_INFO_CLASS(7i32);
7759 impl ::std::convert::From<i32> for NETLOGON_LOGON_INFO_CLASS {
7760     fn from(value: i32) -> Self {
7761         Self(value)
7762     }
7763 }
7764 unsafe impl ::windows::runtime::Abi for NETLOGON_LOGON_INFO_CLASS {
7765     type Abi = Self;
7766     type DefaultType = Self;
7767 }
7768 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7769 #[repr(C)]
7770 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
7771 pub struct NETLOGON_NETWORK_INFO {
7772     pub Identity: NETLOGON_LOGON_IDENTITY_INFO,
7773     pub LmChallenge: CLEAR_BLOCK,
7774     pub NtChallengeResponse: super::super::super::System::Kernel::STRING,
7775     pub LmChallengeResponse: super::super::super::System::Kernel::STRING,
7776 }
7777 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
7778 impl NETLOGON_NETWORK_INFO {}
7779 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
7780 impl ::std::default::Default for NETLOGON_NETWORK_INFO {
7781     fn default() -> Self {
7782         unsafe { ::std::mem::zeroed() }
7783     }
7784 }
7785 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
7786 impl ::std::fmt::Debug for NETLOGON_NETWORK_INFO {
7787     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7788         fmt.debug_struct("NETLOGON_NETWORK_INFO").field("Identity", &self.Identity).field("LmChallenge", &self.LmChallenge).field("NtChallengeResponse", &self.NtChallengeResponse).field("LmChallengeResponse", &self.LmChallengeResponse).finish()
7789     }
7790 }
7791 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
7792 impl ::std::cmp::PartialEq for NETLOGON_NETWORK_INFO {
7793     fn eq(&self, other: &Self) -> bool {
7794         self.Identity == other.Identity && self.LmChallenge == other.LmChallenge && self.NtChallengeResponse == other.NtChallengeResponse && self.LmChallengeResponse == other.LmChallengeResponse
7795     }
7796 }
7797 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
7798 impl ::std::cmp::Eq for NETLOGON_NETWORK_INFO {}
7799 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
7800 unsafe impl ::windows::runtime::Abi for NETLOGON_NETWORK_INFO {
7801     type Abi = Self;
7802     type DefaultType = Self;
7803 }
7804 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7805 #[repr(C)]
7806 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7807 pub struct NETLOGON_SERVICE_INFO {
7808     pub Identity: NETLOGON_LOGON_IDENTITY_INFO,
7809     pub LmOwfPassword: super::super::super::System::PasswordManagement::LM_OWF_PASSWORD,
7810     pub NtOwfPassword: super::super::super::System::PasswordManagement::LM_OWF_PASSWORD,
7811 }
7812 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7813 impl NETLOGON_SERVICE_INFO {}
7814 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7815 impl ::std::default::Default for NETLOGON_SERVICE_INFO {
7816     fn default() -> Self {
7817         unsafe { ::std::mem::zeroed() }
7818     }
7819 }
7820 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7821 impl ::std::fmt::Debug for NETLOGON_SERVICE_INFO {
7822     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7823         fmt.debug_struct("NETLOGON_SERVICE_INFO").field("Identity", &self.Identity).field("LmOwfPassword", &self.LmOwfPassword).field("NtOwfPassword", &self.NtOwfPassword).finish()
7824     }
7825 }
7826 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7827 impl ::std::cmp::PartialEq for NETLOGON_SERVICE_INFO {
7828     fn eq(&self, other: &Self) -> bool {
7829         self.Identity == other.Identity && self.LmOwfPassword == other.LmOwfPassword && self.NtOwfPassword == other.NtOwfPassword
7830     }
7831 }
7832 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7833 impl ::std::cmp::Eq for NETLOGON_SERVICE_INFO {}
7834 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
7835 unsafe impl ::windows::runtime::Abi for NETLOGON_SERVICE_INFO {
7836     type Abi = Self;
7837     type DefaultType = Self;
7838 }
7839 pub const NGC_DATA_FLAG_IS_CLOUD_TRUST_CRED: u32 = 8u32;
7840 pub const NGC_DATA_FLAG_IS_SMARTCARD_DATA: u32 = 4u32;
7841 pub const NGC_DATA_FLAG_KERB_CERTIFICATE_LOGON_FLAG_CHECK_DUPLICATES: u32 = 1u32;
7842 pub const NGC_DATA_FLAG_KERB_CERTIFICATE_LOGON_FLAG_USE_CERTIFICATE_INFO: u32 = 2u32;
7843 pub const NOTIFIER_FLAG_NEW_THREAD: u32 = 1u32;
7844 pub const NOTIFIER_FLAG_ONE_SHOT: u32 = 2u32;
7845 pub const NOTIFIER_FLAG_SECONDS: u32 = 2147483648u32;
7846 pub const NOTIFIER_TYPE_HANDLE_WAIT: u32 = 2u32;
7847 pub const NOTIFIER_TYPE_IMMEDIATE: u32 = 16u32;
7848 pub const NOTIFIER_TYPE_INTERVAL: u32 = 1u32;
7849 pub const NOTIFIER_TYPE_NOTIFY_EVENT: u32 = 4u32;
7850 pub const NOTIFIER_TYPE_STATE_CHANGE: u32 = 3u32;
7851 pub const NOTIFY_CLASS_DOMAIN_CHANGE: u32 = 3u32;
7852 pub const NOTIFY_CLASS_PACKAGE_CHANGE: u32 = 1u32;
7853 pub const NOTIFY_CLASS_REGISTRY_CHANGE: u32 = 4u32;
7854 pub const NOTIFY_CLASS_ROLE_CHANGE: u32 = 2u32;
7855 pub const NO_LONG_NAMES: u32 = 2u32;
7856 pub const PER_USER_AUDIT_FAILURE_EXCLUDE: u32 = 8u32;
7857 pub const PER_USER_AUDIT_FAILURE_INCLUDE: u32 = 4u32;
7858 pub const PER_USER_AUDIT_NONE: u32 = 16u32;
7859 pub const PER_USER_AUDIT_SUCCESS_EXCLUDE: u32 = 2u32;
7860 pub const PER_USER_AUDIT_SUCCESS_INCLUDE: u32 = 1u32;
7861 pub const PER_USER_POLICY_UNCHANGED: u32 = 0u32;
7862 pub type PKSEC_CREATE_CONTEXT_LIST = unsafe extern "system" fn(r#type: KSEC_CONTEXT_TYPE) -> *mut ::std::ffi::c_void;
7863 #[cfg(feature = "Win32_System_Kernel")]
7864 pub type PKSEC_DEREFERENCE_LIST_ENTRY = unsafe extern "system" fn(entry: *const KSEC_LIST_ENTRY, delete: *mut u8);
7865 #[cfg(feature = "Win32_System_Kernel")]
7866 pub type PKSEC_INSERT_LIST_ENTRY = unsafe extern "system" fn(list: *const ::std::ffi::c_void, entry: *const KSEC_LIST_ENTRY);
7867 pub type PKSEC_LOCATE_PKG_BY_ID = unsafe extern "system" fn(packageid: u32) -> *mut ::std::ffi::c_void;
7868 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
7869 pub type PKSEC_REFERENCE_LIST_ENTRY = unsafe extern "system" fn(entry: *const KSEC_LIST_ENTRY, signature: u32, removenoref: super::super::super::Foundation::BOOLEAN) -> super::super::super::Foundation::NTSTATUS;
7870 #[cfg(feature = "Win32_Foundation")]
7871 pub type PKSEC_SERIALIZE_SCHANNEL_AUTH_DATA = unsafe extern "system" fn(pvauthdata: *const ::std::ffi::c_void, size: *mut u32, serializeddata: *mut *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
7872 #[cfg(feature = "Win32_Foundation")]
7873 pub type PKSEC_SERIALIZE_WINNT_AUTH_DATA = unsafe extern "system" fn(pvauthdata: *const ::std::ffi::c_void, size: *mut u32, serializeddata: *mut *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
7874 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7875 #[repr(C)]
7876 #[cfg(feature = "Win32_Foundation")]
7877 pub struct PKU2U_CERTIFICATE_S4U_LOGON {
7878     pub MessageType: PKU2U_LOGON_SUBMIT_TYPE,
7879     pub Flags: u32,
7880     pub UserPrincipalName: super::super::super::Foundation::UNICODE_STRING,
7881     pub DomainName: super::super::super::Foundation::UNICODE_STRING,
7882     pub CertificateLength: u32,
7883     pub Certificate: *mut u8,
7884 }
7885 #[cfg(feature = "Win32_Foundation")]
7886 impl PKU2U_CERTIFICATE_S4U_LOGON {}
7887 #[cfg(feature = "Win32_Foundation")]
7888 impl ::std::default::Default for PKU2U_CERTIFICATE_S4U_LOGON {
7889     fn default() -> Self {
7890         unsafe { ::std::mem::zeroed() }
7891     }
7892 }
7893 #[cfg(feature = "Win32_Foundation")]
7894 impl ::std::fmt::Debug for PKU2U_CERTIFICATE_S4U_LOGON {
7895     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7896         fmt.debug_struct("PKU2U_CERTIFICATE_S4U_LOGON")
7897             .field("MessageType", &self.MessageType)
7898             .field("Flags", &self.Flags)
7899             .field("UserPrincipalName", &self.UserPrincipalName)
7900             .field("DomainName", &self.DomainName)
7901             .field("CertificateLength", &self.CertificateLength)
7902             .field("Certificate", &self.Certificate)
7903             .finish()
7904     }
7905 }
7906 #[cfg(feature = "Win32_Foundation")]
7907 impl ::std::cmp::PartialEq for PKU2U_CERTIFICATE_S4U_LOGON {
7908     fn eq(&self, other: &Self) -> bool {
7909         self.MessageType == other.MessageType && self.Flags == other.Flags && self.UserPrincipalName == other.UserPrincipalName && self.DomainName == other.DomainName && self.CertificateLength == other.CertificateLength && self.Certificate == other.Certificate
7910     }
7911 }
7912 #[cfg(feature = "Win32_Foundation")]
7913 impl ::std::cmp::Eq for PKU2U_CERTIFICATE_S4U_LOGON {}
7914 #[cfg(feature = "Win32_Foundation")]
7915 unsafe impl ::windows::runtime::Abi for PKU2U_CERTIFICATE_S4U_LOGON {
7916     type Abi = Self;
7917     type DefaultType = Self;
7918 }
7919 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7920 #[repr(C)]
7921 pub struct PKU2U_CERT_BLOB {
7922     pub CertOffset: u32,
7923     pub CertLength: u16,
7924 }
7925 impl PKU2U_CERT_BLOB {}
7926 impl ::std::default::Default for PKU2U_CERT_BLOB {
7927     fn default() -> Self {
7928         unsafe { ::std::mem::zeroed() }
7929     }
7930 }
7931 impl ::std::fmt::Debug for PKU2U_CERT_BLOB {
7932     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7933         fmt.debug_struct("PKU2U_CERT_BLOB").field("CertOffset", &self.CertOffset).field("CertLength", &self.CertLength).finish()
7934     }
7935 }
7936 impl ::std::cmp::PartialEq for PKU2U_CERT_BLOB {
7937     fn eq(&self, other: &Self) -> bool {
7938         self.CertOffset == other.CertOffset && self.CertLength == other.CertLength
7939     }
7940 }
7941 impl ::std::cmp::Eq for PKU2U_CERT_BLOB {}
7942 unsafe impl ::windows::runtime::Abi for PKU2U_CERT_BLOB {
7943     type Abi = Self;
7944     type DefaultType = Self;
7945 }
7946 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7947 #[repr(C)]
7948 pub struct PKU2U_CREDUI_CONTEXT {
7949     pub Version: u64,
7950     pub cbHeaderLength: u16,
7951     pub cbStructureLength: u32,
7952     pub CertArrayCount: u16,
7953     pub CertArrayOffset: u32,
7954 }
7955 impl PKU2U_CREDUI_CONTEXT {}
7956 impl ::std::default::Default for PKU2U_CREDUI_CONTEXT {
7957     fn default() -> Self {
7958         unsafe { ::std::mem::zeroed() }
7959     }
7960 }
7961 impl ::std::fmt::Debug for PKU2U_CREDUI_CONTEXT {
7962     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7963         fmt.debug_struct("PKU2U_CREDUI_CONTEXT").field("Version", &self.Version).field("cbHeaderLength", &self.cbHeaderLength).field("cbStructureLength", &self.cbStructureLength).field("CertArrayCount", &self.CertArrayCount).field("CertArrayOffset", &self.CertArrayOffset).finish()
7964     }
7965 }
7966 impl ::std::cmp::PartialEq for PKU2U_CREDUI_CONTEXT {
7967     fn eq(&self, other: &Self) -> bool {
7968         self.Version == other.Version && self.cbHeaderLength == other.cbHeaderLength && self.cbStructureLength == other.cbStructureLength && self.CertArrayCount == other.CertArrayCount && self.CertArrayOffset == other.CertArrayOffset
7969     }
7970 }
7971 impl ::std::cmp::Eq for PKU2U_CREDUI_CONTEXT {}
7972 unsafe impl ::windows::runtime::Abi for PKU2U_CREDUI_CONTEXT {
7973     type Abi = Self;
7974     type DefaultType = Self;
7975 }
7976 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7977 #[repr(transparent)]
7978 pub struct PKU2U_LOGON_SUBMIT_TYPE(pub i32);
7979 pub const Pku2uCertificateS4ULogon: PKU2U_LOGON_SUBMIT_TYPE = PKU2U_LOGON_SUBMIT_TYPE(14i32);
7980 impl ::std::convert::From<i32> for PKU2U_LOGON_SUBMIT_TYPE {
7981     fn from(value: i32) -> Self {
7982         Self(value)
7983     }
7984 }
7985 unsafe impl ::windows::runtime::Abi for PKU2U_LOGON_SUBMIT_TYPE {
7986     type Abi = Self;
7987     type DefaultType = Self;
7988 }
7989 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
7990 pub type PLSA_ADD_CREDENTIAL = unsafe extern "system" fn(logonid: *const super::super::super::Foundation::LUID, authenticationpackage: u32, primarykeyvalue: *const super::super::super::System::Kernel::STRING, credentials: *const super::super::super::System::Kernel::STRING) -> super::super::super::Foundation::NTSTATUS;
7991 #[cfg(feature = "Win32_Foundation")]
7992 pub type PLSA_ALLOCATE_CLIENT_BUFFER = unsafe extern "system" fn(clientrequest: *const *const ::std::ffi::c_void, lengthrequired: u32, clientbaseaddress: *mut *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
7993 pub type PLSA_ALLOCATE_LSA_HEAP = unsafe extern "system" fn(length: u32) -> *mut ::std::ffi::c_void;
7994 pub type PLSA_ALLOCATE_PRIVATE_HEAP = unsafe extern "system" fn(length: usize) -> *mut ::std::ffi::c_void;
7995 pub type PLSA_ALLOCATE_SHARED_MEMORY = unsafe extern "system" fn(sharedmem: *const ::std::ffi::c_void, size: u32) -> *mut ::std::ffi::c_void;
7996 #[cfg(feature = "Win32_Foundation")]
7997 pub type PLSA_AP_CALL_PACKAGE = unsafe extern "system" fn(clientrequest: *const *const ::std::ffi::c_void, protocolsubmitbuffer: *const ::std::ffi::c_void, clientbufferbase: *const ::std::ffi::c_void, submitbufferlength: u32, protocolreturnbuffer: *mut *mut ::std::ffi::c_void, returnbufferlength: *mut u32, protocolstatus: *mut i32) -> super::super::super::Foundation::NTSTATUS;
7998 #[cfg(feature = "Win32_Foundation")]
7999 pub type PLSA_AP_CALL_PACKAGE_PASSTHROUGH = unsafe extern "system" fn(clientrequest: *const *const ::std::ffi::c_void, protocolsubmitbuffer: *const ::std::ffi::c_void, clientbufferbase: *const ::std::ffi::c_void, submitbufferlength: u32, protocolreturnbuffer: *mut *mut ::std::ffi::c_void, returnbufferlength: *mut u32, protocolstatus: *mut i32) -> super::super::super::Foundation::NTSTATUS;
8000 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
8001 pub type PLSA_AP_INITIALIZE_PACKAGE = unsafe extern "system" fn(authenticationpackageid: u32, lsadispatchtable: *const ::std::mem::ManuallyDrop<LSA_DISPATCH_TABLE>, database: *const super::super::super::System::Kernel::STRING, confidentiality: *const super::super::super::System::Kernel::STRING, authenticationpackagename: *mut *mut super::super::super::System::Kernel::STRING) -> super::super::super::Foundation::NTSTATUS;
8002 #[cfg(feature = "Win32_Foundation")]
8003 pub type PLSA_AP_LOGON_TERMINATED = unsafe extern "system" fn(logonid: *const super::super::super::Foundation::LUID);
8004 #[cfg(feature = "Win32_Foundation")]
8005 pub type PLSA_AP_LOGON_USER = unsafe extern "system" fn(
8006     clientrequest: *const *const ::std::ffi::c_void,
8007     logontype: SECURITY_LOGON_TYPE,
8008     authenticationinformation: *const ::std::ffi::c_void,
8009     clientauthenticationbase: *const ::std::ffi::c_void,
8010     authenticationinformationlength: u32,
8011     profilebuffer: *mut *mut ::std::ffi::c_void,
8012     profilebufferlength: *mut u32,
8013     logonid: *mut super::super::super::Foundation::LUID,
8014     substatus: *mut i32,
8015     tokeninformationtype: *mut LSA_TOKEN_INFORMATION_TYPE,
8016     tokeninformation: *mut *mut ::std::ffi::c_void,
8017     accountname: *mut *mut super::super::super::Foundation::UNICODE_STRING,
8018     authenticatingauthority: *mut *mut super::super::super::Foundation::UNICODE_STRING,
8019 ) -> super::super::super::Foundation::NTSTATUS;
8020 #[cfg(feature = "Win32_Foundation")]
8021 pub type PLSA_AP_LOGON_USER_EX = unsafe extern "system" fn(
8022     clientrequest: *const *const ::std::ffi::c_void,
8023     logontype: SECURITY_LOGON_TYPE,
8024     authenticationinformation: *const ::std::ffi::c_void,
8025     clientauthenticationbase: *const ::std::ffi::c_void,
8026     authenticationinformationlength: u32,
8027     profilebuffer: *mut *mut ::std::ffi::c_void,
8028     profilebufferlength: *mut u32,
8029     logonid: *mut super::super::super::Foundation::LUID,
8030     substatus: *mut i32,
8031     tokeninformationtype: *mut LSA_TOKEN_INFORMATION_TYPE,
8032     tokeninformation: *mut *mut ::std::ffi::c_void,
8033     accountname: *mut *mut super::super::super::Foundation::UNICODE_STRING,
8034     authenticatingauthority: *mut *mut super::super::super::Foundation::UNICODE_STRING,
8035     machinename: *mut *mut super::super::super::Foundation::UNICODE_STRING,
8036 ) -> super::super::super::Foundation::NTSTATUS;
8037 #[cfg(feature = "Win32_Foundation")]
8038 pub type PLSA_AP_LOGON_USER_EX2 = unsafe extern "system" fn(
8039     clientrequest: *const *const ::std::ffi::c_void,
8040     logontype: SECURITY_LOGON_TYPE,
8041     protocolsubmitbuffer: *const ::std::ffi::c_void,
8042     clientbufferbase: *const ::std::ffi::c_void,
8043     submitbuffersize: u32,
8044     profilebuffer: *mut *mut ::std::ffi::c_void,
8045     profilebuffersize: *mut u32,
8046     logonid: *mut super::super::super::Foundation::LUID,
8047     substatus: *mut i32,
8048     tokeninformationtype: *mut LSA_TOKEN_INFORMATION_TYPE,
8049     tokeninformation: *mut *mut ::std::ffi::c_void,
8050     accountname: *mut *mut super::super::super::Foundation::UNICODE_STRING,
8051     authenticatingauthority: *mut *mut super::super::super::Foundation::UNICODE_STRING,
8052     machinename: *mut *mut super::super::super::Foundation::UNICODE_STRING,
8053     primarycredentials: *mut SECPKG_PRIMARY_CRED,
8054     supplementalcredentials: *mut *mut SECPKG_SUPPLEMENTAL_CRED_ARRAY,
8055 ) -> super::super::super::Foundation::NTSTATUS;
8056 #[cfg(feature = "Win32_Foundation")]
8057 pub type PLSA_AP_LOGON_USER_EX3 = unsafe extern "system" fn(
8058     clientrequest: *const *const ::std::ffi::c_void,
8059     logontype: SECURITY_LOGON_TYPE,
8060     protocolsubmitbuffer: *const ::std::ffi::c_void,
8061     clientbufferbase: *const ::std::ffi::c_void,
8062     submitbuffersize: u32,
8063     surrogatelogon: *mut SECPKG_SURROGATE_LOGON,
8064     profilebuffer: *mut *mut ::std::ffi::c_void,
8065     profilebuffersize: *mut u32,
8066     logonid: *mut super::super::super::Foundation::LUID,
8067     substatus: *mut i32,
8068     tokeninformationtype: *mut LSA_TOKEN_INFORMATION_TYPE,
8069     tokeninformation: *mut *mut ::std::ffi::c_void,
8070     accountname: *mut *mut super::super::super::Foundation::UNICODE_STRING,
8071     authenticatingauthority: *mut *mut super::super::super::Foundation::UNICODE_STRING,
8072     machinename: *mut *mut super::super::super::Foundation::UNICODE_STRING,
8073     primarycredentials: *mut SECPKG_PRIMARY_CRED,
8074     supplementalcredentials: *mut *mut SECPKG_SUPPLEMENTAL_CRED_ARRAY,
8075 ) -> super::super::super::Foundation::NTSTATUS;
8076 #[cfg(feature = "Win32_Foundation")]
8077 pub type PLSA_AP_POST_LOGON_USER_SURROGATE = unsafe extern "system" fn(
8078     clientrequest: *const *const ::std::ffi::c_void,
8079     logontype: SECURITY_LOGON_TYPE,
8080     protocolsubmitbuffer: *const ::std::ffi::c_void,
8081     clientbufferbase: *const ::std::ffi::c_void,
8082     submitbuffersize: u32,
8083     surrogatelogon: *const SECPKG_SURROGATE_LOGON,
8084     profilebuffer: *const ::std::ffi::c_void,
8085     profilebuffersize: u32,
8086     logonid: *const super::super::super::Foundation::LUID,
8087     status: super::super::super::Foundation::NTSTATUS,
8088     substatus: super::super::super::Foundation::NTSTATUS,
8089     tokeninformationtype: LSA_TOKEN_INFORMATION_TYPE,
8090     tokeninformation: *const ::std::ffi::c_void,
8091     accountname: *const super::super::super::Foundation::UNICODE_STRING,
8092     authenticatingauthority: *const super::super::super::Foundation::UNICODE_STRING,
8093     machinename: *const super::super::super::Foundation::UNICODE_STRING,
8094     primarycredentials: *const SECPKG_PRIMARY_CRED,
8095     supplementalcredentials: *const SECPKG_SUPPLEMENTAL_CRED_ARRAY,
8096 ) -> super::super::super::Foundation::NTSTATUS;
8097 #[cfg(feature = "Win32_Foundation")]
8098 pub type PLSA_AP_PRE_LOGON_USER_SURROGATE = unsafe extern "system" fn(clientrequest: *const *const ::std::ffi::c_void, logontype: SECURITY_LOGON_TYPE, protocolsubmitbuffer: *const ::std::ffi::c_void, clientbufferbase: *const ::std::ffi::c_void, submitbuffersize: u32, surrogatelogon: *mut SECPKG_SURROGATE_LOGON, substatus: *mut i32) -> super::super::super::Foundation::NTSTATUS;
8099 #[cfg(feature = "Win32_Foundation")]
8100 pub type PLSA_AUDIT_ACCOUNT_LOGON = unsafe extern "system" fn(auditid: u32, success: super::super::super::Foundation::BOOLEAN, source: *const super::super::super::Foundation::UNICODE_STRING, clientname: *const super::super::super::Foundation::UNICODE_STRING, mappedname: *const super::super::super::Foundation::UNICODE_STRING, status: super::super::super::Foundation::NTSTATUS) -> super::super::super::Foundation::NTSTATUS;
8101 #[cfg(feature = "Win32_Foundation")]
8102 pub type PLSA_AUDIT_LOGON = unsafe extern "system" fn(
8103     status: super::super::super::Foundation::NTSTATUS,
8104     substatus: super::super::super::Foundation::NTSTATUS,
8105     accountname: *const super::super::super::Foundation::UNICODE_STRING,
8106     authenticatingauthority: *const super::super::super::Foundation::UNICODE_STRING,
8107     workstationname: *const super::super::super::Foundation::UNICODE_STRING,
8108     usersid: super::super::super::Foundation::PSID,
8109     logontype: SECURITY_LOGON_TYPE,
8110     tokensource: *const super::super::TOKEN_SOURCE,
8111     logonid: *const super::super::super::Foundation::LUID,
8112 );
8113 #[cfg(feature = "Win32_Foundation")]
8114 pub type PLSA_AUDIT_LOGON_EX = unsafe extern "system" fn(
8115     status: super::super::super::Foundation::NTSTATUS,
8116     substatus: super::super::super::Foundation::NTSTATUS,
8117     accountname: *const super::super::super::Foundation::UNICODE_STRING,
8118     authenticatingauthority: *const super::super::super::Foundation::UNICODE_STRING,
8119     workstationname: *const super::super::super::Foundation::UNICODE_STRING,
8120     usersid: super::super::super::Foundation::PSID,
8121     logontype: SECURITY_LOGON_TYPE,
8122     impersonationlevel: super::super::SECURITY_IMPERSONATION_LEVEL,
8123     tokensource: *const super::super::TOKEN_SOURCE,
8124     logonid: *const super::super::super::Foundation::LUID,
8125 );
8126 #[cfg(feature = "Win32_Foundation")]
8127 pub type PLSA_CALLBACK_FUNCTION = unsafe extern "system" fn(argument1: usize, argument2: usize, inputbuffer: *mut SecBuffer, outputbuffer: *mut SecBuffer) -> super::super::super::Foundation::NTSTATUS;
8128 #[cfg(feature = "Win32_Foundation")]
8129 pub type PLSA_CALL_PACKAGE = unsafe extern "system" fn(authenticationpackage: *const super::super::super::Foundation::UNICODE_STRING, protocolsubmitbuffer: *const ::std::ffi::c_void, submitbufferlength: u32, protocolreturnbuffer: *mut *mut ::std::ffi::c_void, returnbufferlength: *mut u32, protocolstatus: *mut i32) -> super::super::super::Foundation::NTSTATUS;
8130 #[cfg(feature = "Win32_Foundation")]
8131 pub type PLSA_CALL_PACKAGEEX = unsafe extern "system" fn(authenticationpackage: *const super::super::super::Foundation::UNICODE_STRING, clientbufferbase: *const ::std::ffi::c_void, protocolsubmitbuffer: *const ::std::ffi::c_void, submitbufferlength: u32, protocolreturnbuffer: *mut *mut ::std::ffi::c_void, returnbufferlength: *mut u32, protocolstatus: *mut i32) -> super::super::super::Foundation::NTSTATUS;
8132 #[cfg(feature = "Win32_Foundation")]
8133 pub type PLSA_CALL_PACKAGE_PASSTHROUGH = unsafe extern "system" fn(authenticationpackage: *const super::super::super::Foundation::UNICODE_STRING, clientbufferbase: *const ::std::ffi::c_void, protocolsubmitbuffer: *const ::std::ffi::c_void, submitbufferlength: u32, protocolreturnbuffer: *mut *mut ::std::ffi::c_void, returnbufferlength: *mut u32, protocolstatus: *mut i32) -> super::super::super::Foundation::NTSTATUS;
8134 #[cfg(feature = "Win32_Foundation")]
8135 pub type PLSA_CANCEL_NOTIFICATION = unsafe extern "system" fn(notifyhandle: super::super::super::Foundation::HANDLE) -> super::super::super::Foundation::NTSTATUS;
8136 #[cfg(feature = "Win32_Foundation")]
8137 pub type PLSA_CHECK_PROTECTED_USER_BY_TOKEN = unsafe extern "system" fn(usertoken: super::super::super::Foundation::HANDLE, protecteduser: *mut super::super::super::Foundation::BOOLEAN) -> super::super::super::Foundation::NTSTATUS;
8138 #[cfg(feature = "Win32_Foundation")]
8139 pub type PLSA_CLIENT_CALLBACK = unsafe extern "system" fn(callback: super::super::super::Foundation::PSTR, argument1: usize, argument2: usize, input: *const SecBuffer, output: *mut SecBuffer) -> super::super::super::Foundation::NTSTATUS;
8140 #[cfg(feature = "Win32_Foundation")]
8141 pub type PLSA_CLOSE_SAM_USER = unsafe extern "system" fn(userhandle: *const ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
8142 #[cfg(feature = "Win32_Foundation")]
8143 pub type PLSA_CONVERT_AUTH_DATA_TO_TOKEN = unsafe extern "system" fn(
8144     userauthdata: *const ::std::ffi::c_void,
8145     userauthdatasize: u32,
8146     impersonationlevel: super::super::SECURITY_IMPERSONATION_LEVEL,
8147     tokensource: *const super::super::TOKEN_SOURCE,
8148     logontype: SECURITY_LOGON_TYPE,
8149     authorityname: *const super::super::super::Foundation::UNICODE_STRING,
8150     token: *mut super::super::super::Foundation::HANDLE,
8151     logonid: *mut super::super::super::Foundation::LUID,
8152     accountname: *mut super::super::super::Foundation::UNICODE_STRING,
8153     substatus: *mut i32,
8154 ) -> super::super::super::Foundation::NTSTATUS;
8155 #[cfg(feature = "Win32_Foundation")]
8156 pub type PLSA_COPY_FROM_CLIENT_BUFFER = unsafe extern "system" fn(clientrequest: *const *const ::std::ffi::c_void, length: u32, buffertocopy: *mut ::std::ffi::c_void, clientbaseaddress: *const ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
8157 #[cfg(feature = "Win32_Foundation")]
8158 pub type PLSA_COPY_TO_CLIENT_BUFFER = unsafe extern "system" fn(clientrequest: *const *const ::std::ffi::c_void, length: u32, clientbaseaddress: *mut ::std::ffi::c_void, buffertocopy: *const ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
8159 #[cfg(feature = "Win32_Foundation")]
8160 pub type PLSA_CRACK_SINGLE_NAME = unsafe extern "system" fn(formatoffered: u32, performatgc: super::super::super::Foundation::BOOLEAN, nameinput: *const super::super::super::Foundation::UNICODE_STRING, prefix: *const super::super::super::Foundation::UNICODE_STRING, requestedformat: u32, crackedname: *mut super::super::super::Foundation::UNICODE_STRING, dnsdomainname: *mut super::super::super::Foundation::UNICODE_STRING, substatus: *mut u32) -> super::super::super::Foundation::NTSTATUS;
8161 #[cfg(feature = "Win32_Foundation")]
8162 pub type PLSA_CREATE_LOGON_SESSION = unsafe extern "system" fn(logonid: *mut super::super::super::Foundation::LUID) -> super::super::super::Foundation::NTSTATUS;
8163 pub type PLSA_CREATE_SHARED_MEMORY = unsafe extern "system" fn(maxsize: u32, initialsize: u32) -> *mut ::std::ffi::c_void;
8164 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_SystemServices"))]
8165 pub type PLSA_CREATE_THREAD = unsafe extern "system" fn(securityattributes: *const super::super::SECURITY_ATTRIBUTES, stacksize: u32, startfunction: ::windows::runtime::RawPtr, threadparameter: *const ::std::ffi::c_void, creationflags: u32, threadid: *mut u32) -> super::super::super::Foundation::HANDLE;
8166 #[cfg(feature = "Win32_Foundation")]
8167 pub type PLSA_CREATE_TOKEN = unsafe extern "system" fn(
8168     logonid: *const super::super::super::Foundation::LUID,
8169     tokensource: *const super::super::TOKEN_SOURCE,
8170     logontype: SECURITY_LOGON_TYPE,
8171     impersonationlevel: super::super::SECURITY_IMPERSONATION_LEVEL,
8172     tokeninformationtype: LSA_TOKEN_INFORMATION_TYPE,
8173     tokeninformation: *const ::std::ffi::c_void,
8174     tokengroups: *const super::super::TOKEN_GROUPS,
8175     accountname: *const super::super::super::Foundation::UNICODE_STRING,
8176     authorityname: *const super::super::super::Foundation::UNICODE_STRING,
8177     workstation: *const super::super::super::Foundation::UNICODE_STRING,
8178     profilepath: *const super::super::super::Foundation::UNICODE_STRING,
8179     token: *mut super::super::super::Foundation::HANDLE,
8180     substatus: *mut i32,
8181 ) -> super::super::super::Foundation::NTSTATUS;
8182 #[cfg(feature = "Win32_Foundation")]
8183 pub type PLSA_CREATE_TOKEN_EX = unsafe extern "system" fn(
8184     logonid: *const super::super::super::Foundation::LUID,
8185     tokensource: *const super::super::TOKEN_SOURCE,
8186     logontype: SECURITY_LOGON_TYPE,
8187     impersonationlevel: super::super::SECURITY_IMPERSONATION_LEVEL,
8188     tokeninformationtype: LSA_TOKEN_INFORMATION_TYPE,
8189     tokeninformation: *const ::std::ffi::c_void,
8190     tokengroups: *const super::super::TOKEN_GROUPS,
8191     workstation: *const super::super::super::Foundation::UNICODE_STRING,
8192     profilepath: *const super::super::super::Foundation::UNICODE_STRING,
8193     sessioninformation: *const ::std::ffi::c_void,
8194     sessioninformationtype: SECPKG_SESSIONINFO_TYPE,
8195     token: *mut super::super::super::Foundation::HANDLE,
8196     substatus: *mut i32,
8197 ) -> super::super::super::Foundation::NTSTATUS;
8198 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
8199 pub type PLSA_DELETE_CREDENTIAL = unsafe extern "system" fn(logonid: *const super::super::super::Foundation::LUID, authenticationpackage: u32, primarykeyvalue: *const super::super::super::System::Kernel::STRING) -> super::super::super::Foundation::NTSTATUS;
8200 #[cfg(feature = "Win32_Foundation")]
8201 pub type PLSA_DELETE_LOGON_SESSION = unsafe extern "system" fn(logonid: *const super::super::super::Foundation::LUID) -> super::super::super::Foundation::NTSTATUS;
8202 #[cfg(feature = "Win32_Foundation")]
8203 pub type PLSA_DELETE_SHARED_MEMORY = unsafe extern "system" fn(sharedmem: *const ::std::ffi::c_void) -> super::super::super::Foundation::BOOLEAN;
8204 #[cfg(feature = "Win32_Foundation")]
8205 pub type PLSA_DUPLICATE_HANDLE = unsafe extern "system" fn(sourcehandle: super::super::super::Foundation::HANDLE, destionationhandle: *mut super::super::super::Foundation::HANDLE) -> super::super::super::Foundation::NTSTATUS;
8206 #[cfg(feature = "Win32_Foundation")]
8207 pub type PLSA_EXPAND_AUTH_DATA_FOR_DOMAIN = unsafe extern "system" fn(userauthdata: *const u8, userauthdatasize: u32, reserved: *const ::std::ffi::c_void, expandedauthdata: *mut *mut u8, expandedauthdatasize: *mut u32) -> super::super::super::Foundation::NTSTATUS;
8208 #[cfg(feature = "Win32_Foundation")]
8209 pub type PLSA_FREE_CLIENT_BUFFER = unsafe extern "system" fn(clientrequest: *const *const ::std::ffi::c_void, clientbaseaddress: *const ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
8210 pub type PLSA_FREE_LSA_HEAP = unsafe extern "system" fn(base: *const ::std::ffi::c_void);
8211 pub type PLSA_FREE_PRIVATE_HEAP = unsafe extern "system" fn(base: *const ::std::ffi::c_void);
8212 pub type PLSA_FREE_SHARED_MEMORY = unsafe extern "system" fn(sharedmem: *const ::std::ffi::c_void, memory: *mut ::std::ffi::c_void);
8213 #[cfg(feature = "Win32_Foundation")]
8214 pub type PLSA_GET_APP_MODE_INFO = unsafe extern "system" fn(userfunction: *mut u32, argument1: *mut usize, argument2: *mut usize, userdata: *mut SecBuffer, returntolsa: *mut super::super::super::Foundation::BOOLEAN) -> super::super::super::Foundation::NTSTATUS;
8215 #[cfg(feature = "Win32_Foundation")]
8216 pub type PLSA_GET_AUTH_DATA_FOR_USER = unsafe extern "system" fn(name: *const super::super::super::Foundation::UNICODE_STRING, nametype: SECPKG_NAME_TYPE, prefix: *const super::super::super::Foundation::UNICODE_STRING, userauthdata: *mut *mut u8, userauthdatasize: *mut u32, userflatname: *mut super::super::super::Foundation::UNICODE_STRING) -> super::super::super::Foundation::NTSTATUS;
8217 #[cfg(feature = "Win32_Foundation")]
8218 pub type PLSA_GET_CALL_INFO = unsafe extern "system" fn(info: *mut SECPKG_CALL_INFO) -> super::super::super::Foundation::BOOLEAN;
8219 #[cfg(feature = "Win32_Foundation")]
8220 pub type PLSA_GET_CLIENT_INFO = unsafe extern "system" fn(clientinfo: *mut SECPKG_CLIENT_INFO) -> super::super::super::Foundation::NTSTATUS;
8221 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
8222 pub type PLSA_GET_CREDENTIALS = unsafe extern "system" fn(logonid: *const super::super::super::Foundation::LUID, authenticationpackage: u32, querycontext: *mut u32, retrieveallcredentials: super::super::super::Foundation::BOOLEAN, primarykeyvalue: *const super::super::super::System::Kernel::STRING, primarykeylength: *mut u32, credentials: *const super::super::super::System::Kernel::STRING) -> super::super::super::Foundation::NTSTATUS;
8223 #[cfg(feature = "Win32_Foundation")]
8224 pub type PLSA_GET_EXTENDED_CALL_FLAGS = unsafe extern "system" fn(flags: *mut u32) -> super::super::super::Foundation::NTSTATUS;
8225 #[cfg(feature = "Win32_Foundation")]
8226 pub type PLSA_GET_SERVICE_ACCOUNT_PASSWORD = unsafe extern "system" fn(
8227     accountname: *const super::super::super::Foundation::UNICODE_STRING,
8228     domainname: *const super::super::super::Foundation::UNICODE_STRING,
8229     credfetch: CRED_FETCH,
8230     filetimeexpiry: *mut super::super::super::Foundation::FILETIME,
8231     currentpassword: *mut super::super::super::Foundation::UNICODE_STRING,
8232     previouspassword: *mut super::super::super::Foundation::UNICODE_STRING,
8233     filetimecurrpwdvalidforoutbound: *mut super::super::super::Foundation::FILETIME,
8234 ) -> super::super::super::Foundation::NTSTATUS;
8235 #[cfg(feature = "Win32_Foundation")]
8236 pub type PLSA_GET_USER_AUTH_DATA = unsafe extern "system" fn(userhandle: *const ::std::ffi::c_void, userauthdata: *mut *mut u8, userauthdatasize: *mut u32) -> super::super::super::Foundation::NTSTATUS;
8237 #[cfg(feature = "Win32_Foundation")]
8238 pub type PLSA_GET_USER_CREDENTIALS = unsafe extern "system" fn(userhandle: *const ::std::ffi::c_void, primarycreds: *mut *mut ::std::ffi::c_void, primarycredssize: *mut u32, supplementalcreds: *mut *mut ::std::ffi::c_void, supplementalcredssize: *mut u32) -> super::super::super::Foundation::NTSTATUS;
8239 #[cfg(feature = "Win32_Foundation")]
8240 pub type PLSA_IMPERSONATE_CLIENT = unsafe extern "system" fn() -> super::super::super::Foundation::NTSTATUS;
8241 pub type PLSA_LOCATE_PKG_BY_ID = unsafe extern "system" fn(packgeid: u32) -> *mut ::std::ffi::c_void;
8242 #[cfg(feature = "Win32_Foundation")]
8243 pub type PLSA_MAP_BUFFER = unsafe extern "system" fn(inputbuffer: *const SecBuffer, outputbuffer: *mut SecBuffer) -> super::super::super::Foundation::NTSTATUS;
8244 #[cfg(feature = "Win32_Foundation")]
8245 pub type PLSA_OPEN_SAM_USER = unsafe extern "system" fn(name: *const super::super::super::Foundation::UNICODE_STRING, nametype: SECPKG_NAME_TYPE, prefix: *const super::super::super::Foundation::UNICODE_STRING, allowguest: super::super::super::Foundation::BOOLEAN, reserved: u32, userhandle: *mut *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
8246 #[cfg(feature = "Win32_Foundation")]
8247 pub type PLSA_OPEN_TOKEN_BY_LOGON_ID = unsafe extern "system" fn(logonid: *const super::super::super::Foundation::LUID, rettokenhandle: *mut super::super::super::Foundation::HANDLE) -> super::super::super::Foundation::NTSTATUS;
8248 pub type PLSA_PROTECT_MEMORY = unsafe extern "system" fn(buffer: *mut ::std::ffi::c_void, buffersize: u32);
8249 #[cfg(feature = "Win32_Foundation")]
8250 pub type PLSA_QUERY_CLIENT_REQUEST = unsafe extern "system" fn(clientrequest: *const *const ::std::ffi::c_void, querytype: u32, replybuffer: *mut *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
8251 #[cfg(feature = "Win32_Foundation")]
8252 pub type PLSA_REDIRECTED_LOGON_CALLBACK = unsafe extern "system" fn(redirectedlogonhandle: super::super::super::Foundation::HANDLE, buffer: *mut ::std::ffi::c_void, bufferlength: u32, returnbuffer: *mut *mut ::std::ffi::c_void, returnbufferlength: *mut u32) -> super::super::super::Foundation::NTSTATUS;
8253 #[cfg(feature = "Win32_Foundation")]
8254 pub type PLSA_REDIRECTED_LOGON_CLEANUP_CALLBACK = unsafe extern "system" fn(redirectedlogonhandle: super::super::super::Foundation::HANDLE);
8255 #[cfg(feature = "Win32_Foundation")]
8256 pub type PLSA_REDIRECTED_LOGON_GET_LOGON_CREDS = unsafe extern "system" fn(redirectedlogonhandle: super::super::super::Foundation::HANDLE, logonbuffer: *mut *mut u8, logonbufferlength: *mut u32) -> super::super::super::Foundation::NTSTATUS;
8257 #[cfg(feature = "Win32_Foundation")]
8258 pub type PLSA_REDIRECTED_LOGON_GET_SUPP_CREDS = unsafe extern "system" fn(redirectedlogonhandle: super::super::super::Foundation::HANDLE, supplementalcredentials: *mut *mut SECPKG_SUPPLEMENTAL_CRED_ARRAY) -> super::super::super::Foundation::NTSTATUS;
8259 #[cfg(feature = "Win32_Foundation")]
8260 pub type PLSA_REDIRECTED_LOGON_INIT = unsafe extern "system" fn(redirectedlogonhandle: super::super::super::Foundation::HANDLE, packagename: *const super::super::super::Foundation::UNICODE_STRING, sessionid: u32, logonid: *const super::super::super::Foundation::LUID) -> super::super::super::Foundation::NTSTATUS;
8261 #[cfg(feature = "Win32_Foundation")]
8262 pub type PLSA_REGISTER_CALLBACK = unsafe extern "system" fn(callbackid: u32, callback: ::windows::runtime::RawPtr) -> super::super::super::Foundation::NTSTATUS;
8263 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_SystemServices"))]
8264 pub type PLSA_REGISTER_NOTIFICATION = unsafe extern "system" fn(startfunction: ::windows::runtime::RawPtr, parameter: *const ::std::ffi::c_void, notificationtype: u32, notificationclass: u32, notificationflags: u32, intervalminutes: u32, waitevent: super::super::super::Foundation::HANDLE) -> super::super::super::Foundation::HANDLE;
8265 #[cfg(feature = "Win32_Foundation")]
8266 pub type PLSA_SAVE_SUPPLEMENTAL_CREDENTIALS = unsafe extern "system" fn(logonid: *const super::super::super::Foundation::LUID, supplementalcredsize: u32, supplementalcreds: *const ::std::ffi::c_void, synchronous: super::super::super::Foundation::BOOLEAN) -> super::super::super::Foundation::NTSTATUS;
8267 #[cfg(feature = "Win32_Foundation")]
8268 pub type PLSA_SET_APP_MODE_INFO = unsafe extern "system" fn(userfunction: u32, argument1: usize, argument2: usize, userdata: *const SecBuffer, returntolsa: super::super::super::Foundation::BOOLEAN) -> super::super::super::Foundation::NTSTATUS;
8269 #[cfg(feature = "Win32_Foundation")]
8270 pub type PLSA_UNLOAD_PACKAGE = unsafe extern "system" fn() -> super::super::super::Foundation::NTSTATUS;
8271 #[cfg(feature = "Win32_Foundation")]
8272 pub type PLSA_UPDATE_PRIMARY_CREDENTIALS = unsafe extern "system" fn(primarycredentials: *const SECPKG_PRIMARY_CRED, credentials: *const SECPKG_SUPPLEMENTAL_CRED_ARRAY) -> super::super::super::Foundation::NTSTATUS;
8273 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8274 #[repr(C)]
8275 #[cfg(feature = "Win32_Foundation")]
8276 pub struct POLICY_ACCOUNT_DOMAIN_INFO {
8277     pub DomainName: super::super::super::Foundation::UNICODE_STRING,
8278     pub DomainSid: super::super::super::Foundation::PSID,
8279 }
8280 #[cfg(feature = "Win32_Foundation")]
8281 impl POLICY_ACCOUNT_DOMAIN_INFO {}
8282 #[cfg(feature = "Win32_Foundation")]
8283 impl ::std::default::Default for POLICY_ACCOUNT_DOMAIN_INFO {
8284     fn default() -> Self {
8285         unsafe { ::std::mem::zeroed() }
8286     }
8287 }
8288 #[cfg(feature = "Win32_Foundation")]
8289 impl ::std::fmt::Debug for POLICY_ACCOUNT_DOMAIN_INFO {
8290     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8291         fmt.debug_struct("POLICY_ACCOUNT_DOMAIN_INFO").field("DomainName", &self.DomainName).field("DomainSid", &self.DomainSid).finish()
8292     }
8293 }
8294 #[cfg(feature = "Win32_Foundation")]
8295 impl ::std::cmp::PartialEq for POLICY_ACCOUNT_DOMAIN_INFO {
8296     fn eq(&self, other: &Self) -> bool {
8297         self.DomainName == other.DomainName && self.DomainSid == other.DomainSid
8298     }
8299 }
8300 #[cfg(feature = "Win32_Foundation")]
8301 impl ::std::cmp::Eq for POLICY_ACCOUNT_DOMAIN_INFO {}
8302 #[cfg(feature = "Win32_Foundation")]
8303 unsafe impl ::windows::runtime::Abi for POLICY_ACCOUNT_DOMAIN_INFO {
8304     type Abi = Self;
8305     type DefaultType = Self;
8306 }
8307 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8308 #[repr(C)]
8309 pub struct POLICY_AUDIT_CATEGORIES_INFO {
8310     pub MaximumCategoryCount: u32,
8311     pub SubCategoriesInfo: *mut POLICY_AUDIT_SUBCATEGORIES_INFO,
8312 }
8313 impl POLICY_AUDIT_CATEGORIES_INFO {}
8314 impl ::std::default::Default for POLICY_AUDIT_CATEGORIES_INFO {
8315     fn default() -> Self {
8316         unsafe { ::std::mem::zeroed() }
8317     }
8318 }
8319 impl ::std::fmt::Debug for POLICY_AUDIT_CATEGORIES_INFO {
8320     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8321         fmt.debug_struct("POLICY_AUDIT_CATEGORIES_INFO").field("MaximumCategoryCount", &self.MaximumCategoryCount).field("SubCategoriesInfo", &self.SubCategoriesInfo).finish()
8322     }
8323 }
8324 impl ::std::cmp::PartialEq for POLICY_AUDIT_CATEGORIES_INFO {
8325     fn eq(&self, other: &Self) -> bool {
8326         self.MaximumCategoryCount == other.MaximumCategoryCount && self.SubCategoriesInfo == other.SubCategoriesInfo
8327     }
8328 }
8329 impl ::std::cmp::Eq for POLICY_AUDIT_CATEGORIES_INFO {}
8330 unsafe impl ::windows::runtime::Abi for POLICY_AUDIT_CATEGORIES_INFO {
8331     type Abi = Self;
8332     type DefaultType = Self;
8333 }
8334 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8335 #[repr(C)]
8336 #[cfg(feature = "Win32_Foundation")]
8337 pub struct POLICY_AUDIT_EVENTS_INFO {
8338     pub AuditingMode: super::super::super::Foundation::BOOLEAN,
8339     pub EventAuditingOptions: *mut u32,
8340     pub MaximumAuditEventCount: u32,
8341 }
8342 #[cfg(feature = "Win32_Foundation")]
8343 impl POLICY_AUDIT_EVENTS_INFO {}
8344 #[cfg(feature = "Win32_Foundation")]
8345 impl ::std::default::Default for POLICY_AUDIT_EVENTS_INFO {
8346     fn default() -> Self {
8347         unsafe { ::std::mem::zeroed() }
8348     }
8349 }
8350 #[cfg(feature = "Win32_Foundation")]
8351 impl ::std::fmt::Debug for POLICY_AUDIT_EVENTS_INFO {
8352     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8353         fmt.debug_struct("POLICY_AUDIT_EVENTS_INFO").field("AuditingMode", &self.AuditingMode).field("EventAuditingOptions", &self.EventAuditingOptions).field("MaximumAuditEventCount", &self.MaximumAuditEventCount).finish()
8354     }
8355 }
8356 #[cfg(feature = "Win32_Foundation")]
8357 impl ::std::cmp::PartialEq for POLICY_AUDIT_EVENTS_INFO {
8358     fn eq(&self, other: &Self) -> bool {
8359         self.AuditingMode == other.AuditingMode && self.EventAuditingOptions == other.EventAuditingOptions && self.MaximumAuditEventCount == other.MaximumAuditEventCount
8360     }
8361 }
8362 #[cfg(feature = "Win32_Foundation")]
8363 impl ::std::cmp::Eq for POLICY_AUDIT_EVENTS_INFO {}
8364 #[cfg(feature = "Win32_Foundation")]
8365 unsafe impl ::windows::runtime::Abi for POLICY_AUDIT_EVENTS_INFO {
8366     type Abi = Self;
8367     type DefaultType = Self;
8368 }
8369 pub const POLICY_AUDIT_EVENT_FAILURE: i32 = 2i32;
8370 pub const POLICY_AUDIT_EVENT_NONE: i32 = 4i32;
8371 pub const POLICY_AUDIT_EVENT_SUCCESS: i32 = 1i32;
8372 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8373 #[repr(transparent)]
8374 pub struct POLICY_AUDIT_EVENT_TYPE(pub i32);
8375 pub const AuditCategorySystem: POLICY_AUDIT_EVENT_TYPE = POLICY_AUDIT_EVENT_TYPE(0i32);
8376 pub const AuditCategoryLogon: POLICY_AUDIT_EVENT_TYPE = POLICY_AUDIT_EVENT_TYPE(1i32);
8377 pub const AuditCategoryObjectAccess: POLICY_AUDIT_EVENT_TYPE = POLICY_AUDIT_EVENT_TYPE(2i32);
8378 pub const AuditCategoryPrivilegeUse: POLICY_AUDIT_EVENT_TYPE = POLICY_AUDIT_EVENT_TYPE(3i32);
8379 pub const AuditCategoryDetailedTracking: POLICY_AUDIT_EVENT_TYPE = POLICY_AUDIT_EVENT_TYPE(4i32);
8380 pub const AuditCategoryPolicyChange: POLICY_AUDIT_EVENT_TYPE = POLICY_AUDIT_EVENT_TYPE(5i32);
8381 pub const AuditCategoryAccountManagement: POLICY_AUDIT_EVENT_TYPE = POLICY_AUDIT_EVENT_TYPE(6i32);
8382 pub const AuditCategoryDirectoryServiceAccess: POLICY_AUDIT_EVENT_TYPE = POLICY_AUDIT_EVENT_TYPE(7i32);
8383 pub const AuditCategoryAccountLogon: POLICY_AUDIT_EVENT_TYPE = POLICY_AUDIT_EVENT_TYPE(8i32);
8384 impl ::std::convert::From<i32> for POLICY_AUDIT_EVENT_TYPE {
8385     fn from(value: i32) -> Self {
8386         Self(value)
8387     }
8388 }
8389 unsafe impl ::windows::runtime::Abi for POLICY_AUDIT_EVENT_TYPE {
8390     type Abi = Self;
8391     type DefaultType = Self;
8392 }
8393 pub const POLICY_AUDIT_EVENT_UNCHANGED: i32 = 0i32;
8394 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8395 #[repr(C)]
8396 #[cfg(feature = "Win32_Foundation")]
8397 pub struct POLICY_AUDIT_FULL_QUERY_INFO {
8398     pub ShutDownOnFull: super::super::super::Foundation::BOOLEAN,
8399     pub LogIsFull: super::super::super::Foundation::BOOLEAN,
8400 }
8401 #[cfg(feature = "Win32_Foundation")]
8402 impl POLICY_AUDIT_FULL_QUERY_INFO {}
8403 #[cfg(feature = "Win32_Foundation")]
8404 impl ::std::default::Default for POLICY_AUDIT_FULL_QUERY_INFO {
8405     fn default() -> Self {
8406         unsafe { ::std::mem::zeroed() }
8407     }
8408 }
8409 #[cfg(feature = "Win32_Foundation")]
8410 impl ::std::fmt::Debug for POLICY_AUDIT_FULL_QUERY_INFO {
8411     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8412         fmt.debug_struct("POLICY_AUDIT_FULL_QUERY_INFO").field("ShutDownOnFull", &self.ShutDownOnFull).field("LogIsFull", &self.LogIsFull).finish()
8413     }
8414 }
8415 #[cfg(feature = "Win32_Foundation")]
8416 impl ::std::cmp::PartialEq for POLICY_AUDIT_FULL_QUERY_INFO {
8417     fn eq(&self, other: &Self) -> bool {
8418         self.ShutDownOnFull == other.ShutDownOnFull && self.LogIsFull == other.LogIsFull
8419     }
8420 }
8421 #[cfg(feature = "Win32_Foundation")]
8422 impl ::std::cmp::Eq for POLICY_AUDIT_FULL_QUERY_INFO {}
8423 #[cfg(feature = "Win32_Foundation")]
8424 unsafe impl ::windows::runtime::Abi for POLICY_AUDIT_FULL_QUERY_INFO {
8425     type Abi = Self;
8426     type DefaultType = Self;
8427 }
8428 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8429 #[repr(C)]
8430 #[cfg(feature = "Win32_Foundation")]
8431 pub struct POLICY_AUDIT_FULL_SET_INFO {
8432     pub ShutDownOnFull: super::super::super::Foundation::BOOLEAN,
8433 }
8434 #[cfg(feature = "Win32_Foundation")]
8435 impl POLICY_AUDIT_FULL_SET_INFO {}
8436 #[cfg(feature = "Win32_Foundation")]
8437 impl ::std::default::Default for POLICY_AUDIT_FULL_SET_INFO {
8438     fn default() -> Self {
8439         unsafe { ::std::mem::zeroed() }
8440     }
8441 }
8442 #[cfg(feature = "Win32_Foundation")]
8443 impl ::std::fmt::Debug for POLICY_AUDIT_FULL_SET_INFO {
8444     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8445         fmt.debug_struct("POLICY_AUDIT_FULL_SET_INFO").field("ShutDownOnFull", &self.ShutDownOnFull).finish()
8446     }
8447 }
8448 #[cfg(feature = "Win32_Foundation")]
8449 impl ::std::cmp::PartialEq for POLICY_AUDIT_FULL_SET_INFO {
8450     fn eq(&self, other: &Self) -> bool {
8451         self.ShutDownOnFull == other.ShutDownOnFull
8452     }
8453 }
8454 #[cfg(feature = "Win32_Foundation")]
8455 impl ::std::cmp::Eq for POLICY_AUDIT_FULL_SET_INFO {}
8456 #[cfg(feature = "Win32_Foundation")]
8457 unsafe impl ::windows::runtime::Abi for POLICY_AUDIT_FULL_SET_INFO {
8458     type Abi = Self;
8459     type DefaultType = Self;
8460 }
8461 pub const POLICY_AUDIT_LOG_ADMIN: i32 = 512i32;
8462 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8463 #[repr(C)]
8464 #[cfg(feature = "Win32_Foundation")]
8465 pub struct POLICY_AUDIT_LOG_INFO {
8466     pub AuditLogPercentFull: u32,
8467     pub MaximumLogSize: u32,
8468     pub AuditRetentionPeriod: i64,
8469     pub AuditLogFullShutdownInProgress: super::super::super::Foundation::BOOLEAN,
8470     pub TimeToShutdown: i64,
8471     pub NextAuditRecordId: u32,
8472 }
8473 #[cfg(feature = "Win32_Foundation")]
8474 impl POLICY_AUDIT_LOG_INFO {}
8475 #[cfg(feature = "Win32_Foundation")]
8476 impl ::std::default::Default for POLICY_AUDIT_LOG_INFO {
8477     fn default() -> Self {
8478         unsafe { ::std::mem::zeroed() }
8479     }
8480 }
8481 #[cfg(feature = "Win32_Foundation")]
8482 impl ::std::fmt::Debug for POLICY_AUDIT_LOG_INFO {
8483     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8484         fmt.debug_struct("POLICY_AUDIT_LOG_INFO")
8485             .field("AuditLogPercentFull", &self.AuditLogPercentFull)
8486             .field("MaximumLogSize", &self.MaximumLogSize)
8487             .field("AuditRetentionPeriod", &self.AuditRetentionPeriod)
8488             .field("AuditLogFullShutdownInProgress", &self.AuditLogFullShutdownInProgress)
8489             .field("TimeToShutdown", &self.TimeToShutdown)
8490             .field("NextAuditRecordId", &self.NextAuditRecordId)
8491             .finish()
8492     }
8493 }
8494 #[cfg(feature = "Win32_Foundation")]
8495 impl ::std::cmp::PartialEq for POLICY_AUDIT_LOG_INFO {
8496     fn eq(&self, other: &Self) -> bool {
8497         self.AuditLogPercentFull == other.AuditLogPercentFull && self.MaximumLogSize == other.MaximumLogSize && self.AuditRetentionPeriod == other.AuditRetentionPeriod && self.AuditLogFullShutdownInProgress == other.AuditLogFullShutdownInProgress && self.TimeToShutdown == other.TimeToShutdown && self.NextAuditRecordId == other.NextAuditRecordId
8498     }
8499 }
8500 #[cfg(feature = "Win32_Foundation")]
8501 impl ::std::cmp::Eq for POLICY_AUDIT_LOG_INFO {}
8502 #[cfg(feature = "Win32_Foundation")]
8503 unsafe impl ::windows::runtime::Abi for POLICY_AUDIT_LOG_INFO {
8504     type Abi = Self;
8505     type DefaultType = Self;
8506 }
8507 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8508 #[repr(C)]
8509 #[cfg(feature = "Win32_Foundation")]
8510 pub struct POLICY_AUDIT_SID_ARRAY {
8511     pub UsersCount: u32,
8512     pub UserSidArray: *mut super::super::super::Foundation::PSID,
8513 }
8514 #[cfg(feature = "Win32_Foundation")]
8515 impl POLICY_AUDIT_SID_ARRAY {}
8516 #[cfg(feature = "Win32_Foundation")]
8517 impl ::std::default::Default for POLICY_AUDIT_SID_ARRAY {
8518     fn default() -> Self {
8519         unsafe { ::std::mem::zeroed() }
8520     }
8521 }
8522 #[cfg(feature = "Win32_Foundation")]
8523 impl ::std::fmt::Debug for POLICY_AUDIT_SID_ARRAY {
8524     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8525         fmt.debug_struct("POLICY_AUDIT_SID_ARRAY").field("UsersCount", &self.UsersCount).field("UserSidArray", &self.UserSidArray).finish()
8526     }
8527 }
8528 #[cfg(feature = "Win32_Foundation")]
8529 impl ::std::cmp::PartialEq for POLICY_AUDIT_SID_ARRAY {
8530     fn eq(&self, other: &Self) -> bool {
8531         self.UsersCount == other.UsersCount && self.UserSidArray == other.UserSidArray
8532     }
8533 }
8534 #[cfg(feature = "Win32_Foundation")]
8535 impl ::std::cmp::Eq for POLICY_AUDIT_SID_ARRAY {}
8536 #[cfg(feature = "Win32_Foundation")]
8537 unsafe impl ::windows::runtime::Abi for POLICY_AUDIT_SID_ARRAY {
8538     type Abi = Self;
8539     type DefaultType = Self;
8540 }
8541 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8542 #[repr(C)]
8543 pub struct POLICY_AUDIT_SUBCATEGORIES_INFO {
8544     pub MaximumSubCategoryCount: u32,
8545     pub EventAuditingOptions: *mut u32,
8546 }
8547 impl POLICY_AUDIT_SUBCATEGORIES_INFO {}
8548 impl ::std::default::Default for POLICY_AUDIT_SUBCATEGORIES_INFO {
8549     fn default() -> Self {
8550         unsafe { ::std::mem::zeroed() }
8551     }
8552 }
8553 impl ::std::fmt::Debug for POLICY_AUDIT_SUBCATEGORIES_INFO {
8554     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8555         fmt.debug_struct("POLICY_AUDIT_SUBCATEGORIES_INFO").field("MaximumSubCategoryCount", &self.MaximumSubCategoryCount).field("EventAuditingOptions", &self.EventAuditingOptions).finish()
8556     }
8557 }
8558 impl ::std::cmp::PartialEq for POLICY_AUDIT_SUBCATEGORIES_INFO {
8559     fn eq(&self, other: &Self) -> bool {
8560         self.MaximumSubCategoryCount == other.MaximumSubCategoryCount && self.EventAuditingOptions == other.EventAuditingOptions
8561     }
8562 }
8563 impl ::std::cmp::Eq for POLICY_AUDIT_SUBCATEGORIES_INFO {}
8564 unsafe impl ::windows::runtime::Abi for POLICY_AUDIT_SUBCATEGORIES_INFO {
8565     type Abi = Self;
8566     type DefaultType = Self;
8567 }
8568 pub const POLICY_CREATE_ACCOUNT: i32 = 16i32;
8569 pub const POLICY_CREATE_PRIVILEGE: i32 = 64i32;
8570 pub const POLICY_CREATE_SECRET: i32 = 32i32;
8571 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8572 #[repr(C)]
8573 pub struct POLICY_DEFAULT_QUOTA_INFO {
8574     pub QuotaLimits: super::super::QUOTA_LIMITS,
8575 }
8576 impl POLICY_DEFAULT_QUOTA_INFO {}
8577 impl ::std::default::Default for POLICY_DEFAULT_QUOTA_INFO {
8578     fn default() -> Self {
8579         unsafe { ::std::mem::zeroed() }
8580     }
8581 }
8582 impl ::std::fmt::Debug for POLICY_DEFAULT_QUOTA_INFO {
8583     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8584         fmt.debug_struct("POLICY_DEFAULT_QUOTA_INFO").field("QuotaLimits", &self.QuotaLimits).finish()
8585     }
8586 }
8587 impl ::std::cmp::PartialEq for POLICY_DEFAULT_QUOTA_INFO {
8588     fn eq(&self, other: &Self) -> bool {
8589         self.QuotaLimits == other.QuotaLimits
8590     }
8591 }
8592 impl ::std::cmp::Eq for POLICY_DEFAULT_QUOTA_INFO {}
8593 unsafe impl ::windows::runtime::Abi for POLICY_DEFAULT_QUOTA_INFO {
8594     type Abi = Self;
8595     type DefaultType = Self;
8596 }
8597 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8598 #[repr(C)]
8599 #[cfg(feature = "Win32_Foundation")]
8600 pub struct POLICY_DNS_DOMAIN_INFO {
8601     pub Name: super::super::super::Foundation::UNICODE_STRING,
8602     pub DnsDomainName: super::super::super::Foundation::UNICODE_STRING,
8603     pub DnsForestName: super::super::super::Foundation::UNICODE_STRING,
8604     pub DomainGuid: ::windows::runtime::GUID,
8605     pub Sid: super::super::super::Foundation::PSID,
8606 }
8607 #[cfg(feature = "Win32_Foundation")]
8608 impl POLICY_DNS_DOMAIN_INFO {}
8609 #[cfg(feature = "Win32_Foundation")]
8610 impl ::std::default::Default for POLICY_DNS_DOMAIN_INFO {
8611     fn default() -> Self {
8612         unsafe { ::std::mem::zeroed() }
8613     }
8614 }
8615 #[cfg(feature = "Win32_Foundation")]
8616 impl ::std::fmt::Debug for POLICY_DNS_DOMAIN_INFO {
8617     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8618         fmt.debug_struct("POLICY_DNS_DOMAIN_INFO").field("Name", &self.Name).field("DnsDomainName", &self.DnsDomainName).field("DnsForestName", &self.DnsForestName).field("DomainGuid", &self.DomainGuid).field("Sid", &self.Sid).finish()
8619     }
8620 }
8621 #[cfg(feature = "Win32_Foundation")]
8622 impl ::std::cmp::PartialEq for POLICY_DNS_DOMAIN_INFO {
8623     fn eq(&self, other: &Self) -> bool {
8624         self.Name == other.Name && self.DnsDomainName == other.DnsDomainName && self.DnsForestName == other.DnsForestName && self.DomainGuid == other.DomainGuid && self.Sid == other.Sid
8625     }
8626 }
8627 #[cfg(feature = "Win32_Foundation")]
8628 impl ::std::cmp::Eq for POLICY_DNS_DOMAIN_INFO {}
8629 #[cfg(feature = "Win32_Foundation")]
8630 unsafe impl ::windows::runtime::Abi for POLICY_DNS_DOMAIN_INFO {
8631     type Abi = Self;
8632     type DefaultType = Self;
8633 }
8634 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8635 #[repr(C)]
8636 pub struct POLICY_DOMAIN_EFS_INFO {
8637     pub InfoLength: u32,
8638     pub EfsBlob: *mut u8,
8639 }
8640 impl POLICY_DOMAIN_EFS_INFO {}
8641 impl ::std::default::Default for POLICY_DOMAIN_EFS_INFO {
8642     fn default() -> Self {
8643         unsafe { ::std::mem::zeroed() }
8644     }
8645 }
8646 impl ::std::fmt::Debug for POLICY_DOMAIN_EFS_INFO {
8647     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8648         fmt.debug_struct("POLICY_DOMAIN_EFS_INFO").field("InfoLength", &self.InfoLength).field("EfsBlob", &self.EfsBlob).finish()
8649     }
8650 }
8651 impl ::std::cmp::PartialEq for POLICY_DOMAIN_EFS_INFO {
8652     fn eq(&self, other: &Self) -> bool {
8653         self.InfoLength == other.InfoLength && self.EfsBlob == other.EfsBlob
8654     }
8655 }
8656 impl ::std::cmp::Eq for POLICY_DOMAIN_EFS_INFO {}
8657 unsafe impl ::windows::runtime::Abi for POLICY_DOMAIN_EFS_INFO {
8658     type Abi = Self;
8659     type DefaultType = Self;
8660 }
8661 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8662 #[repr(transparent)]
8663 pub struct POLICY_DOMAIN_INFORMATION_CLASS(pub i32);
8664 pub const PolicyDomainEfsInformation: POLICY_DOMAIN_INFORMATION_CLASS = POLICY_DOMAIN_INFORMATION_CLASS(2i32);
8665 pub const PolicyDomainKerberosTicketInformation: POLICY_DOMAIN_INFORMATION_CLASS = POLICY_DOMAIN_INFORMATION_CLASS(3i32);
8666 impl ::std::convert::From<i32> for POLICY_DOMAIN_INFORMATION_CLASS {
8667     fn from(value: i32) -> Self {
8668         Self(value)
8669     }
8670 }
8671 unsafe impl ::windows::runtime::Abi for POLICY_DOMAIN_INFORMATION_CLASS {
8672     type Abi = Self;
8673     type DefaultType = Self;
8674 }
8675 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8676 #[repr(C)]
8677 pub struct POLICY_DOMAIN_KERBEROS_TICKET_INFO {
8678     pub AuthenticationOptions: u32,
8679     pub MaxServiceTicketAge: i64,
8680     pub MaxTicketAge: i64,
8681     pub MaxRenewAge: i64,
8682     pub MaxClockSkew: i64,
8683     pub Reserved: i64,
8684 }
8685 impl POLICY_DOMAIN_KERBEROS_TICKET_INFO {}
8686 impl ::std::default::Default for POLICY_DOMAIN_KERBEROS_TICKET_INFO {
8687     fn default() -> Self {
8688         unsafe { ::std::mem::zeroed() }
8689     }
8690 }
8691 impl ::std::fmt::Debug for POLICY_DOMAIN_KERBEROS_TICKET_INFO {
8692     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8693         fmt.debug_struct("POLICY_DOMAIN_KERBEROS_TICKET_INFO")
8694             .field("AuthenticationOptions", &self.AuthenticationOptions)
8695             .field("MaxServiceTicketAge", &self.MaxServiceTicketAge)
8696             .field("MaxTicketAge", &self.MaxTicketAge)
8697             .field("MaxRenewAge", &self.MaxRenewAge)
8698             .field("MaxClockSkew", &self.MaxClockSkew)
8699             .field("Reserved", &self.Reserved)
8700             .finish()
8701     }
8702 }
8703 impl ::std::cmp::PartialEq for POLICY_DOMAIN_KERBEROS_TICKET_INFO {
8704     fn eq(&self, other: &Self) -> bool {
8705         self.AuthenticationOptions == other.AuthenticationOptions && self.MaxServiceTicketAge == other.MaxServiceTicketAge && self.MaxTicketAge == other.MaxTicketAge && self.MaxRenewAge == other.MaxRenewAge && self.MaxClockSkew == other.MaxClockSkew && self.Reserved == other.Reserved
8706     }
8707 }
8708 impl ::std::cmp::Eq for POLICY_DOMAIN_KERBEROS_TICKET_INFO {}
8709 unsafe impl ::windows::runtime::Abi for POLICY_DOMAIN_KERBEROS_TICKET_INFO {
8710     type Abi = Self;
8711     type DefaultType = Self;
8712 }
8713 pub const POLICY_GET_PRIVATE_INFORMATION: i32 = 4i32;
8714 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8715 #[repr(transparent)]
8716 pub struct POLICY_INFORMATION_CLASS(pub i32);
8717 pub const PolicyAuditLogInformation: POLICY_INFORMATION_CLASS = POLICY_INFORMATION_CLASS(1i32);
8718 pub const PolicyAuditEventsInformation: POLICY_INFORMATION_CLASS = POLICY_INFORMATION_CLASS(2i32);
8719 pub const PolicyPrimaryDomainInformation: POLICY_INFORMATION_CLASS = POLICY_INFORMATION_CLASS(3i32);
8720 pub const PolicyPdAccountInformation: POLICY_INFORMATION_CLASS = POLICY_INFORMATION_CLASS(4i32);
8721 pub const PolicyAccountDomainInformation: POLICY_INFORMATION_CLASS = POLICY_INFORMATION_CLASS(5i32);
8722 pub const PolicyLsaServerRoleInformation: POLICY_INFORMATION_CLASS = POLICY_INFORMATION_CLASS(6i32);
8723 pub const PolicyReplicaSourceInformation: POLICY_INFORMATION_CLASS = POLICY_INFORMATION_CLASS(7i32);
8724 pub const PolicyDefaultQuotaInformation: POLICY_INFORMATION_CLASS = POLICY_INFORMATION_CLASS(8i32);
8725 pub const PolicyModificationInformation: POLICY_INFORMATION_CLASS = POLICY_INFORMATION_CLASS(9i32);
8726 pub const PolicyAuditFullSetInformation: POLICY_INFORMATION_CLASS = POLICY_INFORMATION_CLASS(10i32);
8727 pub const PolicyAuditFullQueryInformation: POLICY_INFORMATION_CLASS = POLICY_INFORMATION_CLASS(11i32);
8728 pub const PolicyDnsDomainInformation: POLICY_INFORMATION_CLASS = POLICY_INFORMATION_CLASS(12i32);
8729 pub const PolicyDnsDomainInformationInt: POLICY_INFORMATION_CLASS = POLICY_INFORMATION_CLASS(13i32);
8730 pub const PolicyLocalAccountDomainInformation: POLICY_INFORMATION_CLASS = POLICY_INFORMATION_CLASS(14i32);
8731 pub const PolicyMachineAccountInformation: POLICY_INFORMATION_CLASS = POLICY_INFORMATION_CLASS(15i32);
8732 pub const PolicyLastEntry: POLICY_INFORMATION_CLASS = POLICY_INFORMATION_CLASS(16i32);
8733 impl ::std::convert::From<i32> for POLICY_INFORMATION_CLASS {
8734     fn from(value: i32) -> Self {
8735         Self(value)
8736     }
8737 }
8738 unsafe impl ::windows::runtime::Abi for POLICY_INFORMATION_CLASS {
8739     type Abi = Self;
8740     type DefaultType = Self;
8741 }
8742 pub const POLICY_KERBEROS_VALIDATE_CLIENT: u32 = 128u32;
8743 pub const POLICY_LOOKUP_NAMES: i32 = 2048i32;
8744 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8745 #[repr(transparent)]
8746 pub struct POLICY_LSA_SERVER_ROLE(pub i32);
8747 pub const PolicyServerRoleBackup: POLICY_LSA_SERVER_ROLE = POLICY_LSA_SERVER_ROLE(2i32);
8748 pub const PolicyServerRolePrimary: POLICY_LSA_SERVER_ROLE = POLICY_LSA_SERVER_ROLE(3i32);
8749 impl ::std::convert::From<i32> for POLICY_LSA_SERVER_ROLE {
8750     fn from(value: i32) -> Self {
8751         Self(value)
8752     }
8753 }
8754 unsafe impl ::windows::runtime::Abi for POLICY_LSA_SERVER_ROLE {
8755     type Abi = Self;
8756     type DefaultType = Self;
8757 }
8758 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8759 #[repr(C)]
8760 pub struct POLICY_LSA_SERVER_ROLE_INFO {
8761     pub LsaServerRole: POLICY_LSA_SERVER_ROLE,
8762 }
8763 impl POLICY_LSA_SERVER_ROLE_INFO {}
8764 impl ::std::default::Default for POLICY_LSA_SERVER_ROLE_INFO {
8765     fn default() -> Self {
8766         unsafe { ::std::mem::zeroed() }
8767     }
8768 }
8769 impl ::std::fmt::Debug for POLICY_LSA_SERVER_ROLE_INFO {
8770     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8771         fmt.debug_struct("POLICY_LSA_SERVER_ROLE_INFO").field("LsaServerRole", &self.LsaServerRole).finish()
8772     }
8773 }
8774 impl ::std::cmp::PartialEq for POLICY_LSA_SERVER_ROLE_INFO {
8775     fn eq(&self, other: &Self) -> bool {
8776         self.LsaServerRole == other.LsaServerRole
8777     }
8778 }
8779 impl ::std::cmp::Eq for POLICY_LSA_SERVER_ROLE_INFO {}
8780 unsafe impl ::windows::runtime::Abi for POLICY_LSA_SERVER_ROLE_INFO {
8781     type Abi = Self;
8782     type DefaultType = Self;
8783 }
8784 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8785 #[repr(C)]
8786 #[cfg(feature = "Win32_Foundation")]
8787 pub struct POLICY_MACHINE_ACCT_INFO {
8788     pub Rid: u32,
8789     pub Sid: super::super::super::Foundation::PSID,
8790 }
8791 #[cfg(feature = "Win32_Foundation")]
8792 impl POLICY_MACHINE_ACCT_INFO {}
8793 #[cfg(feature = "Win32_Foundation")]
8794 impl ::std::default::Default for POLICY_MACHINE_ACCT_INFO {
8795     fn default() -> Self {
8796         unsafe { ::std::mem::zeroed() }
8797     }
8798 }
8799 #[cfg(feature = "Win32_Foundation")]
8800 impl ::std::fmt::Debug for POLICY_MACHINE_ACCT_INFO {
8801     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8802         fmt.debug_struct("POLICY_MACHINE_ACCT_INFO").field("Rid", &self.Rid).field("Sid", &self.Sid).finish()
8803     }
8804 }
8805 #[cfg(feature = "Win32_Foundation")]
8806 impl ::std::cmp::PartialEq for POLICY_MACHINE_ACCT_INFO {
8807     fn eq(&self, other: &Self) -> bool {
8808         self.Rid == other.Rid && self.Sid == other.Sid
8809     }
8810 }
8811 #[cfg(feature = "Win32_Foundation")]
8812 impl ::std::cmp::Eq for POLICY_MACHINE_ACCT_INFO {}
8813 #[cfg(feature = "Win32_Foundation")]
8814 unsafe impl ::windows::runtime::Abi for POLICY_MACHINE_ACCT_INFO {
8815     type Abi = Self;
8816     type DefaultType = Self;
8817 }
8818 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8819 #[repr(C)]
8820 pub struct POLICY_MODIFICATION_INFO {
8821     pub ModifiedId: i64,
8822     pub DatabaseCreationTime: i64,
8823 }
8824 impl POLICY_MODIFICATION_INFO {}
8825 impl ::std::default::Default for POLICY_MODIFICATION_INFO {
8826     fn default() -> Self {
8827         unsafe { ::std::mem::zeroed() }
8828     }
8829 }
8830 impl ::std::fmt::Debug for POLICY_MODIFICATION_INFO {
8831     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8832         fmt.debug_struct("POLICY_MODIFICATION_INFO").field("ModifiedId", &self.ModifiedId).field("DatabaseCreationTime", &self.DatabaseCreationTime).finish()
8833     }
8834 }
8835 impl ::std::cmp::PartialEq for POLICY_MODIFICATION_INFO {
8836     fn eq(&self, other: &Self) -> bool {
8837         self.ModifiedId == other.ModifiedId && self.DatabaseCreationTime == other.DatabaseCreationTime
8838     }
8839 }
8840 impl ::std::cmp::Eq for POLICY_MODIFICATION_INFO {}
8841 unsafe impl ::windows::runtime::Abi for POLICY_MODIFICATION_INFO {
8842     type Abi = Self;
8843     type DefaultType = Self;
8844 }
8845 pub const POLICY_NOTIFICATION: i32 = 4096i32;
8846 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8847 #[repr(transparent)]
8848 pub struct POLICY_NOTIFICATION_INFORMATION_CLASS(pub i32);
8849 pub const PolicyNotifyAuditEventsInformation: POLICY_NOTIFICATION_INFORMATION_CLASS = POLICY_NOTIFICATION_INFORMATION_CLASS(1i32);
8850 pub const PolicyNotifyAccountDomainInformation: POLICY_NOTIFICATION_INFORMATION_CLASS = POLICY_NOTIFICATION_INFORMATION_CLASS(2i32);
8851 pub const PolicyNotifyServerRoleInformation: POLICY_NOTIFICATION_INFORMATION_CLASS = POLICY_NOTIFICATION_INFORMATION_CLASS(3i32);
8852 pub const PolicyNotifyDnsDomainInformation: POLICY_NOTIFICATION_INFORMATION_CLASS = POLICY_NOTIFICATION_INFORMATION_CLASS(4i32);
8853 pub const PolicyNotifyDomainEfsInformation: POLICY_NOTIFICATION_INFORMATION_CLASS = POLICY_NOTIFICATION_INFORMATION_CLASS(5i32);
8854 pub const PolicyNotifyDomainKerberosTicketInformation: POLICY_NOTIFICATION_INFORMATION_CLASS = POLICY_NOTIFICATION_INFORMATION_CLASS(6i32);
8855 pub const PolicyNotifyMachineAccountPasswordInformation: POLICY_NOTIFICATION_INFORMATION_CLASS = POLICY_NOTIFICATION_INFORMATION_CLASS(7i32);
8856 pub const PolicyNotifyGlobalSaclInformation: POLICY_NOTIFICATION_INFORMATION_CLASS = POLICY_NOTIFICATION_INFORMATION_CLASS(8i32);
8857 pub const PolicyNotifyMax: POLICY_NOTIFICATION_INFORMATION_CLASS = POLICY_NOTIFICATION_INFORMATION_CLASS(9i32);
8858 impl ::std::convert::From<i32> for POLICY_NOTIFICATION_INFORMATION_CLASS {
8859     fn from(value: i32) -> Self {
8860         Self(value)
8861     }
8862 }
8863 unsafe impl ::windows::runtime::Abi for POLICY_NOTIFICATION_INFORMATION_CLASS {
8864     type Abi = Self;
8865     type DefaultType = Self;
8866 }
8867 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8868 #[repr(C)]
8869 #[cfg(feature = "Win32_Foundation")]
8870 pub struct POLICY_PD_ACCOUNT_INFO {
8871     pub Name: super::super::super::Foundation::UNICODE_STRING,
8872 }
8873 #[cfg(feature = "Win32_Foundation")]
8874 impl POLICY_PD_ACCOUNT_INFO {}
8875 #[cfg(feature = "Win32_Foundation")]
8876 impl ::std::default::Default for POLICY_PD_ACCOUNT_INFO {
8877     fn default() -> Self {
8878         unsafe { ::std::mem::zeroed() }
8879     }
8880 }
8881 #[cfg(feature = "Win32_Foundation")]
8882 impl ::std::fmt::Debug for POLICY_PD_ACCOUNT_INFO {
8883     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8884         fmt.debug_struct("POLICY_PD_ACCOUNT_INFO").field("Name", &self.Name).finish()
8885     }
8886 }
8887 #[cfg(feature = "Win32_Foundation")]
8888 impl ::std::cmp::PartialEq for POLICY_PD_ACCOUNT_INFO {
8889     fn eq(&self, other: &Self) -> bool {
8890         self.Name == other.Name
8891     }
8892 }
8893 #[cfg(feature = "Win32_Foundation")]
8894 impl ::std::cmp::Eq for POLICY_PD_ACCOUNT_INFO {}
8895 #[cfg(feature = "Win32_Foundation")]
8896 unsafe impl ::windows::runtime::Abi for POLICY_PD_ACCOUNT_INFO {
8897     type Abi = Self;
8898     type DefaultType = Self;
8899 }
8900 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8901 #[repr(C)]
8902 #[cfg(feature = "Win32_Foundation")]
8903 pub struct POLICY_PRIMARY_DOMAIN_INFO {
8904     pub Name: super::super::super::Foundation::UNICODE_STRING,
8905     pub Sid: super::super::super::Foundation::PSID,
8906 }
8907 #[cfg(feature = "Win32_Foundation")]
8908 impl POLICY_PRIMARY_DOMAIN_INFO {}
8909 #[cfg(feature = "Win32_Foundation")]
8910 impl ::std::default::Default for POLICY_PRIMARY_DOMAIN_INFO {
8911     fn default() -> Self {
8912         unsafe { ::std::mem::zeroed() }
8913     }
8914 }
8915 #[cfg(feature = "Win32_Foundation")]
8916 impl ::std::fmt::Debug for POLICY_PRIMARY_DOMAIN_INFO {
8917     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8918         fmt.debug_struct("POLICY_PRIMARY_DOMAIN_INFO").field("Name", &self.Name).field("Sid", &self.Sid).finish()
8919     }
8920 }
8921 #[cfg(feature = "Win32_Foundation")]
8922 impl ::std::cmp::PartialEq for POLICY_PRIMARY_DOMAIN_INFO {
8923     fn eq(&self, other: &Self) -> bool {
8924         self.Name == other.Name && self.Sid == other.Sid
8925     }
8926 }
8927 #[cfg(feature = "Win32_Foundation")]
8928 impl ::std::cmp::Eq for POLICY_PRIMARY_DOMAIN_INFO {}
8929 #[cfg(feature = "Win32_Foundation")]
8930 unsafe impl ::windows::runtime::Abi for POLICY_PRIMARY_DOMAIN_INFO {
8931     type Abi = Self;
8932     type DefaultType = Self;
8933 }
8934 pub const POLICY_QOS_ALLOW_LOCAL_ROOT_CERT_STORE: u32 = 32u32;
8935 pub const POLICY_QOS_DHCP_SERVER_ALLOWED: u32 = 128u32;
8936 pub const POLICY_QOS_INBOUND_CONFIDENTIALITY: u32 = 16u32;
8937 pub const POLICY_QOS_INBOUND_INTEGRITY: u32 = 8u32;
8938 pub const POLICY_QOS_OUTBOUND_CONFIDENTIALITY: u32 = 4u32;
8939 pub const POLICY_QOS_OUTBOUND_INTEGRITY: u32 = 2u32;
8940 pub const POLICY_QOS_RAS_SERVER_ALLOWED: u32 = 64u32;
8941 pub const POLICY_QOS_SCHANNEL_REQUIRED: u32 = 1u32;
8942 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8943 #[repr(C)]
8944 #[cfg(feature = "Win32_Foundation")]
8945 pub struct POLICY_REPLICA_SOURCE_INFO {
8946     pub ReplicaSource: super::super::super::Foundation::UNICODE_STRING,
8947     pub ReplicaAccountName: super::super::super::Foundation::UNICODE_STRING,
8948 }
8949 #[cfg(feature = "Win32_Foundation")]
8950 impl POLICY_REPLICA_SOURCE_INFO {}
8951 #[cfg(feature = "Win32_Foundation")]
8952 impl ::std::default::Default for POLICY_REPLICA_SOURCE_INFO {
8953     fn default() -> Self {
8954         unsafe { ::std::mem::zeroed() }
8955     }
8956 }
8957 #[cfg(feature = "Win32_Foundation")]
8958 impl ::std::fmt::Debug for POLICY_REPLICA_SOURCE_INFO {
8959     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8960         fmt.debug_struct("POLICY_REPLICA_SOURCE_INFO").field("ReplicaSource", &self.ReplicaSource).field("ReplicaAccountName", &self.ReplicaAccountName).finish()
8961     }
8962 }
8963 #[cfg(feature = "Win32_Foundation")]
8964 impl ::std::cmp::PartialEq for POLICY_REPLICA_SOURCE_INFO {
8965     fn eq(&self, other: &Self) -> bool {
8966         self.ReplicaSource == other.ReplicaSource && self.ReplicaAccountName == other.ReplicaAccountName
8967     }
8968 }
8969 #[cfg(feature = "Win32_Foundation")]
8970 impl ::std::cmp::Eq for POLICY_REPLICA_SOURCE_INFO {}
8971 #[cfg(feature = "Win32_Foundation")]
8972 unsafe impl ::windows::runtime::Abi for POLICY_REPLICA_SOURCE_INFO {
8973     type Abi = Self;
8974     type DefaultType = Self;
8975 }
8976 pub const POLICY_SERVER_ADMIN: i32 = 1024i32;
8977 pub const POLICY_SET_AUDIT_REQUIREMENTS: i32 = 256i32;
8978 pub const POLICY_SET_DEFAULT_QUOTA_LIMITS: i32 = 128i32;
8979 pub const POLICY_TRUST_ADMIN: i32 = 8i32;
8980 pub const POLICY_VIEW_AUDIT_INFORMATION: i32 = 2i32;
8981 pub const POLICY_VIEW_LOCAL_INFORMATION: i32 = 1i32;
8982 pub const PRIMARY_CRED_ARSO_LOGON: u32 = 2097152u32;
8983 pub const PRIMARY_CRED_AUTH_ID: u32 = 512u32;
8984 pub const PRIMARY_CRED_CACHED_INTERACTIVE_LOGON: u32 = 262144u32;
8985 pub const PRIMARY_CRED_CACHED_LOGON: u32 = 8u32;
8986 pub const PRIMARY_CRED_CLEAR_PASSWORD: u32 = 1u32;
8987 pub const PRIMARY_CRED_DO_NOT_SPLIT: u32 = 1024u32;
8988 pub const PRIMARY_CRED_ENCRYPTED_CREDGUARD_PASSWORD: u32 = 131072u32;
8989 pub const PRIMARY_CRED_ENTERPRISE_INTERNET_USER: u32 = 65536u32;
8990 pub const PRIMARY_CRED_EX: u32 = 4096u32;
8991 pub const PRIMARY_CRED_INTERACTIVE_FIDO_LOGON: u32 = 1048576u32;
8992 pub const PRIMARY_CRED_INTERACTIVE_NGC_LOGON: u32 = 524288u32;
8993 pub const PRIMARY_CRED_INTERACTIVE_SMARTCARD_LOGON: u32 = 64u32;
8994 pub const PRIMARY_CRED_INTERNET_USER: u32 = 256u32;
8995 pub const PRIMARY_CRED_LOGON_LUA: u32 = 32u32;
8996 pub const PRIMARY_CRED_LOGON_NO_TCB: u32 = 16u32;
8997 pub const PRIMARY_CRED_LOGON_PACKAGE_SHIFT: u32 = 24u32;
8998 pub const PRIMARY_CRED_OWF_PASSWORD: u32 = 2u32;
8999 pub const PRIMARY_CRED_PACKAGE_MASK: u32 = 4278190080u32;
9000 pub const PRIMARY_CRED_PACKED_CREDS: u32 = 32768u32;
9001 pub const PRIMARY_CRED_PROTECTED_USER: u32 = 2048u32;
9002 pub const PRIMARY_CRED_REFRESH_NEEDED: u32 = 128u32;
9003 pub const PRIMARY_CRED_RESTRICTED_TS: u32 = 16384u32;
9004 pub const PRIMARY_CRED_SUPPLEMENTAL: u32 = 4194304u32;
9005 pub const PRIMARY_CRED_TRANSFER: u32 = 8192u32;
9006 pub const PRIMARY_CRED_UPDATE: u32 = 4u32;
9007 pub type PSAM_CREDENTIAL_UPDATE_FREE_ROUTINE = unsafe extern "system" fn(p: *const ::std::ffi::c_void);
9008 #[cfg(feature = "Win32_Foundation")]
9009 pub type PSAM_CREDENTIAL_UPDATE_NOTIFY_ROUTINE = unsafe extern "system" fn(
9010     clearpassword: *const super::super::super::Foundation::UNICODE_STRING,
9011     oldcredentials: *const ::std::ffi::c_void,
9012     oldcredentialsize: u32,
9013     useraccountcontrol: u32,
9014     upn: *const super::super::super::Foundation::UNICODE_STRING,
9015     username: *const super::super::super::Foundation::UNICODE_STRING,
9016     netbiosdomainname: *const super::super::super::Foundation::UNICODE_STRING,
9017     dnsdomainname: *const super::super::super::Foundation::UNICODE_STRING,
9018     newcredentials: *mut *mut ::std::ffi::c_void,
9019     newcredentialsize: *mut u32,
9020 ) -> super::super::super::Foundation::NTSTATUS;
9021 #[cfg(feature = "Win32_Foundation")]
9022 pub type PSAM_CREDENTIAL_UPDATE_REGISTER_MAPPED_ENTRYPOINTS_ROUTINE = unsafe extern "system" fn(table: *mut SAM_REGISTER_MAPPING_TABLE) -> super::super::super::Foundation::NTSTATUS;
9023 #[cfg(feature = "Win32_Foundation")]
9024 pub type PSAM_CREDENTIAL_UPDATE_REGISTER_ROUTINE = unsafe extern "system" fn(credentialname: *mut super::super::super::Foundation::UNICODE_STRING) -> super::super::super::Foundation::BOOLEAN;
9025 #[cfg(feature = "Win32_Foundation")]
9026 pub type PSAM_INIT_NOTIFICATION_ROUTINE = unsafe extern "system" fn() -> super::super::super::Foundation::BOOLEAN;
9027 #[cfg(feature = "Win32_Foundation")]
9028 pub type PSAM_PASSWORD_FILTER_ROUTINE = unsafe extern "system" fn(accountname: *const super::super::super::Foundation::UNICODE_STRING, fullname: *const super::super::super::Foundation::UNICODE_STRING, password: *const super::super::super::Foundation::UNICODE_STRING, setoperation: super::super::super::Foundation::BOOLEAN) -> super::super::super::Foundation::BOOLEAN;
9029 #[cfg(feature = "Win32_Foundation")]
9030 pub type PSAM_PASSWORD_NOTIFICATION_ROUTINE = unsafe extern "system" fn(username: *mut super::super::super::Foundation::UNICODE_STRING, relativeid: u32, newpassword: *mut super::super::super::Foundation::UNICODE_STRING) -> super::super::super::Foundation::NTSTATUS;
9031 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9032 #[repr(C)]
9033 pub struct PctPublicKey {
9034     pub Type: u32,
9035     pub cbKey: u32,
9036     pub pKey: [u8; 1],
9037 }
9038 impl PctPublicKey {}
9039 impl ::std::default::Default for PctPublicKey {
9040     fn default() -> Self {
9041         unsafe { ::std::mem::zeroed() }
9042     }
9043 }
9044 impl ::std::fmt::Debug for PctPublicKey {
9045     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9046         fmt.debug_struct("PctPublicKey").field("Type", &self.Type).field("cbKey", &self.cbKey).field("pKey", &self.pKey).finish()
9047     }
9048 }
9049 impl ::std::cmp::PartialEq for PctPublicKey {
9050     fn eq(&self, other: &Self) -> bool {
9051         self.Type == other.Type && self.cbKey == other.cbKey && self.pKey == other.pKey
9052     }
9053 }
9054 impl ::std::cmp::Eq for PctPublicKey {}
9055 unsafe impl ::windows::runtime::Abi for PctPublicKey {
9056     type Abi = Self;
9057     type DefaultType = Self;
9058 }
9059 #[cfg(feature = "Win32_Security_Credentials")]
9060 pub type QUERY_CONTEXT_ATTRIBUTES_EX_FN_A = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: u32, param2: *mut ::std::ffi::c_void, param3: u32) -> i32;
9061 #[cfg(feature = "Win32_Security_Credentials")]
9062 pub type QUERY_CONTEXT_ATTRIBUTES_EX_FN_W = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: u32, param2: *mut ::std::ffi::c_void, param3: u32) -> i32;
9063 #[cfg(feature = "Win32_Security_Credentials")]
9064 pub type QUERY_CONTEXT_ATTRIBUTES_FN_A = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: u32, param2: *mut ::std::ffi::c_void) -> i32;
9065 #[cfg(feature = "Win32_Security_Credentials")]
9066 pub type QUERY_CONTEXT_ATTRIBUTES_FN_W = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: u32, param2: *mut ::std::ffi::c_void) -> i32;
9067 #[cfg(feature = "Win32_Security_Credentials")]
9068 pub type QUERY_CREDENTIALS_ATTRIBUTES_EX_FN_A = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: u32, param2: *mut ::std::ffi::c_void, param3: u32) -> i32;
9069 #[cfg(feature = "Win32_Security_Credentials")]
9070 pub type QUERY_CREDENTIALS_ATTRIBUTES_EX_FN_W = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: u32, param2: *mut ::std::ffi::c_void, param3: u32) -> i32;
9071 #[cfg(feature = "Win32_Security_Credentials")]
9072 pub type QUERY_CREDENTIALS_ATTRIBUTES_FN_A = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: u32, param2: *mut ::std::ffi::c_void) -> i32;
9073 #[cfg(feature = "Win32_Security_Credentials")]
9074 pub type QUERY_CREDENTIALS_ATTRIBUTES_FN_W = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: u32, param2: *mut ::std::ffi::c_void) -> i32;
9075 #[cfg(feature = "Win32_Security_Credentials")]
9076 pub type QUERY_SECURITY_CONTEXT_TOKEN_FN = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: *mut *mut ::std::ffi::c_void) -> i32;
9077 pub type QUERY_SECURITY_PACKAGE_INFO_FN_A = unsafe extern "system" fn(param0: *mut i8, param1: *mut *mut SecPkgInfoA) -> i32;
9078 pub type QUERY_SECURITY_PACKAGE_INFO_FN_W = unsafe extern "system" fn(param0: *mut u16, param1: *mut *mut SecPkgInfoW) -> i32;
9079 #[cfg(feature = "Win32_Security_Credentials")]
9080 #[inline]
9081 pub unsafe fn QueryContextAttributesA(phcontext: *const super::super::Credentials::SecHandle, ulattribute: SECPKG_ATTR, pbuffer: *mut ::std::ffi::c_void) -> i32 {
9082     #[cfg(windows)]
9083     {
9084         #[link(name = "windows")]
9085         extern "system" {
9086             fn QueryContextAttributesA(phcontext: *const super::super::Credentials::SecHandle, ulattribute: SECPKG_ATTR, pbuffer: *mut ::std::ffi::c_void) -> i32;
9087         }
9088         ::std::mem::transmute(QueryContextAttributesA(::std::mem::transmute(phcontext), ::std::mem::transmute(ulattribute), ::std::mem::transmute(pbuffer)))
9089     }
9090     #[cfg(not(windows))]
9091     unimplemented!("Unsupported target OS");
9092 }
9093 #[cfg(feature = "Win32_Security_Credentials")]
9094 #[inline]
9095 pub unsafe fn QueryContextAttributesExA(phcontext: *const super::super::Credentials::SecHandle, ulattribute: SECPKG_ATTR, pbuffer: *mut ::std::ffi::c_void, cbbuffer: u32) -> i32 {
9096     #[cfg(windows)]
9097     {
9098         #[link(name = "windows")]
9099         extern "system" {
9100             fn QueryContextAttributesExA(phcontext: *const super::super::Credentials::SecHandle, ulattribute: SECPKG_ATTR, pbuffer: *mut ::std::ffi::c_void, cbbuffer: u32) -> i32;
9101         }
9102         ::std::mem::transmute(QueryContextAttributesExA(::std::mem::transmute(phcontext), ::std::mem::transmute(ulattribute), ::std::mem::transmute(pbuffer), ::std::mem::transmute(cbbuffer)))
9103     }
9104     #[cfg(not(windows))]
9105     unimplemented!("Unsupported target OS");
9106 }
9107 #[cfg(feature = "Win32_Security_Credentials")]
9108 #[inline]
9109 pub unsafe fn QueryContextAttributesExW(phcontext: *const super::super::Credentials::SecHandle, ulattribute: SECPKG_ATTR, pbuffer: *mut ::std::ffi::c_void, cbbuffer: u32) -> i32 {
9110     #[cfg(windows)]
9111     {
9112         #[link(name = "windows")]
9113         extern "system" {
9114             fn QueryContextAttributesExW(phcontext: *const super::super::Credentials::SecHandle, ulattribute: SECPKG_ATTR, pbuffer: *mut ::std::ffi::c_void, cbbuffer: u32) -> i32;
9115         }
9116         ::std::mem::transmute(QueryContextAttributesExW(::std::mem::transmute(phcontext), ::std::mem::transmute(ulattribute), ::std::mem::transmute(pbuffer), ::std::mem::transmute(cbbuffer)))
9117     }
9118     #[cfg(not(windows))]
9119     unimplemented!("Unsupported target OS");
9120 }
9121 #[cfg(feature = "Win32_Security_Credentials")]
9122 #[inline]
9123 pub unsafe fn QueryContextAttributesW(phcontext: *const super::super::Credentials::SecHandle, ulattribute: SECPKG_ATTR, pbuffer: *mut ::std::ffi::c_void) -> i32 {
9124     #[cfg(windows)]
9125     {
9126         #[link(name = "windows")]
9127         extern "system" {
9128             fn QueryContextAttributesW(phcontext: *const super::super::Credentials::SecHandle, ulattribute: SECPKG_ATTR, pbuffer: *mut ::std::ffi::c_void) -> i32;
9129         }
9130         ::std::mem::transmute(QueryContextAttributesW(::std::mem::transmute(phcontext), ::std::mem::transmute(ulattribute), ::std::mem::transmute(pbuffer)))
9131     }
9132     #[cfg(not(windows))]
9133     unimplemented!("Unsupported target OS");
9134 }
9135 #[cfg(feature = "Win32_Security_Credentials")]
9136 #[inline]
9137 pub unsafe fn QueryCredentialsAttributesA(phcredential: *const super::super::Credentials::SecHandle, ulattribute: u32, pbuffer: *mut ::std::ffi::c_void) -> i32 {
9138     #[cfg(windows)]
9139     {
9140         #[link(name = "windows")]
9141         extern "system" {
9142             fn QueryCredentialsAttributesA(phcredential: *const super::super::Credentials::SecHandle, ulattribute: u32, pbuffer: *mut ::std::ffi::c_void) -> i32;
9143         }
9144         ::std::mem::transmute(QueryCredentialsAttributesA(::std::mem::transmute(phcredential), ::std::mem::transmute(ulattribute), ::std::mem::transmute(pbuffer)))
9145     }
9146     #[cfg(not(windows))]
9147     unimplemented!("Unsupported target OS");
9148 }
9149 #[cfg(feature = "Win32_Security_Credentials")]
9150 #[inline]
9151 pub unsafe fn QueryCredentialsAttributesExA(phcredential: *const super::super::Credentials::SecHandle, ulattribute: u32, pbuffer: *mut ::std::ffi::c_void, cbbuffer: u32) -> i32 {
9152     #[cfg(windows)]
9153     {
9154         #[link(name = "windows")]
9155         extern "system" {
9156             fn QueryCredentialsAttributesExA(phcredential: *const super::super::Credentials::SecHandle, ulattribute: u32, pbuffer: *mut ::std::ffi::c_void, cbbuffer: u32) -> i32;
9157         }
9158         ::std::mem::transmute(QueryCredentialsAttributesExA(::std::mem::transmute(phcredential), ::std::mem::transmute(ulattribute), ::std::mem::transmute(pbuffer), ::std::mem::transmute(cbbuffer)))
9159     }
9160     #[cfg(not(windows))]
9161     unimplemented!("Unsupported target OS");
9162 }
9163 #[cfg(feature = "Win32_Security_Credentials")]
9164 #[inline]
9165 pub unsafe fn QueryCredentialsAttributesExW(phcredential: *const super::super::Credentials::SecHandle, ulattribute: u32, pbuffer: *mut ::std::ffi::c_void, cbbuffer: u32) -> i32 {
9166     #[cfg(windows)]
9167     {
9168         #[link(name = "windows")]
9169         extern "system" {
9170             fn QueryCredentialsAttributesExW(phcredential: *const super::super::Credentials::SecHandle, ulattribute: u32, pbuffer: *mut ::std::ffi::c_void, cbbuffer: u32) -> i32;
9171         }
9172         ::std::mem::transmute(QueryCredentialsAttributesExW(::std::mem::transmute(phcredential), ::std::mem::transmute(ulattribute), ::std::mem::transmute(pbuffer), ::std::mem::transmute(cbbuffer)))
9173     }
9174     #[cfg(not(windows))]
9175     unimplemented!("Unsupported target OS");
9176 }
9177 #[cfg(feature = "Win32_Security_Credentials")]
9178 #[inline]
9179 pub unsafe fn QueryCredentialsAttributesW(phcredential: *const super::super::Credentials::SecHandle, ulattribute: u32, pbuffer: *mut ::std::ffi::c_void) -> i32 {
9180     #[cfg(windows)]
9181     {
9182         #[link(name = "windows")]
9183         extern "system" {
9184             fn QueryCredentialsAttributesW(phcredential: *const super::super::Credentials::SecHandle, ulattribute: u32, pbuffer: *mut ::std::ffi::c_void) -> i32;
9185         }
9186         ::std::mem::transmute(QueryCredentialsAttributesW(::std::mem::transmute(phcredential), ::std::mem::transmute(ulattribute), ::std::mem::transmute(pbuffer)))
9187     }
9188     #[cfg(not(windows))]
9189     unimplemented!("Unsupported target OS");
9190 }
9191 #[cfg(feature = "Win32_Security_Credentials")]
9192 #[inline]
9193 pub unsafe fn QuerySecurityContextToken(phcontext: *const super::super::Credentials::SecHandle, token: *mut *mut ::std::ffi::c_void) -> i32 {
9194     #[cfg(windows)]
9195     {
9196         #[link(name = "windows")]
9197         extern "system" {
9198             fn QuerySecurityContextToken(phcontext: *const super::super::Credentials::SecHandle, token: *mut *mut ::std::ffi::c_void) -> i32;
9199         }
9200         ::std::mem::transmute(QuerySecurityContextToken(::std::mem::transmute(phcontext), ::std::mem::transmute(token)))
9201     }
9202     #[cfg(not(windows))]
9203     unimplemented!("Unsupported target OS");
9204 }
9205 #[cfg(feature = "Win32_Foundation")]
9206 #[inline]
9207 pub unsafe fn QuerySecurityPackageInfoA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSTR>>(pszpackagename: Param0, pppackageinfo: *mut *mut SecPkgInfoA) -> i32 {
9208     #[cfg(windows)]
9209     {
9210         #[link(name = "windows")]
9211         extern "system" {
9212             fn QuerySecurityPackageInfoA(pszpackagename: super::super::super::Foundation::PSTR, pppackageinfo: *mut *mut SecPkgInfoA) -> i32;
9213         }
9214         ::std::mem::transmute(QuerySecurityPackageInfoA(pszpackagename.into_param().abi(), ::std::mem::transmute(pppackageinfo)))
9215     }
9216     #[cfg(not(windows))]
9217     unimplemented!("Unsupported target OS");
9218 }
9219 #[cfg(feature = "Win32_Foundation")]
9220 #[inline]
9221 pub unsafe fn QuerySecurityPackageInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pszpackagename: Param0, pppackageinfo: *mut *mut SecPkgInfoW) -> i32 {
9222     #[cfg(windows)]
9223     {
9224         #[link(name = "windows")]
9225         extern "system" {
9226             fn QuerySecurityPackageInfoW(pszpackagename: super::super::super::Foundation::PWSTR, pppackageinfo: *mut *mut SecPkgInfoW) -> i32;
9227         }
9228         ::std::mem::transmute(QuerySecurityPackageInfoW(pszpackagename.into_param().abi(), ::std::mem::transmute(pppackageinfo)))
9229     }
9230     #[cfg(not(windows))]
9231     unimplemented!("Unsupported target OS");
9232 }
9233 pub const RCRED_CRED_EXISTS: u32 = 1u32;
9234 pub const RCRED_STATUS_NOCRED: u32 = 0u32;
9235 pub const RCRED_STATUS_UNKNOWN_ISSUER: u32 = 2u32;
9236 #[cfg(feature = "Win32_Security_Credentials")]
9237 pub type REVERT_SECURITY_CONTEXT_FN = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle) -> i32;
9238 pub const RTL_ENCRYPT_MEMORY_SIZE: u32 = 8u32;
9239 pub const RTL_ENCRYPT_OPTION_CROSS_PROCESS: u32 = 1u32;
9240 pub const RTL_ENCRYPT_OPTION_FOR_SYSTEM: u32 = 4u32;
9241 pub const RTL_ENCRYPT_OPTION_SAME_LOGON: u32 = 2u32;
9242 #[cfg(feature = "Win32_Security_Credentials")]
9243 #[inline]
9244 pub unsafe fn RevertSecurityContext(phcontext: *const super::super::Credentials::SecHandle) -> i32 {
9245     #[cfg(windows)]
9246     {
9247         #[link(name = "windows")]
9248         extern "system" {
9249             fn RevertSecurityContext(phcontext: *const super::super::Credentials::SecHandle) -> i32;
9250         }
9251         ::std::mem::transmute(RevertSecurityContext(::std::mem::transmute(phcontext)))
9252     }
9253     #[cfg(not(windows))]
9254     unimplemented!("Unsupported target OS");
9255 }
9256 pub const SAM_DAYS_PER_WEEK: u32 = 7u32;
9257 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9258 #[repr(C)]
9259 #[cfg(feature = "Win32_Foundation")]
9260 pub struct SAM_REGISTER_MAPPING_ELEMENT {
9261     pub Original: super::super::super::Foundation::PSTR,
9262     pub Mapped: super::super::super::Foundation::PSTR,
9263     pub Continuable: super::super::super::Foundation::BOOLEAN,
9264 }
9265 #[cfg(feature = "Win32_Foundation")]
9266 impl SAM_REGISTER_MAPPING_ELEMENT {}
9267 #[cfg(feature = "Win32_Foundation")]
9268 impl ::std::default::Default for SAM_REGISTER_MAPPING_ELEMENT {
9269     fn default() -> Self {
9270         unsafe { ::std::mem::zeroed() }
9271     }
9272 }
9273 #[cfg(feature = "Win32_Foundation")]
9274 impl ::std::fmt::Debug for SAM_REGISTER_MAPPING_ELEMENT {
9275     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9276         fmt.debug_struct("SAM_REGISTER_MAPPING_ELEMENT").field("Original", &self.Original).field("Mapped", &self.Mapped).field("Continuable", &self.Continuable).finish()
9277     }
9278 }
9279 #[cfg(feature = "Win32_Foundation")]
9280 impl ::std::cmp::PartialEq for SAM_REGISTER_MAPPING_ELEMENT {
9281     fn eq(&self, other: &Self) -> bool {
9282         self.Original == other.Original && self.Mapped == other.Mapped && self.Continuable == other.Continuable
9283     }
9284 }
9285 #[cfg(feature = "Win32_Foundation")]
9286 impl ::std::cmp::Eq for SAM_REGISTER_MAPPING_ELEMENT {}
9287 #[cfg(feature = "Win32_Foundation")]
9288 unsafe impl ::windows::runtime::Abi for SAM_REGISTER_MAPPING_ELEMENT {
9289     type Abi = Self;
9290     type DefaultType = Self;
9291 }
9292 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9293 #[repr(C)]
9294 #[cfg(feature = "Win32_Foundation")]
9295 pub struct SAM_REGISTER_MAPPING_LIST {
9296     pub Count: u32,
9297     pub Elements: *mut SAM_REGISTER_MAPPING_ELEMENT,
9298 }
9299 #[cfg(feature = "Win32_Foundation")]
9300 impl SAM_REGISTER_MAPPING_LIST {}
9301 #[cfg(feature = "Win32_Foundation")]
9302 impl ::std::default::Default for SAM_REGISTER_MAPPING_LIST {
9303     fn default() -> Self {
9304         unsafe { ::std::mem::zeroed() }
9305     }
9306 }
9307 #[cfg(feature = "Win32_Foundation")]
9308 impl ::std::fmt::Debug for SAM_REGISTER_MAPPING_LIST {
9309     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9310         fmt.debug_struct("SAM_REGISTER_MAPPING_LIST").field("Count", &self.Count).field("Elements", &self.Elements).finish()
9311     }
9312 }
9313 #[cfg(feature = "Win32_Foundation")]
9314 impl ::std::cmp::PartialEq for SAM_REGISTER_MAPPING_LIST {
9315     fn eq(&self, other: &Self) -> bool {
9316         self.Count == other.Count && self.Elements == other.Elements
9317     }
9318 }
9319 #[cfg(feature = "Win32_Foundation")]
9320 impl ::std::cmp::Eq for SAM_REGISTER_MAPPING_LIST {}
9321 #[cfg(feature = "Win32_Foundation")]
9322 unsafe impl ::windows::runtime::Abi for SAM_REGISTER_MAPPING_LIST {
9323     type Abi = Self;
9324     type DefaultType = Self;
9325 }
9326 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9327 #[repr(C)]
9328 #[cfg(feature = "Win32_Foundation")]
9329 pub struct SAM_REGISTER_MAPPING_TABLE {
9330     pub Count: u32,
9331     pub Lists: *mut SAM_REGISTER_MAPPING_LIST,
9332 }
9333 #[cfg(feature = "Win32_Foundation")]
9334 impl SAM_REGISTER_MAPPING_TABLE {}
9335 #[cfg(feature = "Win32_Foundation")]
9336 impl ::std::default::Default for SAM_REGISTER_MAPPING_TABLE {
9337     fn default() -> Self {
9338         unsafe { ::std::mem::zeroed() }
9339     }
9340 }
9341 #[cfg(feature = "Win32_Foundation")]
9342 impl ::std::fmt::Debug for SAM_REGISTER_MAPPING_TABLE {
9343     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9344         fmt.debug_struct("SAM_REGISTER_MAPPING_TABLE").field("Count", &self.Count).field("Lists", &self.Lists).finish()
9345     }
9346 }
9347 #[cfg(feature = "Win32_Foundation")]
9348 impl ::std::cmp::PartialEq for SAM_REGISTER_MAPPING_TABLE {
9349     fn eq(&self, other: &Self) -> bool {
9350         self.Count == other.Count && self.Lists == other.Lists
9351     }
9352 }
9353 #[cfg(feature = "Win32_Foundation")]
9354 impl ::std::cmp::Eq for SAM_REGISTER_MAPPING_TABLE {}
9355 #[cfg(feature = "Win32_Foundation")]
9356 unsafe impl ::windows::runtime::Abi for SAM_REGISTER_MAPPING_TABLE {
9357     type Abi = Self;
9358     type DefaultType = Self;
9359 }
9360 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9361 #[repr(transparent)]
9362 pub struct SASL_AUTHZID_STATE(pub i32);
9363 pub const Sasl_AuthZIDForbidden: SASL_AUTHZID_STATE = SASL_AUTHZID_STATE(0i32);
9364 pub const Sasl_AuthZIDProcessed: SASL_AUTHZID_STATE = SASL_AUTHZID_STATE(1i32);
9365 impl ::std::convert::From<i32> for SASL_AUTHZID_STATE {
9366     fn from(value: i32) -> Self {
9367         Self(value)
9368     }
9369 }
9370 unsafe impl ::windows::runtime::Abi for SASL_AUTHZID_STATE {
9371     type Abi = Self;
9372     type DefaultType = Self;
9373 }
9374 pub const SASL_OPTION_AUTHZ_PROCESSING: u32 = 4u32;
9375 pub const SASL_OPTION_AUTHZ_STRING: u32 = 3u32;
9376 pub const SASL_OPTION_RECV_SIZE: u32 = 2u32;
9377 pub const SASL_OPTION_SEND_SIZE: u32 = 1u32;
9378 pub const SCHANNEL_ALERT: u32 = 2u32;
9379 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9380 #[repr(C)]
9381 pub struct SCHANNEL_ALERT_TOKEN {
9382     pub dwTokenType: u32,
9383     pub dwAlertType: SCHANNEL_ALERT_TOKEN_ALERT_TYPE,
9384     pub dwAlertNumber: u32,
9385 }
9386 impl SCHANNEL_ALERT_TOKEN {}
9387 impl ::std::default::Default for SCHANNEL_ALERT_TOKEN {
9388     fn default() -> Self {
9389         unsafe { ::std::mem::zeroed() }
9390     }
9391 }
9392 impl ::std::fmt::Debug for SCHANNEL_ALERT_TOKEN {
9393     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9394         fmt.debug_struct("SCHANNEL_ALERT_TOKEN").field("dwTokenType", &self.dwTokenType).field("dwAlertType", &self.dwAlertType).field("dwAlertNumber", &self.dwAlertNumber).finish()
9395     }
9396 }
9397 impl ::std::cmp::PartialEq for SCHANNEL_ALERT_TOKEN {
9398     fn eq(&self, other: &Self) -> bool {
9399         self.dwTokenType == other.dwTokenType && self.dwAlertType == other.dwAlertType && self.dwAlertNumber == other.dwAlertNumber
9400     }
9401 }
9402 impl ::std::cmp::Eq for SCHANNEL_ALERT_TOKEN {}
9403 unsafe impl ::windows::runtime::Abi for SCHANNEL_ALERT_TOKEN {
9404     type Abi = Self;
9405     type DefaultType = Self;
9406 }
9407 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9408 #[repr(transparent)]
9409 pub struct SCHANNEL_ALERT_TOKEN_ALERT_TYPE(pub u32);
9410 pub const TLS1_ALERT_WARNING: SCHANNEL_ALERT_TOKEN_ALERT_TYPE = SCHANNEL_ALERT_TOKEN_ALERT_TYPE(1u32);
9411 pub const TLS1_ALERT_FATAL: SCHANNEL_ALERT_TOKEN_ALERT_TYPE = SCHANNEL_ALERT_TOKEN_ALERT_TYPE(2u32);
9412 impl ::std::convert::From<u32> for SCHANNEL_ALERT_TOKEN_ALERT_TYPE {
9413     fn from(value: u32) -> Self {
9414         Self(value)
9415     }
9416 }
9417 unsafe impl ::windows::runtime::Abi for SCHANNEL_ALERT_TOKEN_ALERT_TYPE {
9418     type Abi = Self;
9419     type DefaultType = Self;
9420 }
9421 impl ::std::ops::BitOr for SCHANNEL_ALERT_TOKEN_ALERT_TYPE {
9422     type Output = Self;
9423     fn bitor(self, rhs: Self) -> Self {
9424         Self(self.0 | rhs.0)
9425     }
9426 }
9427 impl ::std::ops::BitAnd for SCHANNEL_ALERT_TOKEN_ALERT_TYPE {
9428     type Output = Self;
9429     fn bitand(self, rhs: Self) -> Self {
9430         Self(self.0 & rhs.0)
9431     }
9432 }
9433 impl ::std::ops::BitOrAssign for SCHANNEL_ALERT_TOKEN_ALERT_TYPE {
9434     fn bitor_assign(&mut self, rhs: Self) {
9435         self.0.bitor_assign(rhs.0)
9436     }
9437 }
9438 impl ::std::ops::BitAndAssign for SCHANNEL_ALERT_TOKEN_ALERT_TYPE {
9439     fn bitand_assign(&mut self, rhs: Self) {
9440         self.0.bitand_assign(rhs.0)
9441     }
9442 }
9443 impl ::std::ops::Not for SCHANNEL_ALERT_TOKEN_ALERT_TYPE {
9444     type Output = Self;
9445     fn not(self) -> Self {
9446         Self(self.0.not())
9447     }
9448 }
9449 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9450 #[repr(C)]
9451 pub struct SCHANNEL_CERT_HASH {
9452     pub dwLength: u32,
9453     pub dwFlags: u32,
9454     pub hProv: usize,
9455     pub ShaHash: [u8; 20],
9456 }
9457 impl SCHANNEL_CERT_HASH {}
9458 impl ::std::default::Default for SCHANNEL_CERT_HASH {
9459     fn default() -> Self {
9460         unsafe { ::std::mem::zeroed() }
9461     }
9462 }
9463 impl ::std::fmt::Debug for SCHANNEL_CERT_HASH {
9464     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9465         fmt.debug_struct("SCHANNEL_CERT_HASH").field("dwLength", &self.dwLength).field("dwFlags", &self.dwFlags).field("hProv", &self.hProv).field("ShaHash", &self.ShaHash).finish()
9466     }
9467 }
9468 impl ::std::cmp::PartialEq for SCHANNEL_CERT_HASH {
9469     fn eq(&self, other: &Self) -> bool {
9470         self.dwLength == other.dwLength && self.dwFlags == other.dwFlags && self.hProv == other.hProv && self.ShaHash == other.ShaHash
9471     }
9472 }
9473 impl ::std::cmp::Eq for SCHANNEL_CERT_HASH {}
9474 unsafe impl ::windows::runtime::Abi for SCHANNEL_CERT_HASH {
9475     type Abi = Self;
9476     type DefaultType = Self;
9477 }
9478 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9479 #[repr(C)]
9480 pub struct SCHANNEL_CERT_HASH_STORE {
9481     pub dwLength: u32,
9482     pub dwFlags: u32,
9483     pub hProv: usize,
9484     pub ShaHash: [u8; 20],
9485     pub pwszStoreName: [u16; 128],
9486 }
9487 impl SCHANNEL_CERT_HASH_STORE {}
9488 impl ::std::default::Default for SCHANNEL_CERT_HASH_STORE {
9489     fn default() -> Self {
9490         unsafe { ::std::mem::zeroed() }
9491     }
9492 }
9493 impl ::std::fmt::Debug for SCHANNEL_CERT_HASH_STORE {
9494     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9495         fmt.debug_struct("SCHANNEL_CERT_HASH_STORE").field("dwLength", &self.dwLength).field("dwFlags", &self.dwFlags).field("hProv", &self.hProv).field("ShaHash", &self.ShaHash).field("pwszStoreName", &self.pwszStoreName).finish()
9496     }
9497 }
9498 impl ::std::cmp::PartialEq for SCHANNEL_CERT_HASH_STORE {
9499     fn eq(&self, other: &Self) -> bool {
9500         self.dwLength == other.dwLength && self.dwFlags == other.dwFlags && self.hProv == other.hProv && self.ShaHash == other.ShaHash && self.pwszStoreName == other.pwszStoreName
9501     }
9502 }
9503 impl ::std::cmp::Eq for SCHANNEL_CERT_HASH_STORE {}
9504 unsafe impl ::windows::runtime::Abi for SCHANNEL_CERT_HASH_STORE {
9505     type Abi = Self;
9506     type DefaultType = Self;
9507 }
9508 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9509 #[repr(C)]
9510 pub struct SCHANNEL_CLIENT_SIGNATURE {
9511     pub cbLength: u32,
9512     pub aiHash: u32,
9513     pub cbHash: u32,
9514     pub HashValue: [u8; 36],
9515     pub CertThumbprint: [u8; 20],
9516 }
9517 impl SCHANNEL_CLIENT_SIGNATURE {}
9518 impl ::std::default::Default for SCHANNEL_CLIENT_SIGNATURE {
9519     fn default() -> Self {
9520         unsafe { ::std::mem::zeroed() }
9521     }
9522 }
9523 impl ::std::fmt::Debug for SCHANNEL_CLIENT_SIGNATURE {
9524     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9525         fmt.debug_struct("SCHANNEL_CLIENT_SIGNATURE").field("cbLength", &self.cbLength).field("aiHash", &self.aiHash).field("cbHash", &self.cbHash).field("HashValue", &self.HashValue).field("CertThumbprint", &self.CertThumbprint).finish()
9526     }
9527 }
9528 impl ::std::cmp::PartialEq for SCHANNEL_CLIENT_SIGNATURE {
9529     fn eq(&self, other: &Self) -> bool {
9530         self.cbLength == other.cbLength && self.aiHash == other.aiHash && self.cbHash == other.cbHash && self.HashValue == other.HashValue && self.CertThumbprint == other.CertThumbprint
9531     }
9532 }
9533 impl ::std::cmp::Eq for SCHANNEL_CLIENT_SIGNATURE {}
9534 unsafe impl ::windows::runtime::Abi for SCHANNEL_CLIENT_SIGNATURE {
9535     type Abi = Self;
9536     type DefaultType = Self;
9537 }
9538 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9539 #[repr(C)]
9540 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
9541 pub struct SCHANNEL_CRED {
9542     pub dwVersion: u32,
9543     pub cCreds: u32,
9544     pub paCred: *mut *mut super::super::Cryptography::CERT_CONTEXT,
9545     pub hRootStore: *mut ::std::ffi::c_void,
9546     pub cMappers: u32,
9547     pub aphMappers: *mut *mut _HMAPPER,
9548     pub cSupportedAlgs: u32,
9549     pub palgSupportedAlgs: *mut u32,
9550     pub grbitEnabledProtocols: u32,
9551     pub dwMinimumCipherStrength: u32,
9552     pub dwMaximumCipherStrength: u32,
9553     pub dwSessionLifespan: u32,
9554     pub dwFlags: SCHANNEL_CRED_FLAGS,
9555     pub dwCredFormat: u32,
9556 }
9557 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
9558 impl SCHANNEL_CRED {}
9559 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
9560 impl ::std::default::Default for SCHANNEL_CRED {
9561     fn default() -> Self {
9562         unsafe { ::std::mem::zeroed() }
9563     }
9564 }
9565 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
9566 impl ::std::fmt::Debug for SCHANNEL_CRED {
9567     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9568         fmt.debug_struct("SCHANNEL_CRED")
9569             .field("dwVersion", &self.dwVersion)
9570             .field("cCreds", &self.cCreds)
9571             .field("paCred", &self.paCred)
9572             .field("hRootStore", &self.hRootStore)
9573             .field("cMappers", &self.cMappers)
9574             .field("aphMappers", &self.aphMappers)
9575             .field("cSupportedAlgs", &self.cSupportedAlgs)
9576             .field("palgSupportedAlgs", &self.palgSupportedAlgs)
9577             .field("grbitEnabledProtocols", &self.grbitEnabledProtocols)
9578             .field("dwMinimumCipherStrength", &self.dwMinimumCipherStrength)
9579             .field("dwMaximumCipherStrength", &self.dwMaximumCipherStrength)
9580             .field("dwSessionLifespan", &self.dwSessionLifespan)
9581             .field("dwFlags", &self.dwFlags)
9582             .field("dwCredFormat", &self.dwCredFormat)
9583             .finish()
9584     }
9585 }
9586 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
9587 impl ::std::cmp::PartialEq for SCHANNEL_CRED {
9588     fn eq(&self, other: &Self) -> bool {
9589         self.dwVersion == other.dwVersion
9590             && self.cCreds == other.cCreds
9591             && self.paCred == other.paCred
9592             && self.hRootStore == other.hRootStore
9593             && self.cMappers == other.cMappers
9594             && self.aphMappers == other.aphMappers
9595             && self.cSupportedAlgs == other.cSupportedAlgs
9596             && self.palgSupportedAlgs == other.palgSupportedAlgs
9597             && self.grbitEnabledProtocols == other.grbitEnabledProtocols
9598             && self.dwMinimumCipherStrength == other.dwMinimumCipherStrength
9599             && self.dwMaximumCipherStrength == other.dwMaximumCipherStrength
9600             && self.dwSessionLifespan == other.dwSessionLifespan
9601             && self.dwFlags == other.dwFlags
9602             && self.dwCredFormat == other.dwCredFormat
9603     }
9604 }
9605 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
9606 impl ::std::cmp::Eq for SCHANNEL_CRED {}
9607 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
9608 unsafe impl ::windows::runtime::Abi for SCHANNEL_CRED {
9609     type Abi = Self;
9610     type DefaultType = Self;
9611 }
9612 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9613 #[repr(transparent)]
9614 pub struct SCHANNEL_CRED_FLAGS(pub u32);
9615 pub const SCH_CRED_AUTO_CRED_VALIDATION: SCHANNEL_CRED_FLAGS = SCHANNEL_CRED_FLAGS(32u32);
9616 pub const SCH_CRED_CACHE_ONLY_URL_RETRIEVAL_ON_CREATE: SCHANNEL_CRED_FLAGS = SCHANNEL_CRED_FLAGS(131072u32);
9617 pub const SCH_DISABLE_RECONNECTS: SCHANNEL_CRED_FLAGS = SCHANNEL_CRED_FLAGS(128u32);
9618 pub const SCH_CRED_IGNORE_NO_REVOCATION_CHECK: SCHANNEL_CRED_FLAGS = SCHANNEL_CRED_FLAGS(2048u32);
9619 pub const SCH_CRED_IGNORE_REVOCATION_OFFLINE: SCHANNEL_CRED_FLAGS = SCHANNEL_CRED_FLAGS(4096u32);
9620 pub const SCH_CRED_MANUAL_CRED_VALIDATION: SCHANNEL_CRED_FLAGS = SCHANNEL_CRED_FLAGS(8u32);
9621 pub const SCH_CRED_NO_DEFAULT_CREDS: SCHANNEL_CRED_FLAGS = SCHANNEL_CRED_FLAGS(16u32);
9622 pub const SCH_CRED_NO_SERVERNAME_CHECK: SCHANNEL_CRED_FLAGS = SCHANNEL_CRED_FLAGS(4u32);
9623 pub const SCH_CRED_NO_SYSTEM_MAPPER: SCHANNEL_CRED_FLAGS = SCHANNEL_CRED_FLAGS(2u32);
9624 pub const SCH_CRED_REVOCATION_CHECK_CHAIN: SCHANNEL_CRED_FLAGS = SCHANNEL_CRED_FLAGS(512u32);
9625 pub const SCH_CRED_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT: SCHANNEL_CRED_FLAGS = SCHANNEL_CRED_FLAGS(1024u32);
9626 pub const SCH_CRED_REVOCATION_CHECK_END_CERT: SCHANNEL_CRED_FLAGS = SCHANNEL_CRED_FLAGS(256u32);
9627 pub const SCH_CRED_USE_DEFAULT_CREDS: SCHANNEL_CRED_FLAGS = SCHANNEL_CRED_FLAGS(64u32);
9628 pub const SCH_SEND_AUX_RECORD: SCHANNEL_CRED_FLAGS = SCHANNEL_CRED_FLAGS(2097152u32);
9629 pub const SCH_SEND_ROOT_CERT: SCHANNEL_CRED_FLAGS = SCHANNEL_CRED_FLAGS(262144u32);
9630 pub const SCH_USE_STRONG_CRYPTO: SCHANNEL_CRED_FLAGS = SCHANNEL_CRED_FLAGS(4194304u32);
9631 pub const SCH_USE_PRESHAREDKEY_ONLY: SCHANNEL_CRED_FLAGS = SCHANNEL_CRED_FLAGS(8388608u32);
9632 impl ::std::convert::From<u32> for SCHANNEL_CRED_FLAGS {
9633     fn from(value: u32) -> Self {
9634         Self(value)
9635     }
9636 }
9637 unsafe impl ::windows::runtime::Abi for SCHANNEL_CRED_FLAGS {
9638     type Abi = Self;
9639     type DefaultType = Self;
9640 }
9641 impl ::std::ops::BitOr for SCHANNEL_CRED_FLAGS {
9642     type Output = Self;
9643     fn bitor(self, rhs: Self) -> Self {
9644         Self(self.0 | rhs.0)
9645     }
9646 }
9647 impl ::std::ops::BitAnd for SCHANNEL_CRED_FLAGS {
9648     type Output = Self;
9649     fn bitand(self, rhs: Self) -> Self {
9650         Self(self.0 & rhs.0)
9651     }
9652 }
9653 impl ::std::ops::BitOrAssign for SCHANNEL_CRED_FLAGS {
9654     fn bitor_assign(&mut self, rhs: Self) {
9655         self.0.bitor_assign(rhs.0)
9656     }
9657 }
9658 impl ::std::ops::BitAndAssign for SCHANNEL_CRED_FLAGS {
9659     fn bitand_assign(&mut self, rhs: Self) {
9660         self.0.bitand_assign(rhs.0)
9661     }
9662 }
9663 impl ::std::ops::Not for SCHANNEL_CRED_FLAGS {
9664     type Output = Self;
9665     fn not(self) -> Self {
9666         Self(self.0.not())
9667     }
9668 }
9669 pub const SCHANNEL_CRED_VERSION: u32 = 4u32;
9670 pub const SCHANNEL_RENEGOTIATE: u32 = 0u32;
9671 pub const SCHANNEL_SECRET_PRIVKEY: u32 = 2u32;
9672 pub const SCHANNEL_SECRET_TYPE_CAPI: u32 = 1u32;
9673 pub const SCHANNEL_SESSION: u32 = 3u32;
9674 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9675 #[repr(C)]
9676 pub struct SCHANNEL_SESSION_TOKEN {
9677     pub dwTokenType: u32,
9678     pub dwFlags: SCHANNEL_SESSION_TOKEN_FLAGS,
9679 }
9680 impl SCHANNEL_SESSION_TOKEN {}
9681 impl ::std::default::Default for SCHANNEL_SESSION_TOKEN {
9682     fn default() -> Self {
9683         unsafe { ::std::mem::zeroed() }
9684     }
9685 }
9686 impl ::std::fmt::Debug for SCHANNEL_SESSION_TOKEN {
9687     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9688         fmt.debug_struct("SCHANNEL_SESSION_TOKEN").field("dwTokenType", &self.dwTokenType).field("dwFlags", &self.dwFlags).finish()
9689     }
9690 }
9691 impl ::std::cmp::PartialEq for SCHANNEL_SESSION_TOKEN {
9692     fn eq(&self, other: &Self) -> bool {
9693         self.dwTokenType == other.dwTokenType && self.dwFlags == other.dwFlags
9694     }
9695 }
9696 impl ::std::cmp::Eq for SCHANNEL_SESSION_TOKEN {}
9697 unsafe impl ::windows::runtime::Abi for SCHANNEL_SESSION_TOKEN {
9698     type Abi = Self;
9699     type DefaultType = Self;
9700 }
9701 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9702 #[repr(transparent)]
9703 pub struct SCHANNEL_SESSION_TOKEN_FLAGS(pub u32);
9704 pub const SSL_SESSION_ENABLE_RECONNECTS: SCHANNEL_SESSION_TOKEN_FLAGS = SCHANNEL_SESSION_TOKEN_FLAGS(1u32);
9705 pub const SSL_SESSION_DISABLE_RECONNECTS: SCHANNEL_SESSION_TOKEN_FLAGS = SCHANNEL_SESSION_TOKEN_FLAGS(2u32);
9706 impl ::std::convert::From<u32> for SCHANNEL_SESSION_TOKEN_FLAGS {
9707     fn from(value: u32) -> Self {
9708         Self(value)
9709     }
9710 }
9711 unsafe impl ::windows::runtime::Abi for SCHANNEL_SESSION_TOKEN_FLAGS {
9712     type Abi = Self;
9713     type DefaultType = Self;
9714 }
9715 impl ::std::ops::BitOr for SCHANNEL_SESSION_TOKEN_FLAGS {
9716     type Output = Self;
9717     fn bitor(self, rhs: Self) -> Self {
9718         Self(self.0 | rhs.0)
9719     }
9720 }
9721 impl ::std::ops::BitAnd for SCHANNEL_SESSION_TOKEN_FLAGS {
9722     type Output = Self;
9723     fn bitand(self, rhs: Self) -> Self {
9724         Self(self.0 & rhs.0)
9725     }
9726 }
9727 impl ::std::ops::BitOrAssign for SCHANNEL_SESSION_TOKEN_FLAGS {
9728     fn bitor_assign(&mut self, rhs: Self) {
9729         self.0.bitor_assign(rhs.0)
9730     }
9731 }
9732 impl ::std::ops::BitAndAssign for SCHANNEL_SESSION_TOKEN_FLAGS {
9733     fn bitand_assign(&mut self, rhs: Self) {
9734         self.0.bitand_assign(rhs.0)
9735     }
9736 }
9737 impl ::std::ops::Not for SCHANNEL_SESSION_TOKEN_FLAGS {
9738     type Output = Self;
9739     fn not(self) -> Self {
9740         Self(self.0.not())
9741     }
9742 }
9743 pub const SCHANNEL_SHUTDOWN: u32 = 1u32;
9744 pub const SCH_ALLOW_NULL_ENCRYPTION: u32 = 33554432u32;
9745 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9746 #[repr(C)]
9747 pub struct SCH_CRED {
9748     pub dwVersion: u32,
9749     pub cCreds: u32,
9750     pub paSecret: *mut *mut ::std::ffi::c_void,
9751     pub paPublic: *mut *mut ::std::ffi::c_void,
9752     pub cMappers: u32,
9753     pub aphMappers: *mut *mut _HMAPPER,
9754 }
9755 impl SCH_CRED {}
9756 impl ::std::default::Default for SCH_CRED {
9757     fn default() -> Self {
9758         unsafe { ::std::mem::zeroed() }
9759     }
9760 }
9761 impl ::std::fmt::Debug for SCH_CRED {
9762     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9763         fmt.debug_struct("SCH_CRED").field("dwVersion", &self.dwVersion).field("cCreds", &self.cCreds).field("paSecret", &self.paSecret).field("paPublic", &self.paPublic).field("cMappers", &self.cMappers).field("aphMappers", &self.aphMappers).finish()
9764     }
9765 }
9766 impl ::std::cmp::PartialEq for SCH_CRED {
9767     fn eq(&self, other: &Self) -> bool {
9768         self.dwVersion == other.dwVersion && self.cCreds == other.cCreds && self.paSecret == other.paSecret && self.paPublic == other.paPublic && self.cMappers == other.cMappers && self.aphMappers == other.aphMappers
9769     }
9770 }
9771 impl ::std::cmp::Eq for SCH_CRED {}
9772 unsafe impl ::windows::runtime::Abi for SCH_CRED {
9773     type Abi = Self;
9774     type DefaultType = Self;
9775 }
9776 pub const SCH_CREDENTIALS_VERSION: u32 = 5u32;
9777 pub const SCH_CRED_CACHE_ONLY_URL_RETRIEVAL: u32 = 32768u32;
9778 pub const SCH_CRED_CERT_CONTEXT: u32 = 3u32;
9779 pub const SCH_CRED_DEFERRED_CRED_VALIDATION: u32 = 67108864u32;
9780 pub const SCH_CRED_DISABLE_RECONNECTS: u32 = 128u32;
9781 pub const SCH_CRED_FORMAT_CERT_CONTEXT: u32 = 0u32;
9782 pub const SCH_CRED_FORMAT_CERT_HASH: u32 = 1u32;
9783 pub const SCH_CRED_FORMAT_CERT_HASH_STORE: u32 = 2u32;
9784 pub const SCH_CRED_MAX_STORE_NAME_SIZE: u32 = 128u32;
9785 pub const SCH_CRED_MAX_SUPPORTED_ALGS: u32 = 256u32;
9786 pub const SCH_CRED_MAX_SUPPORTED_ALPN_IDS: u32 = 16u32;
9787 pub const SCH_CRED_MAX_SUPPORTED_CERTS: u32 = 100u32;
9788 pub const SCH_CRED_MAX_SUPPORTED_CHAINING_MODES: u32 = 16u32;
9789 pub const SCH_CRED_MAX_SUPPORTED_CRYPTO_SETTINGS: u32 = 16u32;
9790 pub const SCH_CRED_MAX_SUPPORTED_PARAMETERS: u32 = 16u32;
9791 pub const SCH_CRED_MEMORY_STORE_CERT: u32 = 65536u32;
9792 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9793 #[repr(C)]
9794 pub struct SCH_CRED_PUBLIC_CERTCHAIN {
9795     pub dwType: u32,
9796     pub cbCertChain: u32,
9797     pub pCertChain: *mut u8,
9798 }
9799 impl SCH_CRED_PUBLIC_CERTCHAIN {}
9800 impl ::std::default::Default for SCH_CRED_PUBLIC_CERTCHAIN {
9801     fn default() -> Self {
9802         unsafe { ::std::mem::zeroed() }
9803     }
9804 }
9805 impl ::std::fmt::Debug for SCH_CRED_PUBLIC_CERTCHAIN {
9806     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9807         fmt.debug_struct("SCH_CRED_PUBLIC_CERTCHAIN").field("dwType", &self.dwType).field("cbCertChain", &self.cbCertChain).field("pCertChain", &self.pCertChain).finish()
9808     }
9809 }
9810 impl ::std::cmp::PartialEq for SCH_CRED_PUBLIC_CERTCHAIN {
9811     fn eq(&self, other: &Self) -> bool {
9812         self.dwType == other.dwType && self.cbCertChain == other.cbCertChain && self.pCertChain == other.pCertChain
9813     }
9814 }
9815 impl ::std::cmp::Eq for SCH_CRED_PUBLIC_CERTCHAIN {}
9816 unsafe impl ::windows::runtime::Abi for SCH_CRED_PUBLIC_CERTCHAIN {
9817     type Abi = Self;
9818     type DefaultType = Self;
9819 }
9820 pub const SCH_CRED_RESTRICTED_ROOTS: u32 = 8192u32;
9821 pub const SCH_CRED_REVOCATION_CHECK_CACHE_ONLY: u32 = 16384u32;
9822 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9823 #[repr(C)]
9824 pub struct SCH_CRED_SECRET_CAPI {
9825     pub dwType: u32,
9826     pub hProv: usize,
9827 }
9828 impl SCH_CRED_SECRET_CAPI {}
9829 impl ::std::default::Default for SCH_CRED_SECRET_CAPI {
9830     fn default() -> Self {
9831         unsafe { ::std::mem::zeroed() }
9832     }
9833 }
9834 impl ::std::fmt::Debug for SCH_CRED_SECRET_CAPI {
9835     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9836         fmt.debug_struct("SCH_CRED_SECRET_CAPI").field("dwType", &self.dwType).field("hProv", &self.hProv).finish()
9837     }
9838 }
9839 impl ::std::cmp::PartialEq for SCH_CRED_SECRET_CAPI {
9840     fn eq(&self, other: &Self) -> bool {
9841         self.dwType == other.dwType && self.hProv == other.hProv
9842     }
9843 }
9844 impl ::std::cmp::Eq for SCH_CRED_SECRET_CAPI {}
9845 unsafe impl ::windows::runtime::Abi for SCH_CRED_SECRET_CAPI {
9846     type Abi = Self;
9847     type DefaultType = Self;
9848 }
9849 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9850 #[repr(C)]
9851 #[cfg(feature = "Win32_Foundation")]
9852 pub struct SCH_CRED_SECRET_PRIVKEY {
9853     pub dwType: u32,
9854     pub pPrivateKey: *mut u8,
9855     pub cbPrivateKey: u32,
9856     pub pszPassword: super::super::super::Foundation::PSTR,
9857 }
9858 #[cfg(feature = "Win32_Foundation")]
9859 impl SCH_CRED_SECRET_PRIVKEY {}
9860 #[cfg(feature = "Win32_Foundation")]
9861 impl ::std::default::Default for SCH_CRED_SECRET_PRIVKEY {
9862     fn default() -> Self {
9863         unsafe { ::std::mem::zeroed() }
9864     }
9865 }
9866 #[cfg(feature = "Win32_Foundation")]
9867 impl ::std::fmt::Debug for SCH_CRED_SECRET_PRIVKEY {
9868     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9869         fmt.debug_struct("SCH_CRED_SECRET_PRIVKEY").field("dwType", &self.dwType).field("pPrivateKey", &self.pPrivateKey).field("cbPrivateKey", &self.cbPrivateKey).field("pszPassword", &self.pszPassword).finish()
9870     }
9871 }
9872 #[cfg(feature = "Win32_Foundation")]
9873 impl ::std::cmp::PartialEq for SCH_CRED_SECRET_PRIVKEY {
9874     fn eq(&self, other: &Self) -> bool {
9875         self.dwType == other.dwType && self.pPrivateKey == other.pPrivateKey && self.cbPrivateKey == other.cbPrivateKey && self.pszPassword == other.pszPassword
9876     }
9877 }
9878 #[cfg(feature = "Win32_Foundation")]
9879 impl ::std::cmp::Eq for SCH_CRED_SECRET_PRIVKEY {}
9880 #[cfg(feature = "Win32_Foundation")]
9881 unsafe impl ::windows::runtime::Abi for SCH_CRED_SECRET_PRIVKEY {
9882     type Abi = Self;
9883     type DefaultType = Self;
9884 }
9885 pub const SCH_CRED_SNI_CREDENTIAL: u32 = 524288u32;
9886 pub const SCH_CRED_SNI_ENABLE_OCSP: u32 = 1048576u32;
9887 pub const SCH_CRED_V1: u32 = 1u32;
9888 pub const SCH_CRED_V2: u32 = 2u32;
9889 pub const SCH_CRED_V3: u32 = 3u32;
9890 pub const SCH_CRED_VERSION: u32 = 2u32;
9891 pub const SCH_CRED_X509_CAPI: u32 = 2u32;
9892 pub const SCH_CRED_X509_CERTCHAIN: u32 = 1u32;
9893 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9894 #[repr(C)]
9895 pub struct SCH_EXTENSION_DATA {
9896     pub ExtensionType: u16,
9897     pub pExtData: *mut u8,
9898     pub cbExtData: u32,
9899 }
9900 impl SCH_EXTENSION_DATA {}
9901 impl ::std::default::Default for SCH_EXTENSION_DATA {
9902     fn default() -> Self {
9903         unsafe { ::std::mem::zeroed() }
9904     }
9905 }
9906 impl ::std::fmt::Debug for SCH_EXTENSION_DATA {
9907     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9908         fmt.debug_struct("SCH_EXTENSION_DATA").field("ExtensionType", &self.ExtensionType).field("pExtData", &self.pExtData).field("cbExtData", &self.cbExtData).finish()
9909     }
9910 }
9911 impl ::std::cmp::PartialEq for SCH_EXTENSION_DATA {
9912     fn eq(&self, other: &Self) -> bool {
9913         self.ExtensionType == other.ExtensionType && self.pExtData == other.pExtData && self.cbExtData == other.cbExtData
9914     }
9915 }
9916 impl ::std::cmp::Eq for SCH_EXTENSION_DATA {}
9917 unsafe impl ::windows::runtime::Abi for SCH_EXTENSION_DATA {
9918     type Abi = Self;
9919     type DefaultType = Self;
9920 }
9921 pub const SCH_MACHINE_CERT_HASH: u32 = 1u32;
9922 pub const SCH_MAX_EXT_SUBSCRIPTIONS: u32 = 2u32;
9923 pub const SCH_USE_DTLS_ONLY: u32 = 16777216u32;
9924 pub const SECBUFFER_ALERT: u32 = 17u32;
9925 pub const SECBUFFER_APPLICATION_PROTOCOLS: u32 = 18u32;
9926 pub const SECBUFFER_ATTRMASK: u32 = 4026531840u32;
9927 pub const SECBUFFER_CHANGE_PASS_RESPONSE: u32 = 15u32;
9928 pub const SECBUFFER_CHANNEL_BINDINGS: u32 = 14u32;
9929 pub const SECBUFFER_DATA: u32 = 1u32;
9930 pub const SECBUFFER_DTLS_MTU: u32 = 24u32;
9931 pub const SECBUFFER_EMPTY: u32 = 0u32;
9932 pub const SECBUFFER_EXTRA: u32 = 5u32;
9933 pub const SECBUFFER_FLAGS: u32 = 27u32;
9934 pub const SECBUFFER_KERNEL_MAP: u32 = 536870912u32;
9935 pub const SECBUFFER_MECHLIST: u32 = 11u32;
9936 pub const SECBUFFER_MECHLIST_SIGNATURE: u32 = 12u32;
9937 pub const SECBUFFER_MISSING: u32 = 4u32;
9938 pub const SECBUFFER_NEGOTIATION_INFO: u32 = 8u32;
9939 pub const SECBUFFER_PADDING: u32 = 9u32;
9940 pub const SECBUFFER_PKG_PARAMS: u32 = 3u32;
9941 pub const SECBUFFER_PRESHARED_KEY: u32 = 22u32;
9942 pub const SECBUFFER_PRESHARED_KEY_IDENTITY: u32 = 23u32;
9943 pub const SECBUFFER_READONLY: u32 = 2147483648u32;
9944 pub const SECBUFFER_READONLY_WITH_CHECKSUM: u32 = 268435456u32;
9945 pub const SECBUFFER_RESERVED: u32 = 1610612736u32;
9946 pub const SECBUFFER_SEND_GENERIC_TLS_EXTENSION: u32 = 25u32;
9947 pub const SECBUFFER_SRTP_MASTER_KEY_IDENTIFIER: u32 = 20u32;
9948 pub const SECBUFFER_SRTP_PROTECTION_PROFILES: u32 = 19u32;
9949 pub const SECBUFFER_STREAM: u32 = 10u32;
9950 pub const SECBUFFER_STREAM_HEADER: u32 = 7u32;
9951 pub const SECBUFFER_STREAM_TRAILER: u32 = 6u32;
9952 pub const SECBUFFER_SUBSCRIBE_GENERIC_TLS_EXTENSION: u32 = 26u32;
9953 pub const SECBUFFER_TARGET: u32 = 13u32;
9954 pub const SECBUFFER_TARGET_HOST: u32 = 16u32;
9955 pub const SECBUFFER_TOKEN: u32 = 2u32;
9956 pub const SECBUFFER_TOKEN_BINDING: u32 = 21u32;
9957 pub const SECBUFFER_TRAFFIC_SECRETS: u32 = 28u32;
9958 pub const SECBUFFER_UNMAPPED: u32 = 1073741824u32;
9959 pub const SECBUFFER_VERSION: u32 = 0u32;
9960 pub const SECPKGCONTEXT_CIPHERINFO_V1: u32 = 1u32;
9961 pub const SECPKGCONTEXT_CONNECTION_INFO_EX_V1: u32 = 1u32;
9962 pub const SECPKG_ANSI_ATTRIBUTE: u32 = 0u32;
9963 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9964 #[repr(C)]
9965 #[cfg(feature = "Win32_Foundation")]
9966 pub struct SECPKG_APP_MODE_INFO {
9967     pub UserFunction: u32,
9968     pub Argument1: usize,
9969     pub Argument2: usize,
9970     pub UserData: SecBuffer,
9971     pub ReturnToLsa: super::super::super::Foundation::BOOLEAN,
9972 }
9973 #[cfg(feature = "Win32_Foundation")]
9974 impl SECPKG_APP_MODE_INFO {}
9975 #[cfg(feature = "Win32_Foundation")]
9976 impl ::std::default::Default for SECPKG_APP_MODE_INFO {
9977     fn default() -> Self {
9978         unsafe { ::std::mem::zeroed() }
9979     }
9980 }
9981 #[cfg(feature = "Win32_Foundation")]
9982 impl ::std::fmt::Debug for SECPKG_APP_MODE_INFO {
9983     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9984         fmt.debug_struct("SECPKG_APP_MODE_INFO").field("UserFunction", &self.UserFunction).field("Argument1", &self.Argument1).field("Argument2", &self.Argument2).field("UserData", &self.UserData).field("ReturnToLsa", &self.ReturnToLsa).finish()
9985     }
9986 }
9987 #[cfg(feature = "Win32_Foundation")]
9988 impl ::std::cmp::PartialEq for SECPKG_APP_MODE_INFO {
9989     fn eq(&self, other: &Self) -> bool {
9990         self.UserFunction == other.UserFunction && self.Argument1 == other.Argument1 && self.Argument2 == other.Argument2 && self.UserData == other.UserData && self.ReturnToLsa == other.ReturnToLsa
9991     }
9992 }
9993 #[cfg(feature = "Win32_Foundation")]
9994 impl ::std::cmp::Eq for SECPKG_APP_MODE_INFO {}
9995 #[cfg(feature = "Win32_Foundation")]
9996 unsafe impl ::windows::runtime::Abi for SECPKG_APP_MODE_INFO {
9997     type Abi = Self;
9998     type DefaultType = Self;
9999 }
10000 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10001 #[repr(transparent)]
10002 pub struct SECPKG_ATTR(pub u32);
10003 pub const SECPKG_ATTR_C_ACCESS_TOKEN: SECPKG_ATTR = SECPKG_ATTR(2147483666u32);
10004 pub const SECPKG_ATTR_C_FULL_ACCESS_TOKEN: SECPKG_ATTR = SECPKG_ATTR(2147483778u32);
10005 pub const SECPKG_ATTR_CERT_TRUST_STATUS: SECPKG_ATTR = SECPKG_ATTR(2147483780u32);
10006 pub const SECPKG_ATTR_CREDS: SECPKG_ATTR = SECPKG_ATTR(2147483776u32);
10007 pub const SECPKG_ATTR_CREDS_2: SECPKG_ATTR = SECPKG_ATTR(2147483782u32);
10008 pub const SECPKG_ATTR_NEGOTIATION_PACKAGE: SECPKG_ATTR = SECPKG_ATTR(2147483777u32);
10009 pub const SECPKG_ATTR_PACKAGE_INFO: SECPKG_ATTR = SECPKG_ATTR(10u32);
10010 pub const SECPKG_ATTR_SERVER_AUTH_FLAGS: SECPKG_ATTR = SECPKG_ATTR(2147483779u32);
10011 pub const SECPKG_ATTR_SIZES: SECPKG_ATTR = SECPKG_ATTR(0u32);
10012 pub const SECPKG_ATTR_SUBJECT_SECURITY_ATTRIBUTES: SECPKG_ATTR = SECPKG_ATTR(124u32);
10013 pub const SECPKG_ATTR_APP_DATA: SECPKG_ATTR = SECPKG_ATTR(94u32);
10014 pub const SECPKG_ATTR_EAP_PRF_INFO: SECPKG_ATTR = SECPKG_ATTR(101u32);
10015 pub const SECPKG_ATTR_EARLY_START: SECPKG_ATTR = SECPKG_ATTR(105u32);
10016 pub const SECPKG_ATTR_DTLS_MTU: SECPKG_ATTR = SECPKG_ATTR(34u32);
10017 pub const SECPKG_ATTR_KEYING_MATERIAL_INFO: SECPKG_ATTR = SECPKG_ATTR(106u32);
10018 pub const SECPKG_ATTR_ACCESS_TOKEN: SECPKG_ATTR = SECPKG_ATTR(18u32);
10019 pub const SECPKG_ATTR_AUTHORITY: SECPKG_ATTR = SECPKG_ATTR(6u32);
10020 pub const SECPKG_ATTR_CLIENT_SPECIFIED_TARGET: SECPKG_ATTR = SECPKG_ATTR(27u32);
10021 pub const SECPKG_ATTR_CONNECTION_INFO: SECPKG_ATTR = SECPKG_ATTR(90u32);
10022 pub const SECPKG_ATTR_DCE_INFO: SECPKG_ATTR = SECPKG_ATTR(3u32);
10023 pub const SECPKG_ATTR_ENDPOINT_BINDINGS: SECPKG_ATTR = SECPKG_ATTR(26u32);
10024 pub const SECPKG_ATTR_EAP_KEY_BLOCK: SECPKG_ATTR = SECPKG_ATTR(91u32);
10025 pub const SECPKG_ATTR_FLAGS: SECPKG_ATTR = SECPKG_ATTR(14u32);
10026 pub const SECPKG_ATTR_ISSUER_LIST_EX: SECPKG_ATTR = SECPKG_ATTR(89u32);
10027 pub const SECPKG_ATTR_KEY_INFO: SECPKG_ATTR = SECPKG_ATTR(5u32);
10028 pub const SECPKG_ATTR_LAST_CLIENT_TOKEN_STATUS: SECPKG_ATTR = SECPKG_ATTR(30u32);
10029 pub const SECPKG_ATTR_LIFESPAN: SECPKG_ATTR = SECPKG_ATTR(2u32);
10030 pub const SECPKG_ATTR_LOCAL_CERT_CONTEXT: SECPKG_ATTR = SECPKG_ATTR(84u32);
10031 pub const SECPKG_ATTR_LOCAL_CRED: SECPKG_ATTR = SECPKG_ATTR(82u32);
10032 pub const SECPKG_ATTR_NAMES: SECPKG_ATTR = SECPKG_ATTR(1u32);
10033 pub const SECPKG_ATTR_NATIVE_NAMES: SECPKG_ATTR = SECPKG_ATTR(13u32);
10034 pub const SECPKG_ATTR_NEGOTIATION_INFO: SECPKG_ATTR = SECPKG_ATTR(12u32);
10035 pub const SECPKG_ATTR_PASSWORD_EXPIRY: SECPKG_ATTR = SECPKG_ATTR(8u32);
10036 pub const SECPKG_ATTR_REMOTE_CERT_CONTEXT: SECPKG_ATTR = SECPKG_ATTR(83u32);
10037 pub const SECPKG_ATTR_ROOT_STORE: SECPKG_ATTR = SECPKG_ATTR(85u32);
10038 pub const SECPKG_ATTR_SESSION_KEY: SECPKG_ATTR = SECPKG_ATTR(9u32);
10039 pub const SECPKG_ATTR_SESSION_INFO: SECPKG_ATTR = SECPKG_ATTR(93u32);
10040 pub const SECPKG_ATTR_STREAM_SIZES: SECPKG_ATTR = SECPKG_ATTR(4u32);
10041 pub const SECPKG_ATTR_SUPPORTED_SIGNATURES: SECPKG_ATTR = SECPKG_ATTR(102u32);
10042 pub const SECPKG_ATTR_TARGET_INFORMATION: SECPKG_ATTR = SECPKG_ATTR(17u32);
10043 pub const SECPKG_ATTR_UNIQUE_BINDINGS: SECPKG_ATTR = SECPKG_ATTR(25u32);
10044 impl ::std::convert::From<u32> for SECPKG_ATTR {
10045     fn from(value: u32) -> Self {
10046         Self(value)
10047     }
10048 }
10049 unsafe impl ::windows::runtime::Abi for SECPKG_ATTR {
10050     type Abi = Self;
10051     type DefaultType = Self;
10052 }
10053 impl ::std::ops::BitOr for SECPKG_ATTR {
10054     type Output = Self;
10055     fn bitor(self, rhs: Self) -> Self {
10056         Self(self.0 | rhs.0)
10057     }
10058 }
10059 impl ::std::ops::BitAnd for SECPKG_ATTR {
10060     type Output = Self;
10061     fn bitand(self, rhs: Self) -> Self {
10062         Self(self.0 & rhs.0)
10063     }
10064 }
10065 impl ::std::ops::BitOrAssign for SECPKG_ATTR {
10066     fn bitor_assign(&mut self, rhs: Self) {
10067         self.0.bitor_assign(rhs.0)
10068     }
10069 }
10070 impl ::std::ops::BitAndAssign for SECPKG_ATTR {
10071     fn bitand_assign(&mut self, rhs: Self) {
10072         self.0.bitand_assign(rhs.0)
10073     }
10074 }
10075 impl ::std::ops::Not for SECPKG_ATTR {
10076     type Output = Self;
10077     fn not(self) -> Self {
10078         Self(self.0.not())
10079     }
10080 }
10081 pub const SECPKG_ATTR_APPLICATION_PROTOCOL: u32 = 35u32;
10082 pub const SECPKG_ATTR_AUTHENTICATION_ID: u32 = 20u32;
10083 pub const SECPKG_ATTR_CC_POLICY_RESULT: u32 = 97u32;
10084 pub const SECPKG_ATTR_CERT_CHECK_RESULT: u32 = 113u32;
10085 pub const SECPKG_ATTR_CERT_CHECK_RESULT_INPROC: u32 = 114u32;
10086 pub const SECPKG_ATTR_CIPHER_INFO: u32 = 100u32;
10087 pub const SECPKG_ATTR_CIPHER_STRENGTHS: u32 = 87u32;
10088 pub const SECPKG_ATTR_CLIENT_CERT_POLICY: u32 = 96u32;
10089 pub const SECPKG_ATTR_CONNECTION_INFO_EX: u32 = 110u32;
10090 pub const SECPKG_ATTR_CONTEXT_DELETED: u32 = 33u32;
10091 pub const SECPKG_ATTR_CREDENTIAL_NAME: u32 = 16u32;
10092 pub const SECPKG_ATTR_ISSUER_LIST: u32 = 80u32;
10093 pub const SECPKG_ATTR_IS_LOOPBACK: u32 = 37u32;
10094 pub const SECPKG_ATTR_KEYING_MATERIAL: u32 = 107u32;
10095 pub const SECPKG_ATTR_KEYING_MATERIAL_INPROC: u32 = 112u32;
10096 pub const SECPKG_ATTR_KEYING_MATERIAL_TOKEN_BINDING: u32 = 111u32;
10097 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10098 #[repr(transparent)]
10099 pub struct SECPKG_ATTR_LCT_STATUS(pub i32);
10100 pub const SecPkgAttrLastClientTokenYes: SECPKG_ATTR_LCT_STATUS = SECPKG_ATTR_LCT_STATUS(0i32);
10101 pub const SecPkgAttrLastClientTokenNo: SECPKG_ATTR_LCT_STATUS = SECPKG_ATTR_LCT_STATUS(1i32);
10102 pub const SecPkgAttrLastClientTokenMaybe: SECPKG_ATTR_LCT_STATUS = SECPKG_ATTR_LCT_STATUS(2i32);
10103 impl ::std::convert::From<i32> for SECPKG_ATTR_LCT_STATUS {
10104     fn from(value: i32) -> Self {
10105         Self(value)
10106     }
10107 }
10108 unsafe impl ::windows::runtime::Abi for SECPKG_ATTR_LCT_STATUS {
10109     type Abi = Self;
10110     type DefaultType = Self;
10111 }
10112 pub const SECPKG_ATTR_LOCAL_CERT_INFO: u32 = 99u32;
10113 pub const SECPKG_ATTR_LOGOFF_TIME: u32 = 21u32;
10114 pub const SECPKG_ATTR_MAPPED_CRED_ATTR: u32 = 92u32;
10115 pub const SECPKG_ATTR_NEGOTIATED_TLS_EXTENSIONS: u32 = 36u32;
10116 pub const SECPKG_ATTR_NEGO_INFO_FLAG_NO_KERBEROS: u32 = 1u32;
10117 pub const SECPKG_ATTR_NEGO_INFO_FLAG_NO_NTLM: u32 = 2u32;
10118 pub const SECPKG_ATTR_NEGO_KEYS: u32 = 22u32;
10119 pub const SECPKG_ATTR_NEGO_PKG_INFO: u32 = 31u32;
10120 pub const SECPKG_ATTR_NEGO_STATUS: u32 = 32u32;
10121 pub const SECPKG_ATTR_PROMPTING_NEEDED: u32 = 24u32;
10122 pub const SECPKG_ATTR_PROTO_INFO: u32 = 7u32;
10123 pub const SECPKG_ATTR_REMOTE_CERTIFICATES: u32 = 95u32;
10124 pub const SECPKG_ATTR_REMOTE_CERT_CHAIN: u32 = 103u32;
10125 pub const SECPKG_ATTR_REMOTE_CRED: u32 = 81u32;
10126 pub const SECPKG_ATTR_SASL_CONTEXT: u32 = 65536u32;
10127 pub const SECPKG_ATTR_SESSION_TICKET_KEYS: u32 = 115u32;
10128 pub const SECPKG_ATTR_SRTP_PARAMETERS: u32 = 108u32;
10129 pub const SECPKG_ATTR_SUPPORTED_ALGS: u32 = 86u32;
10130 pub const SECPKG_ATTR_SUPPORTED_PROTOCOLS: u32 = 88u32;
10131 pub const SECPKG_ATTR_TARGET: u32 = 19u32;
10132 pub const SECPKG_ATTR_THUNK_ALL: u32 = 65536u32;
10133 pub const SECPKG_ATTR_TOKEN_BINDING: u32 = 109u32;
10134 pub const SECPKG_ATTR_UI_INFO: u32 = 104u32;
10135 pub const SECPKG_ATTR_USER_FLAGS: u32 = 11u32;
10136 pub const SECPKG_ATTR_USE_NCRYPT: u32 = 98u32;
10137 pub const SECPKG_ATTR_USE_VALIDATED: u32 = 15u32;
10138 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10139 #[repr(C)]
10140 pub struct SECPKG_BYTE_VECTOR {
10141     pub ByteArrayOffset: u32,
10142     pub ByteArrayLength: u16,
10143 }
10144 impl SECPKG_BYTE_VECTOR {}
10145 impl ::std::default::Default for SECPKG_BYTE_VECTOR {
10146     fn default() -> Self {
10147         unsafe { ::std::mem::zeroed() }
10148     }
10149 }
10150 impl ::std::fmt::Debug for SECPKG_BYTE_VECTOR {
10151     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10152         fmt.debug_struct("SECPKG_BYTE_VECTOR").field("ByteArrayOffset", &self.ByteArrayOffset).field("ByteArrayLength", &self.ByteArrayLength).finish()
10153     }
10154 }
10155 impl ::std::cmp::PartialEq for SECPKG_BYTE_VECTOR {
10156     fn eq(&self, other: &Self) -> bool {
10157         self.ByteArrayOffset == other.ByteArrayOffset && self.ByteArrayLength == other.ByteArrayLength
10158     }
10159 }
10160 impl ::std::cmp::Eq for SECPKG_BYTE_VECTOR {}
10161 unsafe impl ::windows::runtime::Abi for SECPKG_BYTE_VECTOR {
10162     type Abi = Self;
10163     type DefaultType = Self;
10164 }
10165 pub const SECPKG_CALLFLAGS_APPCONTAINER: u32 = 1u32;
10166 pub const SECPKG_CALLFLAGS_APPCONTAINER_AUTHCAPABLE: u32 = 2u32;
10167 pub const SECPKG_CALLFLAGS_APPCONTAINER_UPNCAPABLE: u32 = 8u32;
10168 pub const SECPKG_CALLFLAGS_FORCE_SUPPLIED: u32 = 4u32;
10169 pub const SECPKG_CALL_ANSI: u32 = 2u32;
10170 pub const SECPKG_CALL_ASYNC_UPDATE: u32 = 4096u32;
10171 pub const SECPKG_CALL_BUFFER_MARSHAL: u32 = 65536u32;
10172 pub const SECPKG_CALL_CLEANUP: u32 = 32u32;
10173 pub const SECPKG_CALL_CLOUDAP_CONNECT: u32 = 262144u32;
10174 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10175 #[repr(C)]
10176 pub struct SECPKG_CALL_INFO {
10177     pub ProcessId: u32,
10178     pub ThreadId: u32,
10179     pub Attributes: u32,
10180     pub CallCount: u32,
10181     pub MechOid: *mut ::std::ffi::c_void,
10182 }
10183 impl SECPKG_CALL_INFO {}
10184 impl ::std::default::Default for SECPKG_CALL_INFO {
10185     fn default() -> Self {
10186         unsafe { ::std::mem::zeroed() }
10187     }
10188 }
10189 impl ::std::fmt::Debug for SECPKG_CALL_INFO {
10190     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10191         fmt.debug_struct("SECPKG_CALL_INFO").field("ProcessId", &self.ProcessId).field("ThreadId", &self.ThreadId).field("Attributes", &self.Attributes).field("CallCount", &self.CallCount).field("MechOid", &self.MechOid).finish()
10192     }
10193 }
10194 impl ::std::cmp::PartialEq for SECPKG_CALL_INFO {
10195     fn eq(&self, other: &Self) -> bool {
10196         self.ProcessId == other.ProcessId && self.ThreadId == other.ThreadId && self.Attributes == other.Attributes && self.CallCount == other.CallCount && self.MechOid == other.MechOid
10197     }
10198 }
10199 impl ::std::cmp::Eq for SECPKG_CALL_INFO {}
10200 unsafe impl ::windows::runtime::Abi for SECPKG_CALL_INFO {
10201     type Abi = Self;
10202     type DefaultType = Self;
10203 }
10204 pub const SECPKG_CALL_IN_PROC: u32 = 16u32;
10205 pub const SECPKG_CALL_IS_TCB: u32 = 512u32;
10206 pub const SECPKG_CALL_KERNEL_MODE: u32 = 1u32;
10207 pub const SECPKG_CALL_NEGO: u32 = 16384u32;
10208 pub const SECPKG_CALL_NEGO_EXTENDER: u32 = 32768u32;
10209 pub const SECPKG_CALL_NETWORK_ONLY: u32 = 1024u32;
10210 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10211 #[repr(transparent)]
10212 pub struct SECPKG_CALL_PACKAGE_MESSAGE_TYPE(pub i32);
10213 pub const SecPkgCallPackageMinMessage: SECPKG_CALL_PACKAGE_MESSAGE_TYPE = SECPKG_CALL_PACKAGE_MESSAGE_TYPE(1024i32);
10214 pub const SecPkgCallPackagePinDcMessage: SECPKG_CALL_PACKAGE_MESSAGE_TYPE = SECPKG_CALL_PACKAGE_MESSAGE_TYPE(1024i32);
10215 pub const SecPkgCallPackageUnpinAllDcsMessage: SECPKG_CALL_PACKAGE_MESSAGE_TYPE = SECPKG_CALL_PACKAGE_MESSAGE_TYPE(1025i32);
10216 pub const SecPkgCallPackageTransferCredMessage: SECPKG_CALL_PACKAGE_MESSAGE_TYPE = SECPKG_CALL_PACKAGE_MESSAGE_TYPE(1026i32);
10217 pub const SecPkgCallPackageMaxMessage: SECPKG_CALL_PACKAGE_MESSAGE_TYPE = SECPKG_CALL_PACKAGE_MESSAGE_TYPE(1026i32);
10218 impl ::std::convert::From<i32> for SECPKG_CALL_PACKAGE_MESSAGE_TYPE {
10219     fn from(value: i32) -> Self {
10220         Self(value)
10221     }
10222 }
10223 unsafe impl ::windows::runtime::Abi for SECPKG_CALL_PACKAGE_MESSAGE_TYPE {
10224     type Abi = Self;
10225     type DefaultType = Self;
10226 }
10227 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10228 #[repr(C)]
10229 #[cfg(feature = "Win32_Foundation")]
10230 pub struct SECPKG_CALL_PACKAGE_PIN_DC_REQUEST {
10231     pub MessageType: u32,
10232     pub Flags: u32,
10233     pub DomainName: super::super::super::Foundation::UNICODE_STRING,
10234     pub DcName: super::super::super::Foundation::UNICODE_STRING,
10235     pub DcFlags: u32,
10236 }
10237 #[cfg(feature = "Win32_Foundation")]
10238 impl SECPKG_CALL_PACKAGE_PIN_DC_REQUEST {}
10239 #[cfg(feature = "Win32_Foundation")]
10240 impl ::std::default::Default for SECPKG_CALL_PACKAGE_PIN_DC_REQUEST {
10241     fn default() -> Self {
10242         unsafe { ::std::mem::zeroed() }
10243     }
10244 }
10245 #[cfg(feature = "Win32_Foundation")]
10246 impl ::std::fmt::Debug for SECPKG_CALL_PACKAGE_PIN_DC_REQUEST {
10247     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10248         fmt.debug_struct("SECPKG_CALL_PACKAGE_PIN_DC_REQUEST").field("MessageType", &self.MessageType).field("Flags", &self.Flags).field("DomainName", &self.DomainName).field("DcName", &self.DcName).field("DcFlags", &self.DcFlags).finish()
10249     }
10250 }
10251 #[cfg(feature = "Win32_Foundation")]
10252 impl ::std::cmp::PartialEq for SECPKG_CALL_PACKAGE_PIN_DC_REQUEST {
10253     fn eq(&self, other: &Self) -> bool {
10254         self.MessageType == other.MessageType && self.Flags == other.Flags && self.DomainName == other.DomainName && self.DcName == other.DcName && self.DcFlags == other.DcFlags
10255     }
10256 }
10257 #[cfg(feature = "Win32_Foundation")]
10258 impl ::std::cmp::Eq for SECPKG_CALL_PACKAGE_PIN_DC_REQUEST {}
10259 #[cfg(feature = "Win32_Foundation")]
10260 unsafe impl ::windows::runtime::Abi for SECPKG_CALL_PACKAGE_PIN_DC_REQUEST {
10261     type Abi = Self;
10262     type DefaultType = Self;
10263 }
10264 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10265 #[repr(C)]
10266 #[cfg(feature = "Win32_Foundation")]
10267 pub struct SECPKG_CALL_PACKAGE_TRANSFER_CRED_REQUEST {
10268     pub MessageType: u32,
10269     pub OriginLogonId: super::super::super::Foundation::LUID,
10270     pub DestinationLogonId: super::super::super::Foundation::LUID,
10271     pub Flags: u32,
10272 }
10273 #[cfg(feature = "Win32_Foundation")]
10274 impl SECPKG_CALL_PACKAGE_TRANSFER_CRED_REQUEST {}
10275 #[cfg(feature = "Win32_Foundation")]
10276 impl ::std::default::Default for SECPKG_CALL_PACKAGE_TRANSFER_CRED_REQUEST {
10277     fn default() -> Self {
10278         unsafe { ::std::mem::zeroed() }
10279     }
10280 }
10281 #[cfg(feature = "Win32_Foundation")]
10282 impl ::std::fmt::Debug for SECPKG_CALL_PACKAGE_TRANSFER_CRED_REQUEST {
10283     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10284         fmt.debug_struct("SECPKG_CALL_PACKAGE_TRANSFER_CRED_REQUEST").field("MessageType", &self.MessageType).field("OriginLogonId", &self.OriginLogonId).field("DestinationLogonId", &self.DestinationLogonId).field("Flags", &self.Flags).finish()
10285     }
10286 }
10287 #[cfg(feature = "Win32_Foundation")]
10288 impl ::std::cmp::PartialEq for SECPKG_CALL_PACKAGE_TRANSFER_CRED_REQUEST {
10289     fn eq(&self, other: &Self) -> bool {
10290         self.MessageType == other.MessageType && self.OriginLogonId == other.OriginLogonId && self.DestinationLogonId == other.DestinationLogonId && self.Flags == other.Flags
10291     }
10292 }
10293 #[cfg(feature = "Win32_Foundation")]
10294 impl ::std::cmp::Eq for SECPKG_CALL_PACKAGE_TRANSFER_CRED_REQUEST {}
10295 #[cfg(feature = "Win32_Foundation")]
10296 unsafe impl ::windows::runtime::Abi for SECPKG_CALL_PACKAGE_TRANSFER_CRED_REQUEST {
10297     type Abi = Self;
10298     type DefaultType = Self;
10299 }
10300 pub const SECPKG_CALL_PACKAGE_TRANSFER_CRED_REQUEST_FLAG_CLEANUP_CREDENTIALS: u32 = 2u32;
10301 pub const SECPKG_CALL_PACKAGE_TRANSFER_CRED_REQUEST_FLAG_OPTIMISTIC_LOGON: u32 = 1u32;
10302 pub const SECPKG_CALL_PACKAGE_TRANSFER_CRED_REQUEST_FLAG_TO_SSO_SESSION: u32 = 4u32;
10303 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10304 #[repr(C)]
10305 pub struct SECPKG_CALL_PACKAGE_UNPIN_ALL_DCS_REQUEST {
10306     pub MessageType: u32,
10307     pub Flags: u32,
10308 }
10309 impl SECPKG_CALL_PACKAGE_UNPIN_ALL_DCS_REQUEST {}
10310 impl ::std::default::Default for SECPKG_CALL_PACKAGE_UNPIN_ALL_DCS_REQUEST {
10311     fn default() -> Self {
10312         unsafe { ::std::mem::zeroed() }
10313     }
10314 }
10315 impl ::std::fmt::Debug for SECPKG_CALL_PACKAGE_UNPIN_ALL_DCS_REQUEST {
10316     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10317         fmt.debug_struct("SECPKG_CALL_PACKAGE_UNPIN_ALL_DCS_REQUEST").field("MessageType", &self.MessageType).field("Flags", &self.Flags).finish()
10318     }
10319 }
10320 impl ::std::cmp::PartialEq for SECPKG_CALL_PACKAGE_UNPIN_ALL_DCS_REQUEST {
10321     fn eq(&self, other: &Self) -> bool {
10322         self.MessageType == other.MessageType && self.Flags == other.Flags
10323     }
10324 }
10325 impl ::std::cmp::Eq for SECPKG_CALL_PACKAGE_UNPIN_ALL_DCS_REQUEST {}
10326 unsafe impl ::windows::runtime::Abi for SECPKG_CALL_PACKAGE_UNPIN_ALL_DCS_REQUEST {
10327     type Abi = Self;
10328     type DefaultType = Self;
10329 }
10330 pub const SECPKG_CALL_PROCESS_TERM: u32 = 256u32;
10331 pub const SECPKG_CALL_RECURSIVE: u32 = 8u32;
10332 pub const SECPKG_CALL_SYSTEM_PROC: u32 = 8192u32;
10333 pub const SECPKG_CALL_THREAD_TERM: u32 = 128u32;
10334 pub const SECPKG_CALL_UNLOCK: u32 = 131072u32;
10335 pub const SECPKG_CALL_URGENT: u32 = 4u32;
10336 pub const SECPKG_CALL_WINLOGON: u32 = 2048u32;
10337 pub const SECPKG_CALL_WOWA32: u32 = 262144u32;
10338 pub const SECPKG_CALL_WOWCLIENT: u32 = 64u32;
10339 pub const SECPKG_CALL_WOWX86: u32 = 64u32;
10340 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10341 #[repr(C)]
10342 #[cfg(feature = "Win32_Foundation")]
10343 pub struct SECPKG_CLIENT_INFO {
10344     pub LogonId: super::super::super::Foundation::LUID,
10345     pub ProcessID: u32,
10346     pub ThreadID: u32,
10347     pub HasTcbPrivilege: super::super::super::Foundation::BOOLEAN,
10348     pub Impersonating: super::super::super::Foundation::BOOLEAN,
10349     pub Restricted: super::super::super::Foundation::BOOLEAN,
10350     pub ClientFlags: u8,
10351     pub ImpersonationLevel: super::super::SECURITY_IMPERSONATION_LEVEL,
10352     pub ClientToken: super::super::super::Foundation::HANDLE,
10353 }
10354 #[cfg(feature = "Win32_Foundation")]
10355 impl SECPKG_CLIENT_INFO {}
10356 #[cfg(feature = "Win32_Foundation")]
10357 impl ::std::default::Default for SECPKG_CLIENT_INFO {
10358     fn default() -> Self {
10359         unsafe { ::std::mem::zeroed() }
10360     }
10361 }
10362 #[cfg(feature = "Win32_Foundation")]
10363 impl ::std::fmt::Debug for SECPKG_CLIENT_INFO {
10364     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10365         fmt.debug_struct("SECPKG_CLIENT_INFO")
10366             .field("LogonId", &self.LogonId)
10367             .field("ProcessID", &self.ProcessID)
10368             .field("ThreadID", &self.ThreadID)
10369             .field("HasTcbPrivilege", &self.HasTcbPrivilege)
10370             .field("Impersonating", &self.Impersonating)
10371             .field("Restricted", &self.Restricted)
10372             .field("ClientFlags", &self.ClientFlags)
10373             .field("ImpersonationLevel", &self.ImpersonationLevel)
10374             .field("ClientToken", &self.ClientToken)
10375             .finish()
10376     }
10377 }
10378 #[cfg(feature = "Win32_Foundation")]
10379 impl ::std::cmp::PartialEq for SECPKG_CLIENT_INFO {
10380     fn eq(&self, other: &Self) -> bool {
10381         self.LogonId == other.LogonId && self.ProcessID == other.ProcessID && self.ThreadID == other.ThreadID && self.HasTcbPrivilege == other.HasTcbPrivilege && self.Impersonating == other.Impersonating && self.Restricted == other.Restricted && self.ClientFlags == other.ClientFlags && self.ImpersonationLevel == other.ImpersonationLevel && self.ClientToken == other.ClientToken
10382     }
10383 }
10384 #[cfg(feature = "Win32_Foundation")]
10385 impl ::std::cmp::Eq for SECPKG_CLIENT_INFO {}
10386 #[cfg(feature = "Win32_Foundation")]
10387 unsafe impl ::windows::runtime::Abi for SECPKG_CLIENT_INFO {
10388     type Abi = Self;
10389     type DefaultType = Self;
10390 }
10391 pub const SECPKG_CLIENT_PROCESS_TERMINATED: u32 = 1u32;
10392 pub const SECPKG_CLIENT_THREAD_TERMINATED: u32 = 2u32;
10393 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10394 #[repr(C)]
10395 pub struct SECPKG_CONTEXT_THUNKS {
10396     pub InfoLevelCount: u32,
10397     pub Levels: [u32; 1],
10398 }
10399 impl SECPKG_CONTEXT_THUNKS {}
10400 impl ::std::default::Default for SECPKG_CONTEXT_THUNKS {
10401     fn default() -> Self {
10402         unsafe { ::std::mem::zeroed() }
10403     }
10404 }
10405 impl ::std::fmt::Debug for SECPKG_CONTEXT_THUNKS {
10406     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10407         fmt.debug_struct("SECPKG_CONTEXT_THUNKS").field("InfoLevelCount", &self.InfoLevelCount).field("Levels", &self.Levels).finish()
10408     }
10409 }
10410 impl ::std::cmp::PartialEq for SECPKG_CONTEXT_THUNKS {
10411     fn eq(&self, other: &Self) -> bool {
10412         self.InfoLevelCount == other.InfoLevelCount && self.Levels == other.Levels
10413     }
10414 }
10415 impl ::std::cmp::Eq for SECPKG_CONTEXT_THUNKS {}
10416 unsafe impl ::windows::runtime::Abi for SECPKG_CONTEXT_THUNKS {
10417     type Abi = Self;
10418     type DefaultType = Self;
10419 }
10420 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10421 #[repr(transparent)]
10422 pub struct SECPKG_CRED(pub u32);
10423 pub const SECPKG_CRED_INBOUND: SECPKG_CRED = SECPKG_CRED(1u32);
10424 pub const SECPKG_CRED_OUTBOUND: SECPKG_CRED = SECPKG_CRED(2u32);
10425 impl ::std::convert::From<u32> for SECPKG_CRED {
10426     fn from(value: u32) -> Self {
10427         Self(value)
10428     }
10429 }
10430 unsafe impl ::windows::runtime::Abi for SECPKG_CRED {
10431     type Abi = Self;
10432     type DefaultType = Self;
10433 }
10434 impl ::std::ops::BitOr for SECPKG_CRED {
10435     type Output = Self;
10436     fn bitor(self, rhs: Self) -> Self {
10437         Self(self.0 | rhs.0)
10438     }
10439 }
10440 impl ::std::ops::BitAnd for SECPKG_CRED {
10441     type Output = Self;
10442     fn bitand(self, rhs: Self) -> Self {
10443         Self(self.0 & rhs.0)
10444     }
10445 }
10446 impl ::std::ops::BitOrAssign for SECPKG_CRED {
10447     fn bitor_assign(&mut self, rhs: Self) {
10448         self.0.bitor_assign(rhs.0)
10449     }
10450 }
10451 impl ::std::ops::BitAndAssign for SECPKG_CRED {
10452     fn bitand_assign(&mut self, rhs: Self) {
10453         self.0.bitand_assign(rhs.0)
10454     }
10455 }
10456 impl ::std::ops::Not for SECPKG_CRED {
10457     type Output = Self;
10458     fn not(self) -> Self {
10459         Self(self.0.not())
10460     }
10461 }
10462 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10463 #[repr(C)]
10464 #[cfg(feature = "Win32_Foundation")]
10465 pub struct SECPKG_CREDENTIAL {
10466     pub Version: u64,
10467     pub cbHeaderLength: u16,
10468     pub cbStructureLength: u32,
10469     pub ClientProcess: u32,
10470     pub ClientThread: u32,
10471     pub LogonId: super::super::super::Foundation::LUID,
10472     pub ClientToken: super::super::super::Foundation::HANDLE,
10473     pub SessionId: u32,
10474     pub ModifiedId: super::super::super::Foundation::LUID,
10475     pub fCredentials: u32,
10476     pub Flags: u32,
10477     pub PrincipalName: SECPKG_BYTE_VECTOR,
10478     pub PackageList: SECPKG_BYTE_VECTOR,
10479     pub MarshaledSuppliedCreds: SECPKG_BYTE_VECTOR,
10480 }
10481 #[cfg(feature = "Win32_Foundation")]
10482 impl SECPKG_CREDENTIAL {}
10483 #[cfg(feature = "Win32_Foundation")]
10484 impl ::std::default::Default for SECPKG_CREDENTIAL {
10485     fn default() -> Self {
10486         unsafe { ::std::mem::zeroed() }
10487     }
10488 }
10489 #[cfg(feature = "Win32_Foundation")]
10490 impl ::std::fmt::Debug for SECPKG_CREDENTIAL {
10491     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10492         fmt.debug_struct("SECPKG_CREDENTIAL")
10493             .field("Version", &self.Version)
10494             .field("cbHeaderLength", &self.cbHeaderLength)
10495             .field("cbStructureLength", &self.cbStructureLength)
10496             .field("ClientProcess", &self.ClientProcess)
10497             .field("ClientThread", &self.ClientThread)
10498             .field("LogonId", &self.LogonId)
10499             .field("ClientToken", &self.ClientToken)
10500             .field("SessionId", &self.SessionId)
10501             .field("ModifiedId", &self.ModifiedId)
10502             .field("fCredentials", &self.fCredentials)
10503             .field("Flags", &self.Flags)
10504             .field("PrincipalName", &self.PrincipalName)
10505             .field("PackageList", &self.PackageList)
10506             .field("MarshaledSuppliedCreds", &self.MarshaledSuppliedCreds)
10507             .finish()
10508     }
10509 }
10510 #[cfg(feature = "Win32_Foundation")]
10511 impl ::std::cmp::PartialEq for SECPKG_CREDENTIAL {
10512     fn eq(&self, other: &Self) -> bool {
10513         self.Version == other.Version
10514             && self.cbHeaderLength == other.cbHeaderLength
10515             && self.cbStructureLength == other.cbStructureLength
10516             && self.ClientProcess == other.ClientProcess
10517             && self.ClientThread == other.ClientThread
10518             && self.LogonId == other.LogonId
10519             && self.ClientToken == other.ClientToken
10520             && self.SessionId == other.SessionId
10521             && self.ModifiedId == other.ModifiedId
10522             && self.fCredentials == other.fCredentials
10523             && self.Flags == other.Flags
10524             && self.PrincipalName == other.PrincipalName
10525             && self.PackageList == other.PackageList
10526             && self.MarshaledSuppliedCreds == other.MarshaledSuppliedCreds
10527     }
10528 }
10529 #[cfg(feature = "Win32_Foundation")]
10530 impl ::std::cmp::Eq for SECPKG_CREDENTIAL {}
10531 #[cfg(feature = "Win32_Foundation")]
10532 unsafe impl ::windows::runtime::Abi for SECPKG_CREDENTIAL {
10533     type Abi = Self;
10534     type DefaultType = Self;
10535 }
10536 pub const SECPKG_CREDENTIAL_ATTRIBUTE: u32 = 0u32;
10537 pub const SECPKG_CREDENTIAL_FLAGS_CALLER_HAS_TCB: u32 = 1u32;
10538 pub const SECPKG_CREDENTIAL_FLAGS_CREDMAN_CRED: u32 = 2u32;
10539 pub const SECPKG_CREDENTIAL_VERSION: u32 = 201u32;
10540 pub const SECPKG_CRED_ATTR_CERT: u32 = 4u32;
10541 pub const SECPKG_CRED_ATTR_KDC_PROXY_SETTINGS: u32 = 3u32;
10542 pub const SECPKG_CRED_ATTR_NAMES: u32 = 1u32;
10543 pub const SECPKG_CRED_ATTR_PAC_BYPASS: u32 = 5u32;
10544 pub const SECPKG_CRED_ATTR_SSI_PROVIDER: u32 = 2u32;
10545 pub const SECPKG_CRED_AUTOLOGON_RESTRICTED: u32 = 16u32;
10546 pub const SECPKG_CRED_BOTH: u32 = 3u32;
10547 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10548 #[repr(transparent)]
10549 pub struct SECPKG_CRED_CLASS(pub i32);
10550 pub const SecPkgCredClass_None: SECPKG_CRED_CLASS = SECPKG_CRED_CLASS(0i32);
10551 pub const SecPkgCredClass_Ephemeral: SECPKG_CRED_CLASS = SECPKG_CRED_CLASS(10i32);
10552 pub const SecPkgCredClass_PersistedGeneric: SECPKG_CRED_CLASS = SECPKG_CRED_CLASS(20i32);
10553 pub const SecPkgCredClass_PersistedSpecific: SECPKG_CRED_CLASS = SECPKG_CRED_CLASS(30i32);
10554 pub const SecPkgCredClass_Explicit: SECPKG_CRED_CLASS = SECPKG_CRED_CLASS(40i32);
10555 impl ::std::convert::From<i32> for SECPKG_CRED_CLASS {
10556     fn from(value: i32) -> Self {
10557         Self(value)
10558     }
10559 }
10560 unsafe impl ::windows::runtime::Abi for SECPKG_CRED_CLASS {
10561     type Abi = Self;
10562     type DefaultType = Self;
10563 }
10564 pub const SECPKG_CRED_DEFAULT: u32 = 4u32;
10565 pub const SECPKG_CRED_PROCESS_POLICY_ONLY: u32 = 32u32;
10566 pub const SECPKG_CRED_RESERVED: u32 = 4026531840u32;
10567 #[derive(:: std :: clone :: Clone)]
10568 #[repr(C)]
10569 #[cfg(feature = "Win32_Foundation")]
10570 pub struct SECPKG_DLL_FUNCTIONS {
10571     pub AllocateHeap: ::std::option::Option<PLSA_ALLOCATE_LSA_HEAP>,
10572     pub FreeHeap: ::std::option::Option<PLSA_FREE_LSA_HEAP>,
10573     pub RegisterCallback: ::std::option::Option<PLSA_REGISTER_CALLBACK>,
10574     pub LocatePackageById: ::std::option::Option<PLSA_LOCATE_PKG_BY_ID>,
10575 }
10576 #[cfg(feature = "Win32_Foundation")]
10577 impl SECPKG_DLL_FUNCTIONS {}
10578 #[cfg(feature = "Win32_Foundation")]
10579 impl ::std::default::Default for SECPKG_DLL_FUNCTIONS {
10580     fn default() -> Self {
10581         unsafe { ::std::mem::zeroed() }
10582     }
10583 }
10584 #[cfg(feature = "Win32_Foundation")]
10585 impl ::std::fmt::Debug for SECPKG_DLL_FUNCTIONS {
10586     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10587         fmt.debug_struct("SECPKG_DLL_FUNCTIONS").finish()
10588     }
10589 }
10590 #[cfg(feature = "Win32_Foundation")]
10591 impl ::std::cmp::PartialEq for SECPKG_DLL_FUNCTIONS {
10592     fn eq(&self, other: &Self) -> bool {
10593         self.AllocateHeap.map(|f| f as usize) == other.AllocateHeap.map(|f| f as usize) && self.FreeHeap.map(|f| f as usize) == other.FreeHeap.map(|f| f as usize) && self.RegisterCallback.map(|f| f as usize) == other.RegisterCallback.map(|f| f as usize) && self.LocatePackageById.map(|f| f as usize) == other.LocatePackageById.map(|f| f as usize)
10594     }
10595 }
10596 #[cfg(feature = "Win32_Foundation")]
10597 impl ::std::cmp::Eq for SECPKG_DLL_FUNCTIONS {}
10598 #[cfg(feature = "Win32_Foundation")]
10599 unsafe impl ::windows::runtime::Abi for SECPKG_DLL_FUNCTIONS {
10600     type Abi = ::std::mem::ManuallyDrop<Self>;
10601     type DefaultType = Self;
10602 }
10603 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10604 #[repr(C)]
10605 pub struct SECPKG_EVENT_NOTIFY {
10606     pub EventClass: u32,
10607     pub Reserved: u32,
10608     pub EventDataSize: u32,
10609     pub EventData: *mut ::std::ffi::c_void,
10610     pub PackageParameter: *mut ::std::ffi::c_void,
10611 }
10612 impl SECPKG_EVENT_NOTIFY {}
10613 impl ::std::default::Default for SECPKG_EVENT_NOTIFY {
10614     fn default() -> Self {
10615         unsafe { ::std::mem::zeroed() }
10616     }
10617 }
10618 impl ::std::fmt::Debug for SECPKG_EVENT_NOTIFY {
10619     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10620         fmt.debug_struct("SECPKG_EVENT_NOTIFY").field("EventClass", &self.EventClass).field("Reserved", &self.Reserved).field("EventDataSize", &self.EventDataSize).field("EventData", &self.EventData).field("PackageParameter", &self.PackageParameter).finish()
10621     }
10622 }
10623 impl ::std::cmp::PartialEq for SECPKG_EVENT_NOTIFY {
10624     fn eq(&self, other: &Self) -> bool {
10625         self.EventClass == other.EventClass && self.Reserved == other.Reserved && self.EventDataSize == other.EventDataSize && self.EventData == other.EventData && self.PackageParameter == other.PackageParameter
10626     }
10627 }
10628 impl ::std::cmp::Eq for SECPKG_EVENT_NOTIFY {}
10629 unsafe impl ::windows::runtime::Abi for SECPKG_EVENT_NOTIFY {
10630     type Abi = Self;
10631     type DefaultType = Self;
10632 }
10633 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10634 #[repr(C)]
10635 #[cfg(feature = "Win32_Foundation")]
10636 pub struct SECPKG_EVENT_PACKAGE_CHANGE {
10637     pub ChangeType: SECPKG_PACKAGE_CHANGE_TYPE,
10638     pub PackageId: usize,
10639     pub PackageName: super::super::super::Foundation::UNICODE_STRING,
10640 }
10641 #[cfg(feature = "Win32_Foundation")]
10642 impl SECPKG_EVENT_PACKAGE_CHANGE {}
10643 #[cfg(feature = "Win32_Foundation")]
10644 impl ::std::default::Default for SECPKG_EVENT_PACKAGE_CHANGE {
10645     fn default() -> Self {
10646         unsafe { ::std::mem::zeroed() }
10647     }
10648 }
10649 #[cfg(feature = "Win32_Foundation")]
10650 impl ::std::fmt::Debug for SECPKG_EVENT_PACKAGE_CHANGE {
10651     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10652         fmt.debug_struct("SECPKG_EVENT_PACKAGE_CHANGE").field("ChangeType", &self.ChangeType).field("PackageId", &self.PackageId).field("PackageName", &self.PackageName).finish()
10653     }
10654 }
10655 #[cfg(feature = "Win32_Foundation")]
10656 impl ::std::cmp::PartialEq for SECPKG_EVENT_PACKAGE_CHANGE {
10657     fn eq(&self, other: &Self) -> bool {
10658         self.ChangeType == other.ChangeType && self.PackageId == other.PackageId && self.PackageName == other.PackageName
10659     }
10660 }
10661 #[cfg(feature = "Win32_Foundation")]
10662 impl ::std::cmp::Eq for SECPKG_EVENT_PACKAGE_CHANGE {}
10663 #[cfg(feature = "Win32_Foundation")]
10664 unsafe impl ::windows::runtime::Abi for SECPKG_EVENT_PACKAGE_CHANGE {
10665     type Abi = Self;
10666     type DefaultType = Self;
10667 }
10668 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10669 #[repr(C)]
10670 pub struct SECPKG_EVENT_ROLE_CHANGE {
10671     pub PreviousRole: u32,
10672     pub NewRole: u32,
10673 }
10674 impl SECPKG_EVENT_ROLE_CHANGE {}
10675 impl ::std::default::Default for SECPKG_EVENT_ROLE_CHANGE {
10676     fn default() -> Self {
10677         unsafe { ::std::mem::zeroed() }
10678     }
10679 }
10680 impl ::std::fmt::Debug for SECPKG_EVENT_ROLE_CHANGE {
10681     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10682         fmt.debug_struct("SECPKG_EVENT_ROLE_CHANGE").field("PreviousRole", &self.PreviousRole).field("NewRole", &self.NewRole).finish()
10683     }
10684 }
10685 impl ::std::cmp::PartialEq for SECPKG_EVENT_ROLE_CHANGE {
10686     fn eq(&self, other: &Self) -> bool {
10687         self.PreviousRole == other.PreviousRole && self.NewRole == other.NewRole
10688     }
10689 }
10690 impl ::std::cmp::Eq for SECPKG_EVENT_ROLE_CHANGE {}
10691 unsafe impl ::windows::runtime::Abi for SECPKG_EVENT_ROLE_CHANGE {
10692     type Abi = Self;
10693     type DefaultType = Self;
10694 }
10695 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10696 #[repr(C)]
10697 #[cfg(feature = "Win32_Foundation")]
10698 pub struct SECPKG_EXTENDED_INFORMATION {
10699     pub Class: SECPKG_EXTENDED_INFORMATION_CLASS,
10700     pub Info: SECPKG_EXTENDED_INFORMATION_0,
10701 }
10702 #[cfg(feature = "Win32_Foundation")]
10703 impl SECPKG_EXTENDED_INFORMATION {}
10704 #[cfg(feature = "Win32_Foundation")]
10705 impl ::std::default::Default for SECPKG_EXTENDED_INFORMATION {
10706     fn default() -> Self {
10707         unsafe { ::std::mem::zeroed() }
10708     }
10709 }
10710 #[cfg(feature = "Win32_Foundation")]
10711 impl ::std::cmp::PartialEq for SECPKG_EXTENDED_INFORMATION {
10712     fn eq(&self, _other: &Self) -> bool {
10713         unimplemented!()
10714     }
10715 }
10716 #[cfg(feature = "Win32_Foundation")]
10717 impl ::std::cmp::Eq for SECPKG_EXTENDED_INFORMATION {}
10718 #[cfg(feature = "Win32_Foundation")]
10719 unsafe impl ::windows::runtime::Abi for SECPKG_EXTENDED_INFORMATION {
10720     type Abi = Self;
10721     type DefaultType = Self;
10722 }
10723 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10724 #[repr(C)]
10725 #[cfg(feature = "Win32_Foundation")]
10726 pub union SECPKG_EXTENDED_INFORMATION_0 {
10727     pub GssInfo: SECPKG_GSS_INFO,
10728     pub ContextThunks: SECPKG_CONTEXT_THUNKS,
10729     pub MutualAuthLevel: SECPKG_MUTUAL_AUTH_LEVEL,
10730     pub WowClientDll: SECPKG_WOW_CLIENT_DLL,
10731     pub ExtraOids: SECPKG_EXTRA_OIDS,
10732     pub Nego2Info: SECPKG_NEGO2_INFO,
10733 }
10734 #[cfg(feature = "Win32_Foundation")]
10735 impl SECPKG_EXTENDED_INFORMATION_0 {}
10736 #[cfg(feature = "Win32_Foundation")]
10737 impl ::std::default::Default for SECPKG_EXTENDED_INFORMATION_0 {
10738     fn default() -> Self {
10739         unsafe { ::std::mem::zeroed() }
10740     }
10741 }
10742 #[cfg(feature = "Win32_Foundation")]
10743 impl ::std::cmp::PartialEq for SECPKG_EXTENDED_INFORMATION_0 {
10744     fn eq(&self, _other: &Self) -> bool {
10745         unimplemented!()
10746     }
10747 }
10748 #[cfg(feature = "Win32_Foundation")]
10749 impl ::std::cmp::Eq for SECPKG_EXTENDED_INFORMATION_0 {}
10750 #[cfg(feature = "Win32_Foundation")]
10751 unsafe impl ::windows::runtime::Abi for SECPKG_EXTENDED_INFORMATION_0 {
10752     type Abi = Self;
10753     type DefaultType = Self;
10754 }
10755 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10756 #[repr(transparent)]
10757 pub struct SECPKG_EXTENDED_INFORMATION_CLASS(pub i32);
10758 pub const SecpkgGssInfo: SECPKG_EXTENDED_INFORMATION_CLASS = SECPKG_EXTENDED_INFORMATION_CLASS(1i32);
10759 pub const SecpkgContextThunks: SECPKG_EXTENDED_INFORMATION_CLASS = SECPKG_EXTENDED_INFORMATION_CLASS(2i32);
10760 pub const SecpkgMutualAuthLevel: SECPKG_EXTENDED_INFORMATION_CLASS = SECPKG_EXTENDED_INFORMATION_CLASS(3i32);
10761 pub const SecpkgWowClientDll: SECPKG_EXTENDED_INFORMATION_CLASS = SECPKG_EXTENDED_INFORMATION_CLASS(4i32);
10762 pub const SecpkgExtraOids: SECPKG_EXTENDED_INFORMATION_CLASS = SECPKG_EXTENDED_INFORMATION_CLASS(5i32);
10763 pub const SecpkgMaxInfo: SECPKG_EXTENDED_INFORMATION_CLASS = SECPKG_EXTENDED_INFORMATION_CLASS(6i32);
10764 pub const SecpkgNego2Info: SECPKG_EXTENDED_INFORMATION_CLASS = SECPKG_EXTENDED_INFORMATION_CLASS(7i32);
10765 impl ::std::convert::From<i32> for SECPKG_EXTENDED_INFORMATION_CLASS {
10766     fn from(value: i32) -> Self {
10767         Self(value)
10768     }
10769 }
10770 unsafe impl ::windows::runtime::Abi for SECPKG_EXTENDED_INFORMATION_CLASS {
10771     type Abi = Self;
10772     type DefaultType = Self;
10773 }
10774 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10775 #[repr(C)]
10776 pub struct SECPKG_EXTRA_OIDS {
10777     pub OidCount: u32,
10778     pub Oids: [SECPKG_SERIALIZED_OID; 1],
10779 }
10780 impl SECPKG_EXTRA_OIDS {}
10781 impl ::std::default::Default for SECPKG_EXTRA_OIDS {
10782     fn default() -> Self {
10783         unsafe { ::std::mem::zeroed() }
10784     }
10785 }
10786 impl ::std::fmt::Debug for SECPKG_EXTRA_OIDS {
10787     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10788         fmt.debug_struct("SECPKG_EXTRA_OIDS").field("OidCount", &self.OidCount).field("Oids", &self.Oids).finish()
10789     }
10790 }
10791 impl ::std::cmp::PartialEq for SECPKG_EXTRA_OIDS {
10792     fn eq(&self, other: &Self) -> bool {
10793         self.OidCount == other.OidCount && self.Oids == other.Oids
10794     }
10795 }
10796 impl ::std::cmp::Eq for SECPKG_EXTRA_OIDS {}
10797 unsafe impl ::windows::runtime::Abi for SECPKG_EXTRA_OIDS {
10798     type Abi = Self;
10799     type DefaultType = Self;
10800 }
10801 pub const SECPKG_FLAG_ACCEPT_WIN32_NAME: u32 = 512u32;
10802 pub const SECPKG_FLAG_APPCONTAINER_CHECKS: u32 = 8388608u32;
10803 pub const SECPKG_FLAG_APPCONTAINER_PASSTHROUGH: u32 = 4194304u32;
10804 pub const SECPKG_FLAG_APPLY_LOOPBACK: u32 = 33554432u32;
10805 pub const SECPKG_FLAG_ASCII_BUFFERS: u32 = 16384u32;
10806 pub const SECPKG_FLAG_CLIENT_ONLY: u32 = 64u32;
10807 pub const SECPKG_FLAG_CONNECTION: u32 = 16u32;
10808 pub const SECPKG_FLAG_CREDENTIAL_ISOLATION_ENABLED: u32 = 16777216u32;
10809 pub const SECPKG_FLAG_DATAGRAM: u32 = 8u32;
10810 pub const SECPKG_FLAG_DELEGATION: u32 = 131072u32;
10811 pub const SECPKG_FLAG_EXTENDED_ERROR: u32 = 128u32;
10812 pub const SECPKG_FLAG_FRAGMENT: u32 = 32768u32;
10813 pub const SECPKG_FLAG_GSS_COMPATIBLE: u32 = 4096u32;
10814 pub const SECPKG_FLAG_IMPERSONATION: u32 = 256u32;
10815 pub const SECPKG_FLAG_INTEGRITY: u32 = 1u32;
10816 pub const SECPKG_FLAG_LOGON: u32 = 8192u32;
10817 pub const SECPKG_FLAG_MULTI_REQUIRED: u32 = 32u32;
10818 pub const SECPKG_FLAG_MUTUAL_AUTH: u32 = 65536u32;
10819 pub const SECPKG_FLAG_NEGOTIABLE: u32 = 2048u32;
10820 pub const SECPKG_FLAG_NEGOTIABLE2: u32 = 2097152u32;
10821 pub const SECPKG_FLAG_NEGO_EXTENDER: u32 = 1048576u32;
10822 pub const SECPKG_FLAG_PRIVACY: u32 = 2u32;
10823 pub const SECPKG_FLAG_READONLY_WITH_CHECKSUM: u32 = 262144u32;
10824 pub const SECPKG_FLAG_RESTRICTED_TOKENS: u32 = 524288u32;
10825 pub const SECPKG_FLAG_STREAM: u32 = 1024u32;
10826 pub const SECPKG_FLAG_TOKEN_ONLY: u32 = 4u32;
10827 #[derive(:: std :: clone :: Clone)]
10828 #[repr(C)]
10829 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials", feature = "Win32_System_Kernel", feature = "Win32_System_SystemServices"))]
10830 pub struct SECPKG_FUNCTION_TABLE {
10831     pub InitializePackage: ::std::option::Option<PLSA_AP_INITIALIZE_PACKAGE>,
10832     pub LogonUserA: ::std::option::Option<PLSA_AP_LOGON_USER>,
10833     pub CallPackage: ::std::option::Option<PLSA_AP_CALL_PACKAGE>,
10834     pub LogonTerminated: ::std::option::Option<PLSA_AP_LOGON_TERMINATED>,
10835     pub CallPackageUntrusted: ::std::option::Option<PLSA_AP_CALL_PACKAGE>,
10836     pub CallPackagePassthrough: ::std::option::Option<PLSA_AP_CALL_PACKAGE_PASSTHROUGH>,
10837     pub LogonUserExA: ::std::option::Option<PLSA_AP_LOGON_USER_EX>,
10838     pub LogonUserEx2: ::std::option::Option<PLSA_AP_LOGON_USER_EX2>,
10839     pub Initialize: ::std::option::Option<SpInitializeFn>,
10840     pub Shutdown: ::std::option::Option<SpShutdownFn>,
10841     pub GetInfo: ::std::option::Option<SpGetInfoFn>,
10842     pub AcceptCredentials: ::std::option::Option<SpAcceptCredentialsFn>,
10843     pub AcquireCredentialsHandleA: ::std::option::Option<SpAcquireCredentialsHandleFn>,
10844     pub QueryCredentialsAttributesA: ::std::option::Option<SpQueryCredentialsAttributesFn>,
10845     pub FreeCredentialsHandle: ::std::option::Option<SpFreeCredentialsHandleFn>,
10846     pub SaveCredentials: ::std::option::Option<SpSaveCredentialsFn>,
10847     pub GetCredentials: ::std::option::Option<SpGetCredentialsFn>,
10848     pub DeleteCredentials: ::std::option::Option<SpDeleteCredentialsFn>,
10849     pub InitLsaModeContext: ::std::option::Option<SpInitLsaModeContextFn>,
10850     pub AcceptLsaModeContext: ::std::option::Option<SpAcceptLsaModeContextFn>,
10851     pub DeleteContext: ::std::option::Option<SpDeleteContextFn>,
10852     pub ApplyControlToken: ::std::option::Option<SpApplyControlTokenFn>,
10853     pub GetUserInfo: ::std::option::Option<SpGetUserInfoFn>,
10854     pub GetExtendedInformation: ::std::option::Option<SpGetExtendedInformationFn>,
10855     pub QueryContextAttributesA: ::std::option::Option<SpQueryContextAttributesFn>,
10856     pub AddCredentialsA: ::std::option::Option<SpAddCredentialsFn>,
10857     pub SetExtendedInformation: ::std::option::Option<SpSetExtendedInformationFn>,
10858     pub SetContextAttributesA: ::std::option::Option<SpSetContextAttributesFn>,
10859     pub SetCredentialsAttributesA: ::std::option::Option<SpSetCredentialsAttributesFn>,
10860     pub ChangeAccountPasswordA: ::std::option::Option<SpChangeAccountPasswordFn>,
10861     pub QueryMetaData: ::std::option::Option<SpQueryMetaDataFn>,
10862     pub ExchangeMetaData: ::std::option::Option<SpExchangeMetaDataFn>,
10863     pub GetCredUIContext: ::std::option::Option<SpGetCredUIContextFn>,
10864     pub UpdateCredentials: ::std::option::Option<SpUpdateCredentialsFn>,
10865     pub ValidateTargetInfo: ::std::option::Option<SpValidateTargetInfoFn>,
10866     pub PostLogonUser: ::std::option::Option<LSA_AP_POST_LOGON_USER>,
10867     pub GetRemoteCredGuardLogonBuffer: ::std::option::Option<SpGetRemoteCredGuardLogonBufferFn>,
10868     pub GetRemoteCredGuardSupplementalCreds: ::std::option::Option<SpGetRemoteCredGuardSupplementalCredsFn>,
10869     pub GetTbalSupplementalCreds: ::std::option::Option<SpGetTbalSupplementalCredsFn>,
10870     pub LogonUserEx3: ::std::option::Option<PLSA_AP_LOGON_USER_EX3>,
10871     pub PreLogonUserSurrogate: ::std::option::Option<PLSA_AP_PRE_LOGON_USER_SURROGATE>,
10872     pub PostLogonUserSurrogate: ::std::option::Option<PLSA_AP_POST_LOGON_USER_SURROGATE>,
10873 }
10874 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials", feature = "Win32_System_Kernel", feature = "Win32_System_SystemServices"))]
10875 impl SECPKG_FUNCTION_TABLE {}
10876 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials", feature = "Win32_System_Kernel", feature = "Win32_System_SystemServices"))]
10877 impl ::std::default::Default for SECPKG_FUNCTION_TABLE {
10878     fn default() -> Self {
10879         unsafe { ::std::mem::zeroed() }
10880     }
10881 }
10882 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials", feature = "Win32_System_Kernel", feature = "Win32_System_SystemServices"))]
10883 impl ::std::fmt::Debug for SECPKG_FUNCTION_TABLE {
10884     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10885         fmt.debug_struct("SECPKG_FUNCTION_TABLE").finish()
10886     }
10887 }
10888 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials", feature = "Win32_System_Kernel", feature = "Win32_System_SystemServices"))]
10889 impl ::std::cmp::PartialEq for SECPKG_FUNCTION_TABLE {
10890     fn eq(&self, other: &Self) -> bool {
10891         self.InitializePackage.map(|f| f as usize) == other.InitializePackage.map(|f| f as usize)
10892             && self.LogonUserA.map(|f| f as usize) == other.LogonUserA.map(|f| f as usize)
10893             && self.CallPackage.map(|f| f as usize) == other.CallPackage.map(|f| f as usize)
10894             && self.LogonTerminated.map(|f| f as usize) == other.LogonTerminated.map(|f| f as usize)
10895             && self.CallPackageUntrusted.map(|f| f as usize) == other.CallPackageUntrusted.map(|f| f as usize)
10896             && self.CallPackagePassthrough.map(|f| f as usize) == other.CallPackagePassthrough.map(|f| f as usize)
10897             && self.LogonUserExA.map(|f| f as usize) == other.LogonUserExA.map(|f| f as usize)
10898             && self.LogonUserEx2.map(|f| f as usize) == other.LogonUserEx2.map(|f| f as usize)
10899             && self.Initialize.map(|f| f as usize) == other.Initialize.map(|f| f as usize)
10900             && self.Shutdown.map(|f| f as usize) == other.Shutdown.map(|f| f as usize)
10901             && self.GetInfo.map(|f| f as usize) == other.GetInfo.map(|f| f as usize)
10902             && self.AcceptCredentials.map(|f| f as usize) == other.AcceptCredentials.map(|f| f as usize)
10903             && self.AcquireCredentialsHandleA.map(|f| f as usize) == other.AcquireCredentialsHandleA.map(|f| f as usize)
10904             && self.QueryCredentialsAttributesA.map(|f| f as usize) == other.QueryCredentialsAttributesA.map(|f| f as usize)
10905             && self.FreeCredentialsHandle.map(|f| f as usize) == other.FreeCredentialsHandle.map(|f| f as usize)
10906             && self.SaveCredentials.map(|f| f as usize) == other.SaveCredentials.map(|f| f as usize)
10907             && self.GetCredentials.map(|f| f as usize) == other.GetCredentials.map(|f| f as usize)
10908             && self.DeleteCredentials.map(|f| f as usize) == other.DeleteCredentials.map(|f| f as usize)
10909             && self.InitLsaModeContext.map(|f| f as usize) == other.InitLsaModeContext.map(|f| f as usize)
10910             && self.AcceptLsaModeContext.map(|f| f as usize) == other.AcceptLsaModeContext.map(|f| f as usize)
10911             && self.DeleteContext.map(|f| f as usize) == other.DeleteContext.map(|f| f as usize)
10912             && self.ApplyControlToken.map(|f| f as usize) == other.ApplyControlToken.map(|f| f as usize)
10913             && self.GetUserInfo.map(|f| f as usize) == other.GetUserInfo.map(|f| f as usize)
10914             && self.GetExtendedInformation.map(|f| f as usize) == other.GetExtendedInformation.map(|f| f as usize)
10915             && self.QueryContextAttributesA.map(|f| f as usize) == other.QueryContextAttributesA.map(|f| f as usize)
10916             && self.AddCredentialsA.map(|f| f as usize) == other.AddCredentialsA.map(|f| f as usize)
10917             && self.SetExtendedInformation.map(|f| f as usize) == other.SetExtendedInformation.map(|f| f as usize)
10918             && self.SetContextAttributesA.map(|f| f as usize) == other.SetContextAttributesA.map(|f| f as usize)
10919             && self.SetCredentialsAttributesA.map(|f| f as usize) == other.SetCredentialsAttributesA.map(|f| f as usize)
10920             && self.ChangeAccountPasswordA.map(|f| f as usize) == other.ChangeAccountPasswordA.map(|f| f as usize)
10921             && self.QueryMetaData.map(|f| f as usize) == other.QueryMetaData.map(|f| f as usize)
10922             && self.ExchangeMetaData.map(|f| f as usize) == other.ExchangeMetaData.map(|f| f as usize)
10923             && self.GetCredUIContext.map(|f| f as usize) == other.GetCredUIContext.map(|f| f as usize)
10924             && self.UpdateCredentials.map(|f| f as usize) == other.UpdateCredentials.map(|f| f as usize)
10925             && self.ValidateTargetInfo.map(|f| f as usize) == other.ValidateTargetInfo.map(|f| f as usize)
10926             && self.PostLogonUser.map(|f| f as usize) == other.PostLogonUser.map(|f| f as usize)
10927             && self.GetRemoteCredGuardLogonBuffer.map(|f| f as usize) == other.GetRemoteCredGuardLogonBuffer.map(|f| f as usize)
10928             && self.GetRemoteCredGuardSupplementalCreds.map(|f| f as usize) == other.GetRemoteCredGuardSupplementalCreds.map(|f| f as usize)
10929             && self.GetTbalSupplementalCreds.map(|f| f as usize) == other.GetTbalSupplementalCreds.map(|f| f as usize)
10930             && self.LogonUserEx3.map(|f| f as usize) == other.LogonUserEx3.map(|f| f as usize)
10931             && self.PreLogonUserSurrogate.map(|f| f as usize) == other.PreLogonUserSurrogate.map(|f| f as usize)
10932             && self.PostLogonUserSurrogate.map(|f| f as usize) == other.PostLogonUserSurrogate.map(|f| f as usize)
10933     }
10934 }
10935 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials", feature = "Win32_System_Kernel", feature = "Win32_System_SystemServices"))]
10936 impl ::std::cmp::Eq for SECPKG_FUNCTION_TABLE {}
10937 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials", feature = "Win32_System_Kernel", feature = "Win32_System_SystemServices"))]
10938 unsafe impl ::windows::runtime::Abi for SECPKG_FUNCTION_TABLE {
10939     type Abi = ::std::mem::ManuallyDrop<Self>;
10940     type DefaultType = Self;
10941 }
10942 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10943 #[repr(C)]
10944 pub struct SECPKG_GSS_INFO {
10945     pub EncodedIdLength: u32,
10946     pub EncodedId: [u8; 4],
10947 }
10948 impl SECPKG_GSS_INFO {}
10949 impl ::std::default::Default for SECPKG_GSS_INFO {
10950     fn default() -> Self {
10951         unsafe { ::std::mem::zeroed() }
10952     }
10953 }
10954 impl ::std::fmt::Debug for SECPKG_GSS_INFO {
10955     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10956         fmt.debug_struct("SECPKG_GSS_INFO").field("EncodedIdLength", &self.EncodedIdLength).field("EncodedId", &self.EncodedId).finish()
10957     }
10958 }
10959 impl ::std::cmp::PartialEq for SECPKG_GSS_INFO {
10960     fn eq(&self, other: &Self) -> bool {
10961         self.EncodedIdLength == other.EncodedIdLength && self.EncodedId == other.EncodedId
10962     }
10963 }
10964 impl ::std::cmp::Eq for SECPKG_GSS_INFO {}
10965 unsafe impl ::windows::runtime::Abi for SECPKG_GSS_INFO {
10966     type Abi = Self;
10967     type DefaultType = Self;
10968 }
10969 pub const SECPKG_ID_NONE: u32 = 65535u32;
10970 pub const SECPKG_INTERFACE_VERSION: u32 = 65536u32;
10971 pub const SECPKG_INTERFACE_VERSION_10: u32 = 33554432u32;
10972 pub const SECPKG_INTERFACE_VERSION_2: u32 = 131072u32;
10973 pub const SECPKG_INTERFACE_VERSION_3: u32 = 262144u32;
10974 pub const SECPKG_INTERFACE_VERSION_4: u32 = 524288u32;
10975 pub const SECPKG_INTERFACE_VERSION_5: u32 = 1048576u32;
10976 pub const SECPKG_INTERFACE_VERSION_6: u32 = 2097152u32;
10977 pub const SECPKG_INTERFACE_VERSION_7: u32 = 4194304u32;
10978 pub const SECPKG_INTERFACE_VERSION_8: u32 = 8388608u32;
10979 pub const SECPKG_INTERFACE_VERSION_9: u32 = 16777216u32;
10980 #[derive(:: std :: clone :: Clone)]
10981 #[repr(C)]
10982 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
10983 pub struct SECPKG_KERNEL_FUNCTIONS {
10984     pub AllocateHeap: ::std::option::Option<PLSA_ALLOCATE_LSA_HEAP>,
10985     pub FreeHeap: ::std::option::Option<PLSA_FREE_LSA_HEAP>,
10986     pub CreateContextList: ::std::option::Option<PKSEC_CREATE_CONTEXT_LIST>,
10987     pub InsertListEntry: ::std::option::Option<PKSEC_INSERT_LIST_ENTRY>,
10988     pub ReferenceListEntry: ::std::option::Option<PKSEC_REFERENCE_LIST_ENTRY>,
10989     pub DereferenceListEntry: ::std::option::Option<PKSEC_DEREFERENCE_LIST_ENTRY>,
10990     pub SerializeWinntAuthData: ::std::option::Option<PKSEC_SERIALIZE_WINNT_AUTH_DATA>,
10991     pub SerializeSchannelAuthData: ::std::option::Option<PKSEC_SERIALIZE_SCHANNEL_AUTH_DATA>,
10992     pub LocatePackageById: ::std::option::Option<PKSEC_LOCATE_PKG_BY_ID>,
10993 }
10994 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
10995 impl SECPKG_KERNEL_FUNCTIONS {}
10996 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
10997 impl ::std::default::Default for SECPKG_KERNEL_FUNCTIONS {
10998     fn default() -> Self {
10999         unsafe { ::std::mem::zeroed() }
11000     }
11001 }
11002 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
11003 impl ::std::fmt::Debug for SECPKG_KERNEL_FUNCTIONS {
11004     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11005         fmt.debug_struct("SECPKG_KERNEL_FUNCTIONS").finish()
11006     }
11007 }
11008 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
11009 impl ::std::cmp::PartialEq for SECPKG_KERNEL_FUNCTIONS {
11010     fn eq(&self, other: &Self) -> bool {
11011         self.AllocateHeap.map(|f| f as usize) == other.AllocateHeap.map(|f| f as usize)
11012             && self.FreeHeap.map(|f| f as usize) == other.FreeHeap.map(|f| f as usize)
11013             && self.CreateContextList.map(|f| f as usize) == other.CreateContextList.map(|f| f as usize)
11014             && self.InsertListEntry.map(|f| f as usize) == other.InsertListEntry.map(|f| f as usize)
11015             && self.ReferenceListEntry.map(|f| f as usize) == other.ReferenceListEntry.map(|f| f as usize)
11016             && self.DereferenceListEntry.map(|f| f as usize) == other.DereferenceListEntry.map(|f| f as usize)
11017             && self.SerializeWinntAuthData.map(|f| f as usize) == other.SerializeWinntAuthData.map(|f| f as usize)
11018             && self.SerializeSchannelAuthData.map(|f| f as usize) == other.SerializeSchannelAuthData.map(|f| f as usize)
11019             && self.LocatePackageById.map(|f| f as usize) == other.LocatePackageById.map(|f| f as usize)
11020     }
11021 }
11022 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
11023 impl ::std::cmp::Eq for SECPKG_KERNEL_FUNCTIONS {}
11024 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
11025 unsafe impl ::windows::runtime::Abi for SECPKG_KERNEL_FUNCTIONS {
11026     type Abi = ::std::mem::ManuallyDrop<Self>;
11027     type DefaultType = Self;
11028 }
11029 #[derive(:: std :: clone :: Clone)]
11030 #[repr(C)]
11031 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
11032 pub struct SECPKG_KERNEL_FUNCTION_TABLE {
11033     pub Initialize: ::std::option::Option<KspInitPackageFn>,
11034     pub DeleteContext: ::std::option::Option<KspDeleteContextFn>,
11035     pub InitContext: ::std::option::Option<KspInitContextFn>,
11036     pub MapHandle: ::std::option::Option<KspMapHandleFn>,
11037     pub Sign: ::std::option::Option<KspMakeSignatureFn>,
11038     pub Verify: ::std::option::Option<KspVerifySignatureFn>,
11039     pub Seal: ::std::option::Option<KspSealMessageFn>,
11040     pub Unseal: ::std::option::Option<KspUnsealMessageFn>,
11041     pub GetToken: ::std::option::Option<KspGetTokenFn>,
11042     pub QueryAttributes: ::std::option::Option<KspQueryAttributesFn>,
11043     pub CompleteToken: ::std::option::Option<KspCompleteTokenFn>,
11044     pub ExportContext: ::std::option::Option<SpExportSecurityContextFn>,
11045     pub ImportContext: ::std::option::Option<SpImportSecurityContextFn>,
11046     pub SetPackagePagingMode: ::std::option::Option<KspSetPagingModeFn>,
11047     pub SerializeAuthData: ::std::option::Option<KspSerializeAuthDataFn>,
11048 }
11049 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
11050 impl SECPKG_KERNEL_FUNCTION_TABLE {}
11051 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
11052 impl ::std::default::Default for SECPKG_KERNEL_FUNCTION_TABLE {
11053     fn default() -> Self {
11054         unsafe { ::std::mem::zeroed() }
11055     }
11056 }
11057 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
11058 impl ::std::fmt::Debug for SECPKG_KERNEL_FUNCTION_TABLE {
11059     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11060         fmt.debug_struct("SECPKG_KERNEL_FUNCTION_TABLE").finish()
11061     }
11062 }
11063 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
11064 impl ::std::cmp::PartialEq for SECPKG_KERNEL_FUNCTION_TABLE {
11065     fn eq(&self, other: &Self) -> bool {
11066         self.Initialize.map(|f| f as usize) == other.Initialize.map(|f| f as usize)
11067             && self.DeleteContext.map(|f| f as usize) == other.DeleteContext.map(|f| f as usize)
11068             && self.InitContext.map(|f| f as usize) == other.InitContext.map(|f| f as usize)
11069             && self.MapHandle.map(|f| f as usize) == other.MapHandle.map(|f| f as usize)
11070             && self.Sign.map(|f| f as usize) == other.Sign.map(|f| f as usize)
11071             && self.Verify.map(|f| f as usize) == other.Verify.map(|f| f as usize)
11072             && self.Seal.map(|f| f as usize) == other.Seal.map(|f| f as usize)
11073             && self.Unseal.map(|f| f as usize) == other.Unseal.map(|f| f as usize)
11074             && self.GetToken.map(|f| f as usize) == other.GetToken.map(|f| f as usize)
11075             && self.QueryAttributes.map(|f| f as usize) == other.QueryAttributes.map(|f| f as usize)
11076             && self.CompleteToken.map(|f| f as usize) == other.CompleteToken.map(|f| f as usize)
11077             && self.ExportContext.map(|f| f as usize) == other.ExportContext.map(|f| f as usize)
11078             && self.ImportContext.map(|f| f as usize) == other.ImportContext.map(|f| f as usize)
11079             && self.SetPackagePagingMode.map(|f| f as usize) == other.SetPackagePagingMode.map(|f| f as usize)
11080             && self.SerializeAuthData.map(|f| f as usize) == other.SerializeAuthData.map(|f| f as usize)
11081     }
11082 }
11083 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
11084 impl ::std::cmp::Eq for SECPKG_KERNEL_FUNCTION_TABLE {}
11085 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
11086 unsafe impl ::windows::runtime::Abi for SECPKG_KERNEL_FUNCTION_TABLE {
11087     type Abi = ::std::mem::ManuallyDrop<Self>;
11088     type DefaultType = Self;
11089 }
11090 pub const SECPKG_MAX_OID_LENGTH: u32 = 32u32;
11091 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11092 #[repr(C)]
11093 pub struct SECPKG_MUTUAL_AUTH_LEVEL {
11094     pub MutualAuthLevel: u32,
11095 }
11096 impl SECPKG_MUTUAL_AUTH_LEVEL {}
11097 impl ::std::default::Default for SECPKG_MUTUAL_AUTH_LEVEL {
11098     fn default() -> Self {
11099         unsafe { ::std::mem::zeroed() }
11100     }
11101 }
11102 impl ::std::fmt::Debug for SECPKG_MUTUAL_AUTH_LEVEL {
11103     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11104         fmt.debug_struct("SECPKG_MUTUAL_AUTH_LEVEL").field("MutualAuthLevel", &self.MutualAuthLevel).finish()
11105     }
11106 }
11107 impl ::std::cmp::PartialEq for SECPKG_MUTUAL_AUTH_LEVEL {
11108     fn eq(&self, other: &Self) -> bool {
11109         self.MutualAuthLevel == other.MutualAuthLevel
11110     }
11111 }
11112 impl ::std::cmp::Eq for SECPKG_MUTUAL_AUTH_LEVEL {}
11113 unsafe impl ::windows::runtime::Abi for SECPKG_MUTUAL_AUTH_LEVEL {
11114     type Abi = Self;
11115     type DefaultType = Self;
11116 }
11117 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11118 #[repr(transparent)]
11119 pub struct SECPKG_NAME_TYPE(pub i32);
11120 pub const SecNameSamCompatible: SECPKG_NAME_TYPE = SECPKG_NAME_TYPE(0i32);
11121 pub const SecNameAlternateId: SECPKG_NAME_TYPE = SECPKG_NAME_TYPE(1i32);
11122 pub const SecNameFlat: SECPKG_NAME_TYPE = SECPKG_NAME_TYPE(2i32);
11123 pub const SecNameDN: SECPKG_NAME_TYPE = SECPKG_NAME_TYPE(3i32);
11124 pub const SecNameSPN: SECPKG_NAME_TYPE = SECPKG_NAME_TYPE(4i32);
11125 impl ::std::convert::From<i32> for SECPKG_NAME_TYPE {
11126     fn from(value: i32) -> Self {
11127         Self(value)
11128     }
11129 }
11130 unsafe impl ::windows::runtime::Abi for SECPKG_NAME_TYPE {
11131     type Abi = Self;
11132     type DefaultType = Self;
11133 }
11134 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11135 #[repr(C)]
11136 pub struct SECPKG_NEGO2_INFO {
11137     pub AuthScheme: [u8; 16],
11138     pub PackageFlags: u32,
11139 }
11140 impl SECPKG_NEGO2_INFO {}
11141 impl ::std::default::Default for SECPKG_NEGO2_INFO {
11142     fn default() -> Self {
11143         unsafe { ::std::mem::zeroed() }
11144     }
11145 }
11146 impl ::std::fmt::Debug for SECPKG_NEGO2_INFO {
11147     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11148         fmt.debug_struct("SECPKG_NEGO2_INFO").field("AuthScheme", &self.AuthScheme).field("PackageFlags", &self.PackageFlags).finish()
11149     }
11150 }
11151 impl ::std::cmp::PartialEq for SECPKG_NEGO2_INFO {
11152     fn eq(&self, other: &Self) -> bool {
11153         self.AuthScheme == other.AuthScheme && self.PackageFlags == other.PackageFlags
11154     }
11155 }
11156 impl ::std::cmp::Eq for SECPKG_NEGO2_INFO {}
11157 unsafe impl ::windows::runtime::Abi for SECPKG_NEGO2_INFO {
11158     type Abi = Self;
11159     type DefaultType = Self;
11160 }
11161 pub const SECPKG_NEGOTIATION_COMPLETE: u32 = 0u32;
11162 pub const SECPKG_NEGOTIATION_DIRECT: u32 = 3u32;
11163 pub const SECPKG_NEGOTIATION_IN_PROGRESS: u32 = 2u32;
11164 pub const SECPKG_NEGOTIATION_OPTIMISTIC: u32 = 1u32;
11165 pub const SECPKG_NEGOTIATION_TRY_MULTICRED: u32 = 4u32;
11166 pub const SECPKG_OPTIONS_PERMANENT: u32 = 1u32;
11167 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11168 #[repr(transparent)]
11169 pub struct SECPKG_PACKAGE_CHANGE_TYPE(pub u32);
11170 pub const SECPKG_PACKAGE_CHANGE_LOAD: SECPKG_PACKAGE_CHANGE_TYPE = SECPKG_PACKAGE_CHANGE_TYPE(0u32);
11171 pub const SECPKG_PACKAGE_CHANGE_UNLOAD: SECPKG_PACKAGE_CHANGE_TYPE = SECPKG_PACKAGE_CHANGE_TYPE(1u32);
11172 pub const SECPKG_PACKAGE_CHANGE_SELECT: SECPKG_PACKAGE_CHANGE_TYPE = SECPKG_PACKAGE_CHANGE_TYPE(2u32);
11173 impl ::std::convert::From<u32> for SECPKG_PACKAGE_CHANGE_TYPE {
11174     fn from(value: u32) -> Self {
11175         Self(value)
11176     }
11177 }
11178 unsafe impl ::windows::runtime::Abi for SECPKG_PACKAGE_CHANGE_TYPE {
11179     type Abi = Self;
11180     type DefaultType = Self;
11181 }
11182 impl ::std::ops::BitOr for SECPKG_PACKAGE_CHANGE_TYPE {
11183     type Output = Self;
11184     fn bitor(self, rhs: Self) -> Self {
11185         Self(self.0 | rhs.0)
11186     }
11187 }
11188 impl ::std::ops::BitAnd for SECPKG_PACKAGE_CHANGE_TYPE {
11189     type Output = Self;
11190     fn bitand(self, rhs: Self) -> Self {
11191         Self(self.0 & rhs.0)
11192     }
11193 }
11194 impl ::std::ops::BitOrAssign for SECPKG_PACKAGE_CHANGE_TYPE {
11195     fn bitor_assign(&mut self, rhs: Self) {
11196         self.0.bitor_assign(rhs.0)
11197     }
11198 }
11199 impl ::std::ops::BitAndAssign for SECPKG_PACKAGE_CHANGE_TYPE {
11200     fn bitand_assign(&mut self, rhs: Self) {
11201         self.0.bitand_assign(rhs.0)
11202     }
11203 }
11204 impl ::std::ops::Not for SECPKG_PACKAGE_CHANGE_TYPE {
11205     type Output = Self;
11206     fn not(self) -> Self {
11207         Self(self.0.not())
11208     }
11209 }
11210 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11211 #[repr(C)]
11212 #[cfg(feature = "Win32_Foundation")]
11213 pub struct SECPKG_PARAMETERS {
11214     pub Version: u32,
11215     pub MachineState: u32,
11216     pub SetupMode: u32,
11217     pub DomainSid: super::super::super::Foundation::PSID,
11218     pub DomainName: super::super::super::Foundation::UNICODE_STRING,
11219     pub DnsDomainName: super::super::super::Foundation::UNICODE_STRING,
11220     pub DomainGuid: ::windows::runtime::GUID,
11221 }
11222 #[cfg(feature = "Win32_Foundation")]
11223 impl SECPKG_PARAMETERS {}
11224 #[cfg(feature = "Win32_Foundation")]
11225 impl ::std::default::Default for SECPKG_PARAMETERS {
11226     fn default() -> Self {
11227         unsafe { ::std::mem::zeroed() }
11228     }
11229 }
11230 #[cfg(feature = "Win32_Foundation")]
11231 impl ::std::fmt::Debug for SECPKG_PARAMETERS {
11232     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11233         fmt.debug_struct("SECPKG_PARAMETERS")
11234             .field("Version", &self.Version)
11235             .field("MachineState", &self.MachineState)
11236             .field("SetupMode", &self.SetupMode)
11237             .field("DomainSid", &self.DomainSid)
11238             .field("DomainName", &self.DomainName)
11239             .field("DnsDomainName", &self.DnsDomainName)
11240             .field("DomainGuid", &self.DomainGuid)
11241             .finish()
11242     }
11243 }
11244 #[cfg(feature = "Win32_Foundation")]
11245 impl ::std::cmp::PartialEq for SECPKG_PARAMETERS {
11246     fn eq(&self, other: &Self) -> bool {
11247         self.Version == other.Version && self.MachineState == other.MachineState && self.SetupMode == other.SetupMode && self.DomainSid == other.DomainSid && self.DomainName == other.DomainName && self.DnsDomainName == other.DnsDomainName && self.DomainGuid == other.DomainGuid
11248     }
11249 }
11250 #[cfg(feature = "Win32_Foundation")]
11251 impl ::std::cmp::Eq for SECPKG_PARAMETERS {}
11252 #[cfg(feature = "Win32_Foundation")]
11253 unsafe impl ::windows::runtime::Abi for SECPKG_PARAMETERS {
11254     type Abi = Self;
11255     type DefaultType = Self;
11256 }
11257 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11258 #[repr(C)]
11259 #[cfg(feature = "Win32_Foundation")]
11260 pub struct SECPKG_POST_LOGON_USER_INFO {
11261     pub Flags: u32,
11262     pub LogonId: super::super::super::Foundation::LUID,
11263     pub LinkedLogonId: super::super::super::Foundation::LUID,
11264 }
11265 #[cfg(feature = "Win32_Foundation")]
11266 impl SECPKG_POST_LOGON_USER_INFO {}
11267 #[cfg(feature = "Win32_Foundation")]
11268 impl ::std::default::Default for SECPKG_POST_LOGON_USER_INFO {
11269     fn default() -> Self {
11270         unsafe { ::std::mem::zeroed() }
11271     }
11272 }
11273 #[cfg(feature = "Win32_Foundation")]
11274 impl ::std::fmt::Debug for SECPKG_POST_LOGON_USER_INFO {
11275     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11276         fmt.debug_struct("SECPKG_POST_LOGON_USER_INFO").field("Flags", &self.Flags).field("LogonId", &self.LogonId).field("LinkedLogonId", &self.LinkedLogonId).finish()
11277     }
11278 }
11279 #[cfg(feature = "Win32_Foundation")]
11280 impl ::std::cmp::PartialEq for SECPKG_POST_LOGON_USER_INFO {
11281     fn eq(&self, other: &Self) -> bool {
11282         self.Flags == other.Flags && self.LogonId == other.LogonId && self.LinkedLogonId == other.LinkedLogonId
11283     }
11284 }
11285 #[cfg(feature = "Win32_Foundation")]
11286 impl ::std::cmp::Eq for SECPKG_POST_LOGON_USER_INFO {}
11287 #[cfg(feature = "Win32_Foundation")]
11288 unsafe impl ::windows::runtime::Abi for SECPKG_POST_LOGON_USER_INFO {
11289     type Abi = Self;
11290     type DefaultType = Self;
11291 }
11292 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11293 #[repr(C)]
11294 #[cfg(feature = "Win32_Foundation")]
11295 pub struct SECPKG_PRIMARY_CRED {
11296     pub LogonId: super::super::super::Foundation::LUID,
11297     pub DownlevelName: super::super::super::Foundation::UNICODE_STRING,
11298     pub DomainName: super::super::super::Foundation::UNICODE_STRING,
11299     pub Password: super::super::super::Foundation::UNICODE_STRING,
11300     pub OldPassword: super::super::super::Foundation::UNICODE_STRING,
11301     pub UserSid: super::super::super::Foundation::PSID,
11302     pub Flags: u32,
11303     pub DnsDomainName: super::super::super::Foundation::UNICODE_STRING,
11304     pub Upn: super::super::super::Foundation::UNICODE_STRING,
11305     pub LogonServer: super::super::super::Foundation::UNICODE_STRING,
11306     pub Spare1: super::super::super::Foundation::UNICODE_STRING,
11307     pub Spare2: super::super::super::Foundation::UNICODE_STRING,
11308     pub Spare3: super::super::super::Foundation::UNICODE_STRING,
11309     pub Spare4: super::super::super::Foundation::UNICODE_STRING,
11310 }
11311 #[cfg(feature = "Win32_Foundation")]
11312 impl SECPKG_PRIMARY_CRED {}
11313 #[cfg(feature = "Win32_Foundation")]
11314 impl ::std::default::Default for SECPKG_PRIMARY_CRED {
11315     fn default() -> Self {
11316         unsafe { ::std::mem::zeroed() }
11317     }
11318 }
11319 #[cfg(feature = "Win32_Foundation")]
11320 impl ::std::fmt::Debug for SECPKG_PRIMARY_CRED {
11321     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11322         fmt.debug_struct("SECPKG_PRIMARY_CRED")
11323             .field("LogonId", &self.LogonId)
11324             .field("DownlevelName", &self.DownlevelName)
11325             .field("DomainName", &self.DomainName)
11326             .field("Password", &self.Password)
11327             .field("OldPassword", &self.OldPassword)
11328             .field("UserSid", &self.UserSid)
11329             .field("Flags", &self.Flags)
11330             .field("DnsDomainName", &self.DnsDomainName)
11331             .field("Upn", &self.Upn)
11332             .field("LogonServer", &self.LogonServer)
11333             .field("Spare1", &self.Spare1)
11334             .field("Spare2", &self.Spare2)
11335             .field("Spare3", &self.Spare3)
11336             .field("Spare4", &self.Spare4)
11337             .finish()
11338     }
11339 }
11340 #[cfg(feature = "Win32_Foundation")]
11341 impl ::std::cmp::PartialEq for SECPKG_PRIMARY_CRED {
11342     fn eq(&self, other: &Self) -> bool {
11343         self.LogonId == other.LogonId && self.DownlevelName == other.DownlevelName && self.DomainName == other.DomainName && self.Password == other.Password && self.OldPassword == other.OldPassword && self.UserSid == other.UserSid && self.Flags == other.Flags && self.DnsDomainName == other.DnsDomainName && self.Upn == other.Upn && self.LogonServer == other.LogonServer && self.Spare1 == other.Spare1 && self.Spare2 == other.Spare2 && self.Spare3 == other.Spare3 && self.Spare4 == other.Spare4
11344     }
11345 }
11346 #[cfg(feature = "Win32_Foundation")]
11347 impl ::std::cmp::Eq for SECPKG_PRIMARY_CRED {}
11348 #[cfg(feature = "Win32_Foundation")]
11349 unsafe impl ::windows::runtime::Abi for SECPKG_PRIMARY_CRED {
11350     type Abi = Self;
11351     type DefaultType = Self;
11352 }
11353 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11354 #[repr(C)]
11355 #[cfg(feature = "Win32_Foundation")]
11356 pub struct SECPKG_PRIMARY_CRED_EX {
11357     pub LogonId: super::super::super::Foundation::LUID,
11358     pub DownlevelName: super::super::super::Foundation::UNICODE_STRING,
11359     pub DomainName: super::super::super::Foundation::UNICODE_STRING,
11360     pub Password: super::super::super::Foundation::UNICODE_STRING,
11361     pub OldPassword: super::super::super::Foundation::UNICODE_STRING,
11362     pub UserSid: super::super::super::Foundation::PSID,
11363     pub Flags: u32,
11364     pub DnsDomainName: super::super::super::Foundation::UNICODE_STRING,
11365     pub Upn: super::super::super::Foundation::UNICODE_STRING,
11366     pub LogonServer: super::super::super::Foundation::UNICODE_STRING,
11367     pub Spare1: super::super::super::Foundation::UNICODE_STRING,
11368     pub Spare2: super::super::super::Foundation::UNICODE_STRING,
11369     pub Spare3: super::super::super::Foundation::UNICODE_STRING,
11370     pub Spare4: super::super::super::Foundation::UNICODE_STRING,
11371     pub PackageId: usize,
11372     pub PrevLogonId: super::super::super::Foundation::LUID,
11373     pub FlagsEx: u32,
11374 }
11375 #[cfg(feature = "Win32_Foundation")]
11376 impl SECPKG_PRIMARY_CRED_EX {}
11377 #[cfg(feature = "Win32_Foundation")]
11378 impl ::std::default::Default for SECPKG_PRIMARY_CRED_EX {
11379     fn default() -> Self {
11380         unsafe { ::std::mem::zeroed() }
11381     }
11382 }
11383 #[cfg(feature = "Win32_Foundation")]
11384 impl ::std::fmt::Debug for SECPKG_PRIMARY_CRED_EX {
11385     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11386         fmt.debug_struct("SECPKG_PRIMARY_CRED_EX")
11387             .field("LogonId", &self.LogonId)
11388             .field("DownlevelName", &self.DownlevelName)
11389             .field("DomainName", &self.DomainName)
11390             .field("Password", &self.Password)
11391             .field("OldPassword", &self.OldPassword)
11392             .field("UserSid", &self.UserSid)
11393             .field("Flags", &self.Flags)
11394             .field("DnsDomainName", &self.DnsDomainName)
11395             .field("Upn", &self.Upn)
11396             .field("LogonServer", &self.LogonServer)
11397             .field("Spare1", &self.Spare1)
11398             .field("Spare2", &self.Spare2)
11399             .field("Spare3", &self.Spare3)
11400             .field("Spare4", &self.Spare4)
11401             .field("PackageId", &self.PackageId)
11402             .field("PrevLogonId", &self.PrevLogonId)
11403             .field("FlagsEx", &self.FlagsEx)
11404             .finish()
11405     }
11406 }
11407 #[cfg(feature = "Win32_Foundation")]
11408 impl ::std::cmp::PartialEq for SECPKG_PRIMARY_CRED_EX {
11409     fn eq(&self, other: &Self) -> bool {
11410         self.LogonId == other.LogonId
11411             && self.DownlevelName == other.DownlevelName
11412             && self.DomainName == other.DomainName
11413             && self.Password == other.Password
11414             && self.OldPassword == other.OldPassword
11415             && self.UserSid == other.UserSid
11416             && self.Flags == other.Flags
11417             && self.DnsDomainName == other.DnsDomainName
11418             && self.Upn == other.Upn
11419             && self.LogonServer == other.LogonServer
11420             && self.Spare1 == other.Spare1
11421             && self.Spare2 == other.Spare2
11422             && self.Spare3 == other.Spare3
11423             && self.Spare4 == other.Spare4
11424             && self.PackageId == other.PackageId
11425             && self.PrevLogonId == other.PrevLogonId
11426             && self.FlagsEx == other.FlagsEx
11427     }
11428 }
11429 #[cfg(feature = "Win32_Foundation")]
11430 impl ::std::cmp::Eq for SECPKG_PRIMARY_CRED_EX {}
11431 #[cfg(feature = "Win32_Foundation")]
11432 unsafe impl ::windows::runtime::Abi for SECPKG_PRIMARY_CRED_EX {
11433     type Abi = Self;
11434     type DefaultType = Self;
11435 }
11436 pub const SECPKG_PRIMARY_CRED_EX_FLAGS_EX_DELEGATION_TOKEN: u32 = 1u32;
11437 #[derive(:: std :: clone :: Clone)]
11438 #[repr(C)]
11439 #[cfg(feature = "Win32_Foundation")]
11440 pub struct SECPKG_REDIRECTED_LOGON_BUFFER {
11441     pub RedirectedLogonGuid: ::windows::runtime::GUID,
11442     pub RedirectedLogonHandle: super::super::super::Foundation::HANDLE,
11443     pub Init: ::std::option::Option<PLSA_REDIRECTED_LOGON_INIT>,
11444     pub Callback: ::std::option::Option<PLSA_REDIRECTED_LOGON_CALLBACK>,
11445     pub CleanupCallback: ::std::option::Option<PLSA_REDIRECTED_LOGON_CLEANUP_CALLBACK>,
11446     pub GetLogonCreds: ::std::option::Option<PLSA_REDIRECTED_LOGON_GET_LOGON_CREDS>,
11447     pub GetSupplementalCreds: ::std::option::Option<PLSA_REDIRECTED_LOGON_GET_SUPP_CREDS>,
11448 }
11449 #[cfg(feature = "Win32_Foundation")]
11450 impl SECPKG_REDIRECTED_LOGON_BUFFER {}
11451 #[cfg(feature = "Win32_Foundation")]
11452 impl ::std::default::Default for SECPKG_REDIRECTED_LOGON_BUFFER {
11453     fn default() -> Self {
11454         unsafe { ::std::mem::zeroed() }
11455     }
11456 }
11457 #[cfg(feature = "Win32_Foundation")]
11458 impl ::std::fmt::Debug for SECPKG_REDIRECTED_LOGON_BUFFER {
11459     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11460         fmt.debug_struct("SECPKG_REDIRECTED_LOGON_BUFFER").field("RedirectedLogonGuid", &self.RedirectedLogonGuid).field("RedirectedLogonHandle", &self.RedirectedLogonHandle).finish()
11461     }
11462 }
11463 #[cfg(feature = "Win32_Foundation")]
11464 impl ::std::cmp::PartialEq for SECPKG_REDIRECTED_LOGON_BUFFER {
11465     fn eq(&self, other: &Self) -> bool {
11466         self.RedirectedLogonGuid == other.RedirectedLogonGuid
11467             && self.RedirectedLogonHandle == other.RedirectedLogonHandle
11468             && self.Init.map(|f| f as usize) == other.Init.map(|f| f as usize)
11469             && self.Callback.map(|f| f as usize) == other.Callback.map(|f| f as usize)
11470             && self.CleanupCallback.map(|f| f as usize) == other.CleanupCallback.map(|f| f as usize)
11471             && self.GetLogonCreds.map(|f| f as usize) == other.GetLogonCreds.map(|f| f as usize)
11472             && self.GetSupplementalCreds.map(|f| f as usize) == other.GetSupplementalCreds.map(|f| f as usize)
11473     }
11474 }
11475 #[cfg(feature = "Win32_Foundation")]
11476 impl ::std::cmp::Eq for SECPKG_REDIRECTED_LOGON_BUFFER {}
11477 #[cfg(feature = "Win32_Foundation")]
11478 unsafe impl ::windows::runtime::Abi for SECPKG_REDIRECTED_LOGON_BUFFER {
11479     type Abi = ::std::mem::ManuallyDrop<Self>;
11480     type DefaultType = Self;
11481 }
11482 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11483 #[repr(C)]
11484 pub struct SECPKG_SERIALIZED_OID {
11485     pub OidLength: u32,
11486     pub OidAttributes: u32,
11487     pub OidValue: [u8; 32],
11488 }
11489 impl SECPKG_SERIALIZED_OID {}
11490 impl ::std::default::Default for SECPKG_SERIALIZED_OID {
11491     fn default() -> Self {
11492         unsafe { ::std::mem::zeroed() }
11493     }
11494 }
11495 impl ::std::fmt::Debug for SECPKG_SERIALIZED_OID {
11496     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11497         fmt.debug_struct("SECPKG_SERIALIZED_OID").field("OidLength", &self.OidLength).field("OidAttributes", &self.OidAttributes).field("OidValue", &self.OidValue).finish()
11498     }
11499 }
11500 impl ::std::cmp::PartialEq for SECPKG_SERIALIZED_OID {
11501     fn eq(&self, other: &Self) -> bool {
11502         self.OidLength == other.OidLength && self.OidAttributes == other.OidAttributes && self.OidValue == other.OidValue
11503     }
11504 }
11505 impl ::std::cmp::Eq for SECPKG_SERIALIZED_OID {}
11506 unsafe impl ::windows::runtime::Abi for SECPKG_SERIALIZED_OID {
11507     type Abi = Self;
11508     type DefaultType = Self;
11509 }
11510 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11511 #[repr(transparent)]
11512 pub struct SECPKG_SESSIONINFO_TYPE(pub i32);
11513 pub const SecSessionPrimaryCred: SECPKG_SESSIONINFO_TYPE = SECPKG_SESSIONINFO_TYPE(0i32);
11514 impl ::std::convert::From<i32> for SECPKG_SESSIONINFO_TYPE {
11515     fn from(value: i32) -> Self {
11516         Self(value)
11517     }
11518 }
11519 unsafe impl ::windows::runtime::Abi for SECPKG_SESSIONINFO_TYPE {
11520     type Abi = Self;
11521     type DefaultType = Self;
11522 }
11523 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11524 #[repr(C)]
11525 pub struct SECPKG_SHORT_VECTOR {
11526     pub ShortArrayOffset: u32,
11527     pub ShortArrayCount: u16,
11528 }
11529 impl SECPKG_SHORT_VECTOR {}
11530 impl ::std::default::Default for SECPKG_SHORT_VECTOR {
11531     fn default() -> Self {
11532         unsafe { ::std::mem::zeroed() }
11533     }
11534 }
11535 impl ::std::fmt::Debug for SECPKG_SHORT_VECTOR {
11536     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11537         fmt.debug_struct("SECPKG_SHORT_VECTOR").field("ShortArrayOffset", &self.ShortArrayOffset).field("ShortArrayCount", &self.ShortArrayCount).finish()
11538     }
11539 }
11540 impl ::std::cmp::PartialEq for SECPKG_SHORT_VECTOR {
11541     fn eq(&self, other: &Self) -> bool {
11542         self.ShortArrayOffset == other.ShortArrayOffset && self.ShortArrayCount == other.ShortArrayCount
11543     }
11544 }
11545 impl ::std::cmp::Eq for SECPKG_SHORT_VECTOR {}
11546 unsafe impl ::windows::runtime::Abi for SECPKG_SHORT_VECTOR {
11547     type Abi = Self;
11548     type DefaultType = Self;
11549 }
11550 pub const SECPKG_STATE_CRED_ISOLATION_ENABLED: u32 = 32u32;
11551 pub const SECPKG_STATE_DOMAIN_CONTROLLER: u32 = 4u32;
11552 pub const SECPKG_STATE_ENCRYPTION_PERMITTED: u32 = 1u32;
11553 pub const SECPKG_STATE_RESERVED_1: u32 = 2147483648u32;
11554 pub const SECPKG_STATE_STANDALONE: u32 = 16u32;
11555 pub const SECPKG_STATE_STRONG_ENCRYPTION_PERMITTED: u32 = 2u32;
11556 pub const SECPKG_STATE_WORKSTATION: u32 = 8u32;
11557 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11558 #[repr(C)]
11559 #[cfg(feature = "Win32_Foundation")]
11560 pub struct SECPKG_SUPPLEMENTAL_CRED {
11561     pub PackageName: super::super::super::Foundation::UNICODE_STRING,
11562     pub CredentialSize: u32,
11563     pub Credentials: *mut u8,
11564 }
11565 #[cfg(feature = "Win32_Foundation")]
11566 impl SECPKG_SUPPLEMENTAL_CRED {}
11567 #[cfg(feature = "Win32_Foundation")]
11568 impl ::std::default::Default for SECPKG_SUPPLEMENTAL_CRED {
11569     fn default() -> Self {
11570         unsafe { ::std::mem::zeroed() }
11571     }
11572 }
11573 #[cfg(feature = "Win32_Foundation")]
11574 impl ::std::fmt::Debug for SECPKG_SUPPLEMENTAL_CRED {
11575     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11576         fmt.debug_struct("SECPKG_SUPPLEMENTAL_CRED").field("PackageName", &self.PackageName).field("CredentialSize", &self.CredentialSize).field("Credentials", &self.Credentials).finish()
11577     }
11578 }
11579 #[cfg(feature = "Win32_Foundation")]
11580 impl ::std::cmp::PartialEq for SECPKG_SUPPLEMENTAL_CRED {
11581     fn eq(&self, other: &Self) -> bool {
11582         self.PackageName == other.PackageName && self.CredentialSize == other.CredentialSize && self.Credentials == other.Credentials
11583     }
11584 }
11585 #[cfg(feature = "Win32_Foundation")]
11586 impl ::std::cmp::Eq for SECPKG_SUPPLEMENTAL_CRED {}
11587 #[cfg(feature = "Win32_Foundation")]
11588 unsafe impl ::windows::runtime::Abi for SECPKG_SUPPLEMENTAL_CRED {
11589     type Abi = Self;
11590     type DefaultType = Self;
11591 }
11592 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11593 #[repr(C)]
11594 #[cfg(feature = "Win32_Foundation")]
11595 pub struct SECPKG_SUPPLEMENTAL_CRED_ARRAY {
11596     pub CredentialCount: u32,
11597     pub Credentials: [SECPKG_SUPPLEMENTAL_CRED; 1],
11598 }
11599 #[cfg(feature = "Win32_Foundation")]
11600 impl SECPKG_SUPPLEMENTAL_CRED_ARRAY {}
11601 #[cfg(feature = "Win32_Foundation")]
11602 impl ::std::default::Default for SECPKG_SUPPLEMENTAL_CRED_ARRAY {
11603     fn default() -> Self {
11604         unsafe { ::std::mem::zeroed() }
11605     }
11606 }
11607 #[cfg(feature = "Win32_Foundation")]
11608 impl ::std::fmt::Debug for SECPKG_SUPPLEMENTAL_CRED_ARRAY {
11609     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11610         fmt.debug_struct("SECPKG_SUPPLEMENTAL_CRED_ARRAY").field("CredentialCount", &self.CredentialCount).field("Credentials", &self.Credentials).finish()
11611     }
11612 }
11613 #[cfg(feature = "Win32_Foundation")]
11614 impl ::std::cmp::PartialEq for SECPKG_SUPPLEMENTAL_CRED_ARRAY {
11615     fn eq(&self, other: &Self) -> bool {
11616         self.CredentialCount == other.CredentialCount && self.Credentials == other.Credentials
11617     }
11618 }
11619 #[cfg(feature = "Win32_Foundation")]
11620 impl ::std::cmp::Eq for SECPKG_SUPPLEMENTAL_CRED_ARRAY {}
11621 #[cfg(feature = "Win32_Foundation")]
11622 unsafe impl ::windows::runtime::Abi for SECPKG_SUPPLEMENTAL_CRED_ARRAY {
11623     type Abi = Self;
11624     type DefaultType = Self;
11625 }
11626 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11627 #[repr(C)]
11628 pub struct SECPKG_SUPPLIED_CREDENTIAL {
11629     pub cbHeaderLength: u16,
11630     pub cbStructureLength: u16,
11631     pub UserName: SECPKG_SHORT_VECTOR,
11632     pub DomainName: SECPKG_SHORT_VECTOR,
11633     pub PackedCredentials: SECPKG_BYTE_VECTOR,
11634     pub CredFlags: u32,
11635 }
11636 impl SECPKG_SUPPLIED_CREDENTIAL {}
11637 impl ::std::default::Default for SECPKG_SUPPLIED_CREDENTIAL {
11638     fn default() -> Self {
11639         unsafe { ::std::mem::zeroed() }
11640     }
11641 }
11642 impl ::std::fmt::Debug for SECPKG_SUPPLIED_CREDENTIAL {
11643     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11644         fmt.debug_struct("SECPKG_SUPPLIED_CREDENTIAL")
11645             .field("cbHeaderLength", &self.cbHeaderLength)
11646             .field("cbStructureLength", &self.cbStructureLength)
11647             .field("UserName", &self.UserName)
11648             .field("DomainName", &self.DomainName)
11649             .field("PackedCredentials", &self.PackedCredentials)
11650             .field("CredFlags", &self.CredFlags)
11651             .finish()
11652     }
11653 }
11654 impl ::std::cmp::PartialEq for SECPKG_SUPPLIED_CREDENTIAL {
11655     fn eq(&self, other: &Self) -> bool {
11656         self.cbHeaderLength == other.cbHeaderLength && self.cbStructureLength == other.cbStructureLength && self.UserName == other.UserName && self.DomainName == other.DomainName && self.PackedCredentials == other.PackedCredentials && self.CredFlags == other.CredFlags
11657     }
11658 }
11659 impl ::std::cmp::Eq for SECPKG_SUPPLIED_CREDENTIAL {}
11660 unsafe impl ::windows::runtime::Abi for SECPKG_SUPPLIED_CREDENTIAL {
11661     type Abi = Self;
11662     type DefaultType = Self;
11663 }
11664 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11665 #[repr(C)]
11666 #[cfg(feature = "Win32_Foundation")]
11667 pub struct SECPKG_SURROGATE_LOGON {
11668     pub Version: u32,
11669     pub SurrogateLogonID: super::super::super::Foundation::LUID,
11670     pub EntryCount: u32,
11671     pub Entries: *mut SECPKG_SURROGATE_LOGON_ENTRY,
11672 }
11673 #[cfg(feature = "Win32_Foundation")]
11674 impl SECPKG_SURROGATE_LOGON {}
11675 #[cfg(feature = "Win32_Foundation")]
11676 impl ::std::default::Default for SECPKG_SURROGATE_LOGON {
11677     fn default() -> Self {
11678         unsafe { ::std::mem::zeroed() }
11679     }
11680 }
11681 #[cfg(feature = "Win32_Foundation")]
11682 impl ::std::fmt::Debug for SECPKG_SURROGATE_LOGON {
11683     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11684         fmt.debug_struct("SECPKG_SURROGATE_LOGON").field("Version", &self.Version).field("SurrogateLogonID", &self.SurrogateLogonID).field("EntryCount", &self.EntryCount).field("Entries", &self.Entries).finish()
11685     }
11686 }
11687 #[cfg(feature = "Win32_Foundation")]
11688 impl ::std::cmp::PartialEq for SECPKG_SURROGATE_LOGON {
11689     fn eq(&self, other: &Self) -> bool {
11690         self.Version == other.Version && self.SurrogateLogonID == other.SurrogateLogonID && self.EntryCount == other.EntryCount && self.Entries == other.Entries
11691     }
11692 }
11693 #[cfg(feature = "Win32_Foundation")]
11694 impl ::std::cmp::Eq for SECPKG_SURROGATE_LOGON {}
11695 #[cfg(feature = "Win32_Foundation")]
11696 unsafe impl ::windows::runtime::Abi for SECPKG_SURROGATE_LOGON {
11697     type Abi = Self;
11698     type DefaultType = Self;
11699 }
11700 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11701 #[repr(C)]
11702 pub struct SECPKG_SURROGATE_LOGON_ENTRY {
11703     pub Type: ::windows::runtime::GUID,
11704     pub Data: *mut ::std::ffi::c_void,
11705 }
11706 impl SECPKG_SURROGATE_LOGON_ENTRY {}
11707 impl ::std::default::Default for SECPKG_SURROGATE_LOGON_ENTRY {
11708     fn default() -> Self {
11709         unsafe { ::std::mem::zeroed() }
11710     }
11711 }
11712 impl ::std::fmt::Debug for SECPKG_SURROGATE_LOGON_ENTRY {
11713     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11714         fmt.debug_struct("SECPKG_SURROGATE_LOGON_ENTRY").field("Type", &self.Type).field("Data", &self.Data).finish()
11715     }
11716 }
11717 impl ::std::cmp::PartialEq for SECPKG_SURROGATE_LOGON_ENTRY {
11718     fn eq(&self, other: &Self) -> bool {
11719         self.Type == other.Type && self.Data == other.Data
11720     }
11721 }
11722 impl ::std::cmp::Eq for SECPKG_SURROGATE_LOGON_ENTRY {}
11723 unsafe impl ::windows::runtime::Abi for SECPKG_SURROGATE_LOGON_ENTRY {
11724     type Abi = Self;
11725     type DefaultType = Self;
11726 }
11727 pub const SECPKG_SURROGATE_LOGON_VERSION_1: u32 = 1u32;
11728 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11729 #[repr(C)]
11730 #[cfg(feature = "Win32_Foundation")]
11731 pub struct SECPKG_TARGETINFO {
11732     pub DomainSid: super::super::super::Foundation::PSID,
11733     pub ComputerName: super::super::super::Foundation::PWSTR,
11734 }
11735 #[cfg(feature = "Win32_Foundation")]
11736 impl SECPKG_TARGETINFO {}
11737 #[cfg(feature = "Win32_Foundation")]
11738 impl ::std::default::Default for SECPKG_TARGETINFO {
11739     fn default() -> Self {
11740         unsafe { ::std::mem::zeroed() }
11741     }
11742 }
11743 #[cfg(feature = "Win32_Foundation")]
11744 impl ::std::fmt::Debug for SECPKG_TARGETINFO {
11745     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11746         fmt.debug_struct("SECPKG_TARGETINFO").field("DomainSid", &self.DomainSid).field("ComputerName", &self.ComputerName).finish()
11747     }
11748 }
11749 #[cfg(feature = "Win32_Foundation")]
11750 impl ::std::cmp::PartialEq for SECPKG_TARGETINFO {
11751     fn eq(&self, other: &Self) -> bool {
11752         self.DomainSid == other.DomainSid && self.ComputerName == other.ComputerName
11753     }
11754 }
11755 #[cfg(feature = "Win32_Foundation")]
11756 impl ::std::cmp::Eq for SECPKG_TARGETINFO {}
11757 #[cfg(feature = "Win32_Foundation")]
11758 unsafe impl ::windows::runtime::Abi for SECPKG_TARGETINFO {
11759     type Abi = Self;
11760     type DefaultType = Self;
11761 }
11762 pub const SECPKG_UNICODE_ATTRIBUTE: u32 = 2147483648u32;
11763 #[derive(:: std :: clone :: Clone)]
11764 #[repr(C)]
11765 #[cfg(feature = "Win32_Foundation")]
11766 pub struct SECPKG_USER_FUNCTION_TABLE {
11767     pub InstanceInit: ::std::option::Option<SpInstanceInitFn>,
11768     pub InitUserModeContext: ::std::option::Option<SpInitUserModeContextFn>,
11769     pub MakeSignature: ::std::option::Option<SpMakeSignatureFn>,
11770     pub VerifySignature: ::std::option::Option<SpVerifySignatureFn>,
11771     pub SealMessage: ::std::option::Option<SpSealMessageFn>,
11772     pub UnsealMessage: ::std::option::Option<SpUnsealMessageFn>,
11773     pub GetContextToken: ::std::option::Option<SpGetContextTokenFn>,
11774     pub QueryContextAttributesA: ::std::option::Option<SpQueryContextAttributesFn>,
11775     pub CompleteAuthToken: ::std::option::Option<SpCompleteAuthTokenFn>,
11776     pub DeleteUserModeContext: ::std::option::Option<SpDeleteContextFn>,
11777     pub FormatCredentials: ::std::option::Option<SpFormatCredentialsFn>,
11778     pub MarshallSupplementalCreds: ::std::option::Option<SpMarshallSupplementalCredsFn>,
11779     pub ExportContext: ::std::option::Option<SpExportSecurityContextFn>,
11780     pub ImportContext: ::std::option::Option<SpImportSecurityContextFn>,
11781     pub MarshalAttributeData: ::std::option::Option<SpMarshalAttributeDataFn>,
11782 }
11783 #[cfg(feature = "Win32_Foundation")]
11784 impl SECPKG_USER_FUNCTION_TABLE {}
11785 #[cfg(feature = "Win32_Foundation")]
11786 impl ::std::default::Default for SECPKG_USER_FUNCTION_TABLE {
11787     fn default() -> Self {
11788         unsafe { ::std::mem::zeroed() }
11789     }
11790 }
11791 #[cfg(feature = "Win32_Foundation")]
11792 impl ::std::fmt::Debug for SECPKG_USER_FUNCTION_TABLE {
11793     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11794         fmt.debug_struct("SECPKG_USER_FUNCTION_TABLE").finish()
11795     }
11796 }
11797 #[cfg(feature = "Win32_Foundation")]
11798 impl ::std::cmp::PartialEq for SECPKG_USER_FUNCTION_TABLE {
11799     fn eq(&self, other: &Self) -> bool {
11800         self.InstanceInit.map(|f| f as usize) == other.InstanceInit.map(|f| f as usize)
11801             && self.InitUserModeContext.map(|f| f as usize) == other.InitUserModeContext.map(|f| f as usize)
11802             && self.MakeSignature.map(|f| f as usize) == other.MakeSignature.map(|f| f as usize)
11803             && self.VerifySignature.map(|f| f as usize) == other.VerifySignature.map(|f| f as usize)
11804             && self.SealMessage.map(|f| f as usize) == other.SealMessage.map(|f| f as usize)
11805             && self.UnsealMessage.map(|f| f as usize) == other.UnsealMessage.map(|f| f as usize)
11806             && self.GetContextToken.map(|f| f as usize) == other.GetContextToken.map(|f| f as usize)
11807             && self.QueryContextAttributesA.map(|f| f as usize) == other.QueryContextAttributesA.map(|f| f as usize)
11808             && self.CompleteAuthToken.map(|f| f as usize) == other.CompleteAuthToken.map(|f| f as usize)
11809             && self.DeleteUserModeContext.map(|f| f as usize) == other.DeleteUserModeContext.map(|f| f as usize)
11810             && self.FormatCredentials.map(|f| f as usize) == other.FormatCredentials.map(|f| f as usize)
11811             && self.MarshallSupplementalCreds.map(|f| f as usize) == other.MarshallSupplementalCreds.map(|f| f as usize)
11812             && self.ExportContext.map(|f| f as usize) == other.ExportContext.map(|f| f as usize)
11813             && self.ImportContext.map(|f| f as usize) == other.ImportContext.map(|f| f as usize)
11814             && self.MarshalAttributeData.map(|f| f as usize) == other.MarshalAttributeData.map(|f| f as usize)
11815     }
11816 }
11817 #[cfg(feature = "Win32_Foundation")]
11818 impl ::std::cmp::Eq for SECPKG_USER_FUNCTION_TABLE {}
11819 #[cfg(feature = "Win32_Foundation")]
11820 unsafe impl ::windows::runtime::Abi for SECPKG_USER_FUNCTION_TABLE {
11821     type Abi = ::std::mem::ManuallyDrop<Self>;
11822     type DefaultType = Self;
11823 }
11824 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11825 #[repr(C)]
11826 #[cfg(feature = "Win32_Foundation")]
11827 pub struct SECPKG_WOW_CLIENT_DLL {
11828     pub WowClientDllPath: super::super::super::Foundation::UNICODE_STRING,
11829 }
11830 #[cfg(feature = "Win32_Foundation")]
11831 impl SECPKG_WOW_CLIENT_DLL {}
11832 #[cfg(feature = "Win32_Foundation")]
11833 impl ::std::default::Default for SECPKG_WOW_CLIENT_DLL {
11834     fn default() -> Self {
11835         unsafe { ::std::mem::zeroed() }
11836     }
11837 }
11838 #[cfg(feature = "Win32_Foundation")]
11839 impl ::std::fmt::Debug for SECPKG_WOW_CLIENT_DLL {
11840     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11841         fmt.debug_struct("SECPKG_WOW_CLIENT_DLL").field("WowClientDllPath", &self.WowClientDllPath).finish()
11842     }
11843 }
11844 #[cfg(feature = "Win32_Foundation")]
11845 impl ::std::cmp::PartialEq for SECPKG_WOW_CLIENT_DLL {
11846     fn eq(&self, other: &Self) -> bool {
11847         self.WowClientDllPath == other.WowClientDllPath
11848     }
11849 }
11850 #[cfg(feature = "Win32_Foundation")]
11851 impl ::std::cmp::Eq for SECPKG_WOW_CLIENT_DLL {}
11852 #[cfg(feature = "Win32_Foundation")]
11853 unsafe impl ::windows::runtime::Abi for SECPKG_WOW_CLIENT_DLL {
11854     type Abi = Self;
11855     type DefaultType = Self;
11856 }
11857 pub const SECQOP_WRAP_NO_ENCRYPT: u32 = 2147483649u32;
11858 pub const SECQOP_WRAP_OOB_DATA: u32 = 1073741824u32;
11859 pub const SECRET_QUERY_VALUE: i32 = 2i32;
11860 pub const SECRET_SET_VALUE: i32 = 1i32;
11861 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11862 #[repr(C)]
11863 #[cfg(feature = "Win32_Foundation")]
11864 pub struct SECURITY_LOGON_SESSION_DATA {
11865     pub Size: u32,
11866     pub LogonId: super::super::super::Foundation::LUID,
11867     pub UserName: super::super::super::Foundation::UNICODE_STRING,
11868     pub LogonDomain: super::super::super::Foundation::UNICODE_STRING,
11869     pub AuthenticationPackage: super::super::super::Foundation::UNICODE_STRING,
11870     pub LogonType: u32,
11871     pub Session: u32,
11872     pub Sid: super::super::super::Foundation::PSID,
11873     pub LogonTime: i64,
11874     pub LogonServer: super::super::super::Foundation::UNICODE_STRING,
11875     pub DnsDomainName: super::super::super::Foundation::UNICODE_STRING,
11876     pub Upn: super::super::super::Foundation::UNICODE_STRING,
11877     pub UserFlags: u32,
11878     pub LastLogonInfo: LSA_LAST_INTER_LOGON_INFO,
11879     pub LogonScript: super::super::super::Foundation::UNICODE_STRING,
11880     pub ProfilePath: super::super::super::Foundation::UNICODE_STRING,
11881     pub HomeDirectory: super::super::super::Foundation::UNICODE_STRING,
11882     pub HomeDirectoryDrive: super::super::super::Foundation::UNICODE_STRING,
11883     pub LogoffTime: i64,
11884     pub KickOffTime: i64,
11885     pub PasswordLastSet: i64,
11886     pub PasswordCanChange: i64,
11887     pub PasswordMustChange: i64,
11888 }
11889 #[cfg(feature = "Win32_Foundation")]
11890 impl SECURITY_LOGON_SESSION_DATA {}
11891 #[cfg(feature = "Win32_Foundation")]
11892 impl ::std::default::Default for SECURITY_LOGON_SESSION_DATA {
11893     fn default() -> Self {
11894         unsafe { ::std::mem::zeroed() }
11895     }
11896 }
11897 #[cfg(feature = "Win32_Foundation")]
11898 impl ::std::fmt::Debug for SECURITY_LOGON_SESSION_DATA {
11899     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11900         fmt.debug_struct("SECURITY_LOGON_SESSION_DATA")
11901             .field("Size", &self.Size)
11902             .field("LogonId", &self.LogonId)
11903             .field("UserName", &self.UserName)
11904             .field("LogonDomain", &self.LogonDomain)
11905             .field("AuthenticationPackage", &self.AuthenticationPackage)
11906             .field("LogonType", &self.LogonType)
11907             .field("Session", &self.Session)
11908             .field("Sid", &self.Sid)
11909             .field("LogonTime", &self.LogonTime)
11910             .field("LogonServer", &self.LogonServer)
11911             .field("DnsDomainName", &self.DnsDomainName)
11912             .field("Upn", &self.Upn)
11913             .field("UserFlags", &self.UserFlags)
11914             .field("LastLogonInfo", &self.LastLogonInfo)
11915             .field("LogonScript", &self.LogonScript)
11916             .field("ProfilePath", &self.ProfilePath)
11917             .field("HomeDirectory", &self.HomeDirectory)
11918             .field("HomeDirectoryDrive", &self.HomeDirectoryDrive)
11919             .field("LogoffTime", &self.LogoffTime)
11920             .field("KickOffTime", &self.KickOffTime)
11921             .field("PasswordLastSet", &self.PasswordLastSet)
11922             .field("PasswordCanChange", &self.PasswordCanChange)
11923             .field("PasswordMustChange", &self.PasswordMustChange)
11924             .finish()
11925     }
11926 }
11927 #[cfg(feature = "Win32_Foundation")]
11928 impl ::std::cmp::PartialEq for SECURITY_LOGON_SESSION_DATA {
11929     fn eq(&self, other: &Self) -> bool {
11930         self.Size == other.Size
11931             && self.LogonId == other.LogonId
11932             && self.UserName == other.UserName
11933             && self.LogonDomain == other.LogonDomain
11934             && self.AuthenticationPackage == other.AuthenticationPackage
11935             && self.LogonType == other.LogonType
11936             && self.Session == other.Session
11937             && self.Sid == other.Sid
11938             && self.LogonTime == other.LogonTime
11939             && self.LogonServer == other.LogonServer
11940             && self.DnsDomainName == other.DnsDomainName
11941             && self.Upn == other.Upn
11942             && self.UserFlags == other.UserFlags
11943             && self.LastLogonInfo == other.LastLogonInfo
11944             && self.LogonScript == other.LogonScript
11945             && self.ProfilePath == other.ProfilePath
11946             && self.HomeDirectory == other.HomeDirectory
11947             && self.HomeDirectoryDrive == other.HomeDirectoryDrive
11948             && self.LogoffTime == other.LogoffTime
11949             && self.KickOffTime == other.KickOffTime
11950             && self.PasswordLastSet == other.PasswordLastSet
11951             && self.PasswordCanChange == other.PasswordCanChange
11952             && self.PasswordMustChange == other.PasswordMustChange
11953     }
11954 }
11955 #[cfg(feature = "Win32_Foundation")]
11956 impl ::std::cmp::Eq for SECURITY_LOGON_SESSION_DATA {}
11957 #[cfg(feature = "Win32_Foundation")]
11958 unsafe impl ::windows::runtime::Abi for SECURITY_LOGON_SESSION_DATA {
11959     type Abi = Self;
11960     type DefaultType = Self;
11961 }
11962 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11963 #[repr(transparent)]
11964 pub struct SECURITY_LOGON_TYPE(pub i32);
11965 impl SECURITY_LOGON_TYPE {
11966     pub const UndefinedLogonType: SECURITY_LOGON_TYPE = SECURITY_LOGON_TYPE(0i32);
11967     pub const Interactive: SECURITY_LOGON_TYPE = SECURITY_LOGON_TYPE(2i32);
11968     pub const Network: SECURITY_LOGON_TYPE = SECURITY_LOGON_TYPE(3i32);
11969     pub const Batch: SECURITY_LOGON_TYPE = SECURITY_LOGON_TYPE(4i32);
11970     pub const Service: SECURITY_LOGON_TYPE = SECURITY_LOGON_TYPE(5i32);
11971     pub const Proxy: SECURITY_LOGON_TYPE = SECURITY_LOGON_TYPE(6i32);
11972     pub const Unlock: SECURITY_LOGON_TYPE = SECURITY_LOGON_TYPE(7i32);
11973     pub const NetworkCleartext: SECURITY_LOGON_TYPE = SECURITY_LOGON_TYPE(8i32);
11974     pub const NewCredentials: SECURITY_LOGON_TYPE = SECURITY_LOGON_TYPE(9i32);
11975     pub const RemoteInteractive: SECURITY_LOGON_TYPE = SECURITY_LOGON_TYPE(10i32);
11976     pub const CachedInteractive: SECURITY_LOGON_TYPE = SECURITY_LOGON_TYPE(11i32);
11977     pub const CachedRemoteInteractive: SECURITY_LOGON_TYPE = SECURITY_LOGON_TYPE(12i32);
11978     pub const CachedUnlock: SECURITY_LOGON_TYPE = SECURITY_LOGON_TYPE(13i32);
11979 }
11980 impl ::std::convert::From<i32> for SECURITY_LOGON_TYPE {
11981     fn from(value: i32) -> Self {
11982         Self(value)
11983     }
11984 }
11985 unsafe impl ::windows::runtime::Abi for SECURITY_LOGON_TYPE {
11986     type Abi = Self;
11987     type DefaultType = Self;
11988 }
11989 pub const SECURITY_NATIVE_DREP: u32 = 16u32;
11990 pub const SECURITY_NETWORK_DREP: u32 = 0u32;
11991 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11992 #[repr(C)]
11993 pub struct SECURITY_PACKAGE_OPTIONS {
11994     pub Size: u32,
11995     pub Type: SECURITY_PACKAGE_OPTIONS_TYPE,
11996     pub Flags: u32,
11997     pub SignatureSize: u32,
11998     pub Signature: *mut ::std::ffi::c_void,
11999 }
12000 impl SECURITY_PACKAGE_OPTIONS {}
12001 impl ::std::default::Default for SECURITY_PACKAGE_OPTIONS {
12002     fn default() -> Self {
12003         unsafe { ::std::mem::zeroed() }
12004     }
12005 }
12006 impl ::std::fmt::Debug for SECURITY_PACKAGE_OPTIONS {
12007     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12008         fmt.debug_struct("SECURITY_PACKAGE_OPTIONS").field("Size", &self.Size).field("Type", &self.Type).field("Flags", &self.Flags).field("SignatureSize", &self.SignatureSize).field("Signature", &self.Signature).finish()
12009     }
12010 }
12011 impl ::std::cmp::PartialEq for SECURITY_PACKAGE_OPTIONS {
12012     fn eq(&self, other: &Self) -> bool {
12013         self.Size == other.Size && self.Type == other.Type && self.Flags == other.Flags && self.SignatureSize == other.SignatureSize && self.Signature == other.Signature
12014     }
12015 }
12016 impl ::std::cmp::Eq for SECURITY_PACKAGE_OPTIONS {}
12017 unsafe impl ::windows::runtime::Abi for SECURITY_PACKAGE_OPTIONS {
12018     type Abi = Self;
12019     type DefaultType = Self;
12020 }
12021 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12022 #[repr(transparent)]
12023 pub struct SECURITY_PACKAGE_OPTIONS_TYPE(pub u32);
12024 pub const SECPKG_OPTIONS_TYPE_UNKNOWN: SECURITY_PACKAGE_OPTIONS_TYPE = SECURITY_PACKAGE_OPTIONS_TYPE(0u32);
12025 pub const SECPKG_OPTIONS_TYPE_LSA: SECURITY_PACKAGE_OPTIONS_TYPE = SECURITY_PACKAGE_OPTIONS_TYPE(1u32);
12026 pub const SECPKG_OPTIONS_TYPE_SSPI: SECURITY_PACKAGE_OPTIONS_TYPE = SECURITY_PACKAGE_OPTIONS_TYPE(2u32);
12027 impl ::std::convert::From<u32> for SECURITY_PACKAGE_OPTIONS_TYPE {
12028     fn from(value: u32) -> Self {
12029         Self(value)
12030     }
12031 }
12032 unsafe impl ::windows::runtime::Abi for SECURITY_PACKAGE_OPTIONS_TYPE {
12033     type Abi = Self;
12034     type DefaultType = Self;
12035 }
12036 impl ::std::ops::BitOr for SECURITY_PACKAGE_OPTIONS_TYPE {
12037     type Output = Self;
12038     fn bitor(self, rhs: Self) -> Self {
12039         Self(self.0 | rhs.0)
12040     }
12041 }
12042 impl ::std::ops::BitAnd for SECURITY_PACKAGE_OPTIONS_TYPE {
12043     type Output = Self;
12044     fn bitand(self, rhs: Self) -> Self {
12045         Self(self.0 & rhs.0)
12046     }
12047 }
12048 impl ::std::ops::BitOrAssign for SECURITY_PACKAGE_OPTIONS_TYPE {
12049     fn bitor_assign(&mut self, rhs: Self) {
12050         self.0.bitor_assign(rhs.0)
12051     }
12052 }
12053 impl ::std::ops::BitAndAssign for SECURITY_PACKAGE_OPTIONS_TYPE {
12054     fn bitand_assign(&mut self, rhs: Self) {
12055         self.0.bitand_assign(rhs.0)
12056     }
12057 }
12058 impl ::std::ops::Not for SECURITY_PACKAGE_OPTIONS_TYPE {
12059     type Output = Self;
12060     fn not(self) -> Self {
12061         Self(self.0.not())
12062     }
12063 }
12064 pub const SECURITY_SUPPORT_PROVIDER_INTERFACE_VERSION: u32 = 1u32;
12065 pub const SECURITY_SUPPORT_PROVIDER_INTERFACE_VERSION_2: u32 = 2u32;
12066 pub const SECURITY_SUPPORT_PROVIDER_INTERFACE_VERSION_3: u32 = 3u32;
12067 pub const SECURITY_SUPPORT_PROVIDER_INTERFACE_VERSION_4: u32 = 4u32;
12068 pub const SECURITY_SUPPORT_PROVIDER_INTERFACE_VERSION_5: u32 = 5u32;
12069 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12070 #[repr(C)]
12071 #[cfg(feature = "Win32_Foundation")]
12072 pub struct SECURITY_USER_DATA {
12073     pub UserName: super::super::super::Foundation::UNICODE_STRING,
12074     pub LogonDomainName: super::super::super::Foundation::UNICODE_STRING,
12075     pub LogonServer: super::super::super::Foundation::UNICODE_STRING,
12076     pub pSid: super::super::super::Foundation::PSID,
12077 }
12078 #[cfg(feature = "Win32_Foundation")]
12079 impl SECURITY_USER_DATA {}
12080 #[cfg(feature = "Win32_Foundation")]
12081 impl ::std::default::Default for SECURITY_USER_DATA {
12082     fn default() -> Self {
12083         unsafe { ::std::mem::zeroed() }
12084     }
12085 }
12086 #[cfg(feature = "Win32_Foundation")]
12087 impl ::std::fmt::Debug for SECURITY_USER_DATA {
12088     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12089         fmt.debug_struct("SECURITY_USER_DATA").field("UserName", &self.UserName).field("LogonDomainName", &self.LogonDomainName).field("LogonServer", &self.LogonServer).field("pSid", &self.pSid).finish()
12090     }
12091 }
12092 #[cfg(feature = "Win32_Foundation")]
12093 impl ::std::cmp::PartialEq for SECURITY_USER_DATA {
12094     fn eq(&self, other: &Self) -> bool {
12095         self.UserName == other.UserName && self.LogonDomainName == other.LogonDomainName && self.LogonServer == other.LogonServer && self.pSid == other.pSid
12096     }
12097 }
12098 #[cfg(feature = "Win32_Foundation")]
12099 impl ::std::cmp::Eq for SECURITY_USER_DATA {}
12100 #[cfg(feature = "Win32_Foundation")]
12101 unsafe impl ::windows::runtime::Abi for SECURITY_USER_DATA {
12102     type Abi = Self;
12103     type DefaultType = Self;
12104 }
12105 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12106 #[repr(C)]
12107 pub struct SEC_APPLICATION_PROTOCOLS {
12108     pub ProtocolListsSize: u32,
12109     pub ProtocolLists: [SEC_APPLICATION_PROTOCOL_LIST; 1],
12110 }
12111 impl SEC_APPLICATION_PROTOCOLS {}
12112 impl ::std::default::Default for SEC_APPLICATION_PROTOCOLS {
12113     fn default() -> Self {
12114         unsafe { ::std::mem::zeroed() }
12115     }
12116 }
12117 impl ::std::fmt::Debug for SEC_APPLICATION_PROTOCOLS {
12118     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12119         fmt.debug_struct("SEC_APPLICATION_PROTOCOLS").field("ProtocolListsSize", &self.ProtocolListsSize).field("ProtocolLists", &self.ProtocolLists).finish()
12120     }
12121 }
12122 impl ::std::cmp::PartialEq for SEC_APPLICATION_PROTOCOLS {
12123     fn eq(&self, other: &Self) -> bool {
12124         self.ProtocolListsSize == other.ProtocolListsSize && self.ProtocolLists == other.ProtocolLists
12125     }
12126 }
12127 impl ::std::cmp::Eq for SEC_APPLICATION_PROTOCOLS {}
12128 unsafe impl ::windows::runtime::Abi for SEC_APPLICATION_PROTOCOLS {
12129     type Abi = Self;
12130     type DefaultType = Self;
12131 }
12132 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12133 #[repr(C)]
12134 pub struct SEC_APPLICATION_PROTOCOL_LIST {
12135     pub ProtoNegoExt: SEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT,
12136     pub ProtocolListSize: u16,
12137     pub ProtocolList: [u8; 1],
12138 }
12139 impl SEC_APPLICATION_PROTOCOL_LIST {}
12140 impl ::std::default::Default for SEC_APPLICATION_PROTOCOL_LIST {
12141     fn default() -> Self {
12142         unsafe { ::std::mem::zeroed() }
12143     }
12144 }
12145 impl ::std::fmt::Debug for SEC_APPLICATION_PROTOCOL_LIST {
12146     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12147         fmt.debug_struct("SEC_APPLICATION_PROTOCOL_LIST").field("ProtoNegoExt", &self.ProtoNegoExt).field("ProtocolListSize", &self.ProtocolListSize).field("ProtocolList", &self.ProtocolList).finish()
12148     }
12149 }
12150 impl ::std::cmp::PartialEq for SEC_APPLICATION_PROTOCOL_LIST {
12151     fn eq(&self, other: &Self) -> bool {
12152         self.ProtoNegoExt == other.ProtoNegoExt && self.ProtocolListSize == other.ProtocolListSize && self.ProtocolList == other.ProtocolList
12153     }
12154 }
12155 impl ::std::cmp::Eq for SEC_APPLICATION_PROTOCOL_LIST {}
12156 unsafe impl ::windows::runtime::Abi for SEC_APPLICATION_PROTOCOL_LIST {
12157     type Abi = Self;
12158     type DefaultType = Self;
12159 }
12160 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12161 #[repr(transparent)]
12162 pub struct SEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT(pub i32);
12163 pub const SecApplicationProtocolNegotiationExt_None: SEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT = SEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT(0i32);
12164 pub const SecApplicationProtocolNegotiationExt_NPN: SEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT = SEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT(1i32);
12165 pub const SecApplicationProtocolNegotiationExt_ALPN: SEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT = SEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT(2i32);
12166 impl ::std::convert::From<i32> for SEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT {
12167     fn from(value: i32) -> Self {
12168         Self(value)
12169     }
12170 }
12171 unsafe impl ::windows::runtime::Abi for SEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT {
12172     type Abi = Self;
12173     type DefaultType = Self;
12174 }
12175 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12176 #[repr(transparent)]
12177 pub struct SEC_APPLICATION_PROTOCOL_NEGOTIATION_STATUS(pub i32);
12178 pub const SecApplicationProtocolNegotiationStatus_None: SEC_APPLICATION_PROTOCOL_NEGOTIATION_STATUS = SEC_APPLICATION_PROTOCOL_NEGOTIATION_STATUS(0i32);
12179 pub const SecApplicationProtocolNegotiationStatus_Success: SEC_APPLICATION_PROTOCOL_NEGOTIATION_STATUS = SEC_APPLICATION_PROTOCOL_NEGOTIATION_STATUS(1i32);
12180 pub const SecApplicationProtocolNegotiationStatus_SelectedClientOnly: SEC_APPLICATION_PROTOCOL_NEGOTIATION_STATUS = SEC_APPLICATION_PROTOCOL_NEGOTIATION_STATUS(2i32);
12181 impl ::std::convert::From<i32> for SEC_APPLICATION_PROTOCOL_NEGOTIATION_STATUS {
12182     fn from(value: i32) -> Self {
12183         Self(value)
12184     }
12185 }
12186 unsafe impl ::windows::runtime::Abi for SEC_APPLICATION_PROTOCOL_NEGOTIATION_STATUS {
12187     type Abi = Self;
12188     type DefaultType = Self;
12189 }
12190 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12191 #[repr(C)]
12192 pub struct SEC_CHANNEL_BINDINGS {
12193     pub dwInitiatorAddrType: u32,
12194     pub cbInitiatorLength: u32,
12195     pub dwInitiatorOffset: u32,
12196     pub dwAcceptorAddrType: u32,
12197     pub cbAcceptorLength: u32,
12198     pub dwAcceptorOffset: u32,
12199     pub cbApplicationDataLength: u32,
12200     pub dwApplicationDataOffset: u32,
12201 }
12202 impl SEC_CHANNEL_BINDINGS {}
12203 impl ::std::default::Default for SEC_CHANNEL_BINDINGS {
12204     fn default() -> Self {
12205         unsafe { ::std::mem::zeroed() }
12206     }
12207 }
12208 impl ::std::fmt::Debug for SEC_CHANNEL_BINDINGS {
12209     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12210         fmt.debug_struct("SEC_CHANNEL_BINDINGS")
12211             .field("dwInitiatorAddrType", &self.dwInitiatorAddrType)
12212             .field("cbInitiatorLength", &self.cbInitiatorLength)
12213             .field("dwInitiatorOffset", &self.dwInitiatorOffset)
12214             .field("dwAcceptorAddrType", &self.dwAcceptorAddrType)
12215             .field("cbAcceptorLength", &self.cbAcceptorLength)
12216             .field("dwAcceptorOffset", &self.dwAcceptorOffset)
12217             .field("cbApplicationDataLength", &self.cbApplicationDataLength)
12218             .field("dwApplicationDataOffset", &self.dwApplicationDataOffset)
12219             .finish()
12220     }
12221 }
12222 impl ::std::cmp::PartialEq for SEC_CHANNEL_BINDINGS {
12223     fn eq(&self, other: &Self) -> bool {
12224         self.dwInitiatorAddrType == other.dwInitiatorAddrType && self.cbInitiatorLength == other.cbInitiatorLength && self.dwInitiatorOffset == other.dwInitiatorOffset && self.dwAcceptorAddrType == other.dwAcceptorAddrType && self.cbAcceptorLength == other.cbAcceptorLength && self.dwAcceptorOffset == other.dwAcceptorOffset && self.cbApplicationDataLength == other.cbApplicationDataLength && self.dwApplicationDataOffset == other.dwApplicationDataOffset
12225     }
12226 }
12227 impl ::std::cmp::Eq for SEC_CHANNEL_BINDINGS {}
12228 unsafe impl ::windows::runtime::Abi for SEC_CHANNEL_BINDINGS {
12229     type Abi = Self;
12230     type DefaultType = Self;
12231 }
12232 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12233 #[repr(C)]
12234 pub struct SEC_DTLS_MTU {
12235     pub PathMTU: u16,
12236 }
12237 impl SEC_DTLS_MTU {}
12238 impl ::std::default::Default for SEC_DTLS_MTU {
12239     fn default() -> Self {
12240         unsafe { ::std::mem::zeroed() }
12241     }
12242 }
12243 impl ::std::fmt::Debug for SEC_DTLS_MTU {
12244     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12245         fmt.debug_struct("SEC_DTLS_MTU").field("PathMTU", &self.PathMTU).finish()
12246     }
12247 }
12248 impl ::std::cmp::PartialEq for SEC_DTLS_MTU {
12249     fn eq(&self, other: &Self) -> bool {
12250         self.PathMTU == other.PathMTU
12251     }
12252 }
12253 impl ::std::cmp::Eq for SEC_DTLS_MTU {}
12254 unsafe impl ::windows::runtime::Abi for SEC_DTLS_MTU {
12255     type Abi = Self;
12256     type DefaultType = Self;
12257 }
12258 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12259 #[repr(C)]
12260 pub struct SEC_FLAGS {
12261     pub Flags: u64,
12262 }
12263 impl SEC_FLAGS {}
12264 impl ::std::default::Default for SEC_FLAGS {
12265     fn default() -> Self {
12266         unsafe { ::std::mem::zeroed() }
12267     }
12268 }
12269 impl ::std::fmt::Debug for SEC_FLAGS {
12270     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12271         fmt.debug_struct("SEC_FLAGS").field("Flags", &self.Flags).finish()
12272     }
12273 }
12274 impl ::std::cmp::PartialEq for SEC_FLAGS {
12275     fn eq(&self, other: &Self) -> bool {
12276         self.Flags == other.Flags
12277     }
12278 }
12279 impl ::std::cmp::Eq for SEC_FLAGS {}
12280 unsafe impl ::windows::runtime::Abi for SEC_FLAGS {
12281     type Abi = Self;
12282     type DefaultType = Self;
12283 }
12284 pub type SEC_GET_KEY_FN = unsafe extern "system" fn(arg: *mut ::std::ffi::c_void, principal: *mut ::std::ffi::c_void, keyver: u32, key: *mut *mut ::std::ffi::c_void, status: *mut i32);
12285 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12286 #[repr(C)]
12287 pub struct SEC_NEGOTIATION_INFO {
12288     pub Size: u32,
12289     pub NameLength: u32,
12290     pub Name: *mut u16,
12291     pub Reserved: *mut ::std::ffi::c_void,
12292 }
12293 impl SEC_NEGOTIATION_INFO {}
12294 impl ::std::default::Default for SEC_NEGOTIATION_INFO {
12295     fn default() -> Self {
12296         unsafe { ::std::mem::zeroed() }
12297     }
12298 }
12299 impl ::std::fmt::Debug for SEC_NEGOTIATION_INFO {
12300     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12301         fmt.debug_struct("SEC_NEGOTIATION_INFO").field("Size", &self.Size).field("NameLength", &self.NameLength).field("Name", &self.Name).field("Reserved", &self.Reserved).finish()
12302     }
12303 }
12304 impl ::std::cmp::PartialEq for SEC_NEGOTIATION_INFO {
12305     fn eq(&self, other: &Self) -> bool {
12306         self.Size == other.Size && self.NameLength == other.NameLength && self.Name == other.Name && self.Reserved == other.Reserved
12307     }
12308 }
12309 impl ::std::cmp::Eq for SEC_NEGOTIATION_INFO {}
12310 unsafe impl ::windows::runtime::Abi for SEC_NEGOTIATION_INFO {
12311     type Abi = Self;
12312     type DefaultType = Self;
12313 }
12314 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12315 #[repr(C)]
12316 pub struct SEC_PRESHAREDKEY {
12317     pub KeySize: u16,
12318     pub Key: [u8; 1],
12319 }
12320 impl SEC_PRESHAREDKEY {}
12321 impl ::std::default::Default for SEC_PRESHAREDKEY {
12322     fn default() -> Self {
12323         unsafe { ::std::mem::zeroed() }
12324     }
12325 }
12326 impl ::std::fmt::Debug for SEC_PRESHAREDKEY {
12327     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12328         fmt.debug_struct("SEC_PRESHAREDKEY").field("KeySize", &self.KeySize).field("Key", &self.Key).finish()
12329     }
12330 }
12331 impl ::std::cmp::PartialEq for SEC_PRESHAREDKEY {
12332     fn eq(&self, other: &Self) -> bool {
12333         self.KeySize == other.KeySize && self.Key == other.Key
12334     }
12335 }
12336 impl ::std::cmp::Eq for SEC_PRESHAREDKEY {}
12337 unsafe impl ::windows::runtime::Abi for SEC_PRESHAREDKEY {
12338     type Abi = Self;
12339     type DefaultType = Self;
12340 }
12341 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12342 #[repr(C)]
12343 pub struct SEC_PRESHAREDKEY_IDENTITY {
12344     pub KeyIdentitySize: u16,
12345     pub KeyIdentity: [u8; 1],
12346 }
12347 impl SEC_PRESHAREDKEY_IDENTITY {}
12348 impl ::std::default::Default for SEC_PRESHAREDKEY_IDENTITY {
12349     fn default() -> Self {
12350         unsafe { ::std::mem::zeroed() }
12351     }
12352 }
12353 impl ::std::fmt::Debug for SEC_PRESHAREDKEY_IDENTITY {
12354     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12355         fmt.debug_struct("SEC_PRESHAREDKEY_IDENTITY").field("KeyIdentitySize", &self.KeyIdentitySize).field("KeyIdentity", &self.KeyIdentity).finish()
12356     }
12357 }
12358 impl ::std::cmp::PartialEq for SEC_PRESHAREDKEY_IDENTITY {
12359     fn eq(&self, other: &Self) -> bool {
12360         self.KeyIdentitySize == other.KeyIdentitySize && self.KeyIdentity == other.KeyIdentity
12361     }
12362 }
12363 impl ::std::cmp::Eq for SEC_PRESHAREDKEY_IDENTITY {}
12364 unsafe impl ::windows::runtime::Abi for SEC_PRESHAREDKEY_IDENTITY {
12365     type Abi = Self;
12366     type DefaultType = Self;
12367 }
12368 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12369 #[repr(C)]
12370 pub struct SEC_SRTP_MASTER_KEY_IDENTIFIER {
12371     pub MasterKeyIdentifierSize: u8,
12372     pub MasterKeyIdentifier: [u8; 1],
12373 }
12374 impl SEC_SRTP_MASTER_KEY_IDENTIFIER {}
12375 impl ::std::default::Default for SEC_SRTP_MASTER_KEY_IDENTIFIER {
12376     fn default() -> Self {
12377         unsafe { ::std::mem::zeroed() }
12378     }
12379 }
12380 impl ::std::fmt::Debug for SEC_SRTP_MASTER_KEY_IDENTIFIER {
12381     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12382         fmt.debug_struct("SEC_SRTP_MASTER_KEY_IDENTIFIER").field("MasterKeyIdentifierSize", &self.MasterKeyIdentifierSize).field("MasterKeyIdentifier", &self.MasterKeyIdentifier).finish()
12383     }
12384 }
12385 impl ::std::cmp::PartialEq for SEC_SRTP_MASTER_KEY_IDENTIFIER {
12386     fn eq(&self, other: &Self) -> bool {
12387         self.MasterKeyIdentifierSize == other.MasterKeyIdentifierSize && self.MasterKeyIdentifier == other.MasterKeyIdentifier
12388     }
12389 }
12390 impl ::std::cmp::Eq for SEC_SRTP_MASTER_KEY_IDENTIFIER {}
12391 unsafe impl ::windows::runtime::Abi for SEC_SRTP_MASTER_KEY_IDENTIFIER {
12392     type Abi = Self;
12393     type DefaultType = Self;
12394 }
12395 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12396 #[repr(C)]
12397 pub struct SEC_SRTP_PROTECTION_PROFILES {
12398     pub ProfilesSize: u16,
12399     pub ProfilesList: [u16; 1],
12400 }
12401 impl SEC_SRTP_PROTECTION_PROFILES {}
12402 impl ::std::default::Default for SEC_SRTP_PROTECTION_PROFILES {
12403     fn default() -> Self {
12404         unsafe { ::std::mem::zeroed() }
12405     }
12406 }
12407 impl ::std::fmt::Debug for SEC_SRTP_PROTECTION_PROFILES {
12408     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12409         fmt.debug_struct("SEC_SRTP_PROTECTION_PROFILES").field("ProfilesSize", &self.ProfilesSize).field("ProfilesList", &self.ProfilesList).finish()
12410     }
12411 }
12412 impl ::std::cmp::PartialEq for SEC_SRTP_PROTECTION_PROFILES {
12413     fn eq(&self, other: &Self) -> bool {
12414         self.ProfilesSize == other.ProfilesSize && self.ProfilesList == other.ProfilesList
12415     }
12416 }
12417 impl ::std::cmp::Eq for SEC_SRTP_PROTECTION_PROFILES {}
12418 unsafe impl ::windows::runtime::Abi for SEC_SRTP_PROTECTION_PROFILES {
12419     type Abi = Self;
12420     type DefaultType = Self;
12421 }
12422 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12423 #[repr(C)]
12424 pub struct SEC_TOKEN_BINDING {
12425     pub MajorVersion: u8,
12426     pub MinorVersion: u8,
12427     pub KeyParametersSize: u16,
12428     pub KeyParameters: [u8; 1],
12429 }
12430 impl SEC_TOKEN_BINDING {}
12431 impl ::std::default::Default for SEC_TOKEN_BINDING {
12432     fn default() -> Self {
12433         unsafe { ::std::mem::zeroed() }
12434     }
12435 }
12436 impl ::std::fmt::Debug for SEC_TOKEN_BINDING {
12437     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12438         fmt.debug_struct("SEC_TOKEN_BINDING").field("MajorVersion", &self.MajorVersion).field("MinorVersion", &self.MinorVersion).field("KeyParametersSize", &self.KeyParametersSize).field("KeyParameters", &self.KeyParameters).finish()
12439     }
12440 }
12441 impl ::std::cmp::PartialEq for SEC_TOKEN_BINDING {
12442     fn eq(&self, other: &Self) -> bool {
12443         self.MajorVersion == other.MajorVersion && self.MinorVersion == other.MinorVersion && self.KeyParametersSize == other.KeyParametersSize && self.KeyParameters == other.KeyParameters
12444     }
12445 }
12446 impl ::std::cmp::Eq for SEC_TOKEN_BINDING {}
12447 unsafe impl ::windows::runtime::Abi for SEC_TOKEN_BINDING {
12448     type Abi = Self;
12449     type DefaultType = Self;
12450 }
12451 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12452 #[repr(C)]
12453 pub struct SEC_TRAFFIC_SECRETS {
12454     pub SymmetricAlgId: [u16; 64],
12455     pub ChainingMode: [u16; 64],
12456     pub HashAlgId: [u16; 64],
12457     pub KeySize: u16,
12458     pub IvSize: u16,
12459     pub MsgSequenceStart: u16,
12460     pub MsgSequenceEnd: u16,
12461     pub TrafficSecretType: SEC_TRAFFIC_SECRET_TYPE,
12462     pub TrafficSecretSize: u16,
12463     pub TrafficSecret: [u8; 1],
12464 }
12465 impl SEC_TRAFFIC_SECRETS {}
12466 impl ::std::default::Default for SEC_TRAFFIC_SECRETS {
12467     fn default() -> Self {
12468         unsafe { ::std::mem::zeroed() }
12469     }
12470 }
12471 impl ::std::fmt::Debug for SEC_TRAFFIC_SECRETS {
12472     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12473         fmt.debug_struct("SEC_TRAFFIC_SECRETS")
12474             .field("SymmetricAlgId", &self.SymmetricAlgId)
12475             .field("ChainingMode", &self.ChainingMode)
12476             .field("HashAlgId", &self.HashAlgId)
12477             .field("KeySize", &self.KeySize)
12478             .field("IvSize", &self.IvSize)
12479             .field("MsgSequenceStart", &self.MsgSequenceStart)
12480             .field("MsgSequenceEnd", &self.MsgSequenceEnd)
12481             .field("TrafficSecretType", &self.TrafficSecretType)
12482             .field("TrafficSecretSize", &self.TrafficSecretSize)
12483             .field("TrafficSecret", &self.TrafficSecret)
12484             .finish()
12485     }
12486 }
12487 impl ::std::cmp::PartialEq for SEC_TRAFFIC_SECRETS {
12488     fn eq(&self, other: &Self) -> bool {
12489         self.SymmetricAlgId == other.SymmetricAlgId && self.ChainingMode == other.ChainingMode && self.HashAlgId == other.HashAlgId && self.KeySize == other.KeySize && self.IvSize == other.IvSize && self.MsgSequenceStart == other.MsgSequenceStart && self.MsgSequenceEnd == other.MsgSequenceEnd && self.TrafficSecretType == other.TrafficSecretType && self.TrafficSecretSize == other.TrafficSecretSize && self.TrafficSecret == other.TrafficSecret
12490     }
12491 }
12492 impl ::std::cmp::Eq for SEC_TRAFFIC_SECRETS {}
12493 unsafe impl ::windows::runtime::Abi for SEC_TRAFFIC_SECRETS {
12494     type Abi = Self;
12495     type DefaultType = Self;
12496 }
12497 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12498 #[repr(transparent)]
12499 pub struct SEC_TRAFFIC_SECRET_TYPE(pub i32);
12500 pub const SecTrafficSecret_None: SEC_TRAFFIC_SECRET_TYPE = SEC_TRAFFIC_SECRET_TYPE(0i32);
12501 pub const SecTrafficSecret_Client: SEC_TRAFFIC_SECRET_TYPE = SEC_TRAFFIC_SECRET_TYPE(1i32);
12502 pub const SecTrafficSecret_Server: SEC_TRAFFIC_SECRET_TYPE = SEC_TRAFFIC_SECRET_TYPE(2i32);
12503 impl ::std::convert::From<i32> for SEC_TRAFFIC_SECRET_TYPE {
12504     fn from(value: i32) -> Self {
12505         Self(value)
12506     }
12507 }
12508 unsafe impl ::windows::runtime::Abi for SEC_TRAFFIC_SECRET_TYPE {
12509     type Abi = Self;
12510     type DefaultType = Self;
12511 }
12512 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12513 #[repr(C)]
12514 pub struct SEC_WINNT_AUTH_IDENTITY32 {
12515     pub User: u32,
12516     pub UserLength: u32,
12517     pub Domain: u32,
12518     pub DomainLength: u32,
12519     pub Password: u32,
12520     pub PasswordLength: u32,
12521     pub Flags: u32,
12522 }
12523 impl SEC_WINNT_AUTH_IDENTITY32 {}
12524 impl ::std::default::Default for SEC_WINNT_AUTH_IDENTITY32 {
12525     fn default() -> Self {
12526         unsafe { ::std::mem::zeroed() }
12527     }
12528 }
12529 impl ::std::fmt::Debug for SEC_WINNT_AUTH_IDENTITY32 {
12530     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12531         fmt.debug_struct("SEC_WINNT_AUTH_IDENTITY32").field("User", &self.User).field("UserLength", &self.UserLength).field("Domain", &self.Domain).field("DomainLength", &self.DomainLength).field("Password", &self.Password).field("PasswordLength", &self.PasswordLength).field("Flags", &self.Flags).finish()
12532     }
12533 }
12534 impl ::std::cmp::PartialEq for SEC_WINNT_AUTH_IDENTITY32 {
12535     fn eq(&self, other: &Self) -> bool {
12536         self.User == other.User && self.UserLength == other.UserLength && self.Domain == other.Domain && self.DomainLength == other.DomainLength && self.Password == other.Password && self.PasswordLength == other.PasswordLength && self.Flags == other.Flags
12537     }
12538 }
12539 impl ::std::cmp::Eq for SEC_WINNT_AUTH_IDENTITY32 {}
12540 unsafe impl ::windows::runtime::Abi for SEC_WINNT_AUTH_IDENTITY32 {
12541     type Abi = Self;
12542     type DefaultType = Self;
12543 }
12544 pub const SEC_WINNT_AUTH_IDENTITY_ENCRYPT_FOR_SYSTEM: u32 = 4u32;
12545 pub const SEC_WINNT_AUTH_IDENTITY_ENCRYPT_SAME_LOGON: u32 = 1u32;
12546 pub const SEC_WINNT_AUTH_IDENTITY_ENCRYPT_SAME_PROCESS: u32 = 2u32;
12547 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12548 #[repr(C)]
12549 pub struct SEC_WINNT_AUTH_IDENTITY_EX2 {
12550     pub Version: u32,
12551     pub cbHeaderLength: u16,
12552     pub cbStructureLength: u32,
12553     pub UserOffset: u32,
12554     pub UserLength: u16,
12555     pub DomainOffset: u32,
12556     pub DomainLength: u16,
12557     pub PackedCredentialsOffset: u32,
12558     pub PackedCredentialsLength: u16,
12559     pub Flags: u32,
12560     pub PackageListOffset: u32,
12561     pub PackageListLength: u16,
12562 }
12563 impl SEC_WINNT_AUTH_IDENTITY_EX2 {}
12564 impl ::std::default::Default for SEC_WINNT_AUTH_IDENTITY_EX2 {
12565     fn default() -> Self {
12566         unsafe { ::std::mem::zeroed() }
12567     }
12568 }
12569 impl ::std::fmt::Debug for SEC_WINNT_AUTH_IDENTITY_EX2 {
12570     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12571         fmt.debug_struct("SEC_WINNT_AUTH_IDENTITY_EX2")
12572             .field("Version", &self.Version)
12573             .field("cbHeaderLength", &self.cbHeaderLength)
12574             .field("cbStructureLength", &self.cbStructureLength)
12575             .field("UserOffset", &self.UserOffset)
12576             .field("UserLength", &self.UserLength)
12577             .field("DomainOffset", &self.DomainOffset)
12578             .field("DomainLength", &self.DomainLength)
12579             .field("PackedCredentialsOffset", &self.PackedCredentialsOffset)
12580             .field("PackedCredentialsLength", &self.PackedCredentialsLength)
12581             .field("Flags", &self.Flags)
12582             .field("PackageListOffset", &self.PackageListOffset)
12583             .field("PackageListLength", &self.PackageListLength)
12584             .finish()
12585     }
12586 }
12587 impl ::std::cmp::PartialEq for SEC_WINNT_AUTH_IDENTITY_EX2 {
12588     fn eq(&self, other: &Self) -> bool {
12589         self.Version == other.Version
12590             && self.cbHeaderLength == other.cbHeaderLength
12591             && self.cbStructureLength == other.cbStructureLength
12592             && self.UserOffset == other.UserOffset
12593             && self.UserLength == other.UserLength
12594             && self.DomainOffset == other.DomainOffset
12595             && self.DomainLength == other.DomainLength
12596             && self.PackedCredentialsOffset == other.PackedCredentialsOffset
12597             && self.PackedCredentialsLength == other.PackedCredentialsLength
12598             && self.Flags == other.Flags
12599             && self.PackageListOffset == other.PackageListOffset
12600             && self.PackageListLength == other.PackageListLength
12601     }
12602 }
12603 impl ::std::cmp::Eq for SEC_WINNT_AUTH_IDENTITY_EX2 {}
12604 unsafe impl ::windows::runtime::Abi for SEC_WINNT_AUTH_IDENTITY_EX2 {
12605     type Abi = Self;
12606     type DefaultType = Self;
12607 }
12608 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12609 #[repr(C)]
12610 pub struct SEC_WINNT_AUTH_IDENTITY_EX32 {
12611     pub Version: u32,
12612     pub Length: u32,
12613     pub User: u32,
12614     pub UserLength: u32,
12615     pub Domain: u32,
12616     pub DomainLength: u32,
12617     pub Password: u32,
12618     pub PasswordLength: u32,
12619     pub Flags: u32,
12620     pub PackageList: u32,
12621     pub PackageListLength: u32,
12622 }
12623 impl SEC_WINNT_AUTH_IDENTITY_EX32 {}
12624 impl ::std::default::Default for SEC_WINNT_AUTH_IDENTITY_EX32 {
12625     fn default() -> Self {
12626         unsafe { ::std::mem::zeroed() }
12627     }
12628 }
12629 impl ::std::fmt::Debug for SEC_WINNT_AUTH_IDENTITY_EX32 {
12630     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12631         fmt.debug_struct("SEC_WINNT_AUTH_IDENTITY_EX32")
12632             .field("Version", &self.Version)
12633             .field("Length", &self.Length)
12634             .field("User", &self.User)
12635             .field("UserLength", &self.UserLength)
12636             .field("Domain", &self.Domain)
12637             .field("DomainLength", &self.DomainLength)
12638             .field("Password", &self.Password)
12639             .field("PasswordLength", &self.PasswordLength)
12640             .field("Flags", &self.Flags)
12641             .field("PackageList", &self.PackageList)
12642             .field("PackageListLength", &self.PackageListLength)
12643             .finish()
12644     }
12645 }
12646 impl ::std::cmp::PartialEq for SEC_WINNT_AUTH_IDENTITY_EX32 {
12647     fn eq(&self, other: &Self) -> bool {
12648         self.Version == other.Version && self.Length == other.Length && self.User == other.User && self.UserLength == other.UserLength && self.Domain == other.Domain && self.DomainLength == other.DomainLength && self.Password == other.Password && self.PasswordLength == other.PasswordLength && self.Flags == other.Flags && self.PackageList == other.PackageList && self.PackageListLength == other.PackageListLength
12649     }
12650 }
12651 impl ::std::cmp::Eq for SEC_WINNT_AUTH_IDENTITY_EX32 {}
12652 unsafe impl ::windows::runtime::Abi for SEC_WINNT_AUTH_IDENTITY_EX32 {
12653     type Abi = Self;
12654     type DefaultType = Self;
12655 }
12656 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12657 #[repr(C)]
12658 pub struct SEC_WINNT_AUTH_IDENTITY_EXA {
12659     pub Version: u32,
12660     pub Length: u32,
12661     pub User: *mut u8,
12662     pub UserLength: u32,
12663     pub Domain: *mut u8,
12664     pub DomainLength: u32,
12665     pub Password: *mut u8,
12666     pub PasswordLength: u32,
12667     pub Flags: u32,
12668     pub PackageList: *mut u8,
12669     pub PackageListLength: u32,
12670 }
12671 impl SEC_WINNT_AUTH_IDENTITY_EXA {}
12672 impl ::std::default::Default for SEC_WINNT_AUTH_IDENTITY_EXA {
12673     fn default() -> Self {
12674         unsafe { ::std::mem::zeroed() }
12675     }
12676 }
12677 impl ::std::fmt::Debug for SEC_WINNT_AUTH_IDENTITY_EXA {
12678     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12679         fmt.debug_struct("SEC_WINNT_AUTH_IDENTITY_EXA")
12680             .field("Version", &self.Version)
12681             .field("Length", &self.Length)
12682             .field("User", &self.User)
12683             .field("UserLength", &self.UserLength)
12684             .field("Domain", &self.Domain)
12685             .field("DomainLength", &self.DomainLength)
12686             .field("Password", &self.Password)
12687             .field("PasswordLength", &self.PasswordLength)
12688             .field("Flags", &self.Flags)
12689             .field("PackageList", &self.PackageList)
12690             .field("PackageListLength", &self.PackageListLength)
12691             .finish()
12692     }
12693 }
12694 impl ::std::cmp::PartialEq for SEC_WINNT_AUTH_IDENTITY_EXA {
12695     fn eq(&self, other: &Self) -> bool {
12696         self.Version == other.Version && self.Length == other.Length && self.User == other.User && self.UserLength == other.UserLength && self.Domain == other.Domain && self.DomainLength == other.DomainLength && self.Password == other.Password && self.PasswordLength == other.PasswordLength && self.Flags == other.Flags && self.PackageList == other.PackageList && self.PackageListLength == other.PackageListLength
12697     }
12698 }
12699 impl ::std::cmp::Eq for SEC_WINNT_AUTH_IDENTITY_EXA {}
12700 unsafe impl ::windows::runtime::Abi for SEC_WINNT_AUTH_IDENTITY_EXA {
12701     type Abi = Self;
12702     type DefaultType = Self;
12703 }
12704 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12705 #[repr(C)]
12706 pub struct SEC_WINNT_AUTH_IDENTITY_EXW {
12707     pub Version: u32,
12708     pub Length: u32,
12709     pub User: *mut u16,
12710     pub UserLength: u32,
12711     pub Domain: *mut u16,
12712     pub DomainLength: u32,
12713     pub Password: *mut u16,
12714     pub PasswordLength: u32,
12715     pub Flags: u32,
12716     pub PackageList: *mut u16,
12717     pub PackageListLength: u32,
12718 }
12719 impl SEC_WINNT_AUTH_IDENTITY_EXW {}
12720 impl ::std::default::Default for SEC_WINNT_AUTH_IDENTITY_EXW {
12721     fn default() -> Self {
12722         unsafe { ::std::mem::zeroed() }
12723     }
12724 }
12725 impl ::std::fmt::Debug for SEC_WINNT_AUTH_IDENTITY_EXW {
12726     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12727         fmt.debug_struct("SEC_WINNT_AUTH_IDENTITY_EXW")
12728             .field("Version", &self.Version)
12729             .field("Length", &self.Length)
12730             .field("User", &self.User)
12731             .field("UserLength", &self.UserLength)
12732             .field("Domain", &self.Domain)
12733             .field("DomainLength", &self.DomainLength)
12734             .field("Password", &self.Password)
12735             .field("PasswordLength", &self.PasswordLength)
12736             .field("Flags", &self.Flags)
12737             .field("PackageList", &self.PackageList)
12738             .field("PackageListLength", &self.PackageListLength)
12739             .finish()
12740     }
12741 }
12742 impl ::std::cmp::PartialEq for SEC_WINNT_AUTH_IDENTITY_EXW {
12743     fn eq(&self, other: &Self) -> bool {
12744         self.Version == other.Version && self.Length == other.Length && self.User == other.User && self.UserLength == other.UserLength && self.Domain == other.Domain && self.DomainLength == other.DomainLength && self.Password == other.Password && self.PasswordLength == other.PasswordLength && self.Flags == other.Flags && self.PackageList == other.PackageList && self.PackageListLength == other.PackageListLength
12745     }
12746 }
12747 impl ::std::cmp::Eq for SEC_WINNT_AUTH_IDENTITY_EXW {}
12748 unsafe impl ::windows::runtime::Abi for SEC_WINNT_AUTH_IDENTITY_EXW {
12749     type Abi = Self;
12750     type DefaultType = Self;
12751 }
12752 pub const SEC_WINNT_AUTH_IDENTITY_FLAGS_ID_PROVIDER: u32 = 524288u32;
12753 pub const SEC_WINNT_AUTH_IDENTITY_FLAGS_NULL_DOMAIN: u32 = 262144u32;
12754 pub const SEC_WINNT_AUTH_IDENTITY_FLAGS_NULL_USER: u32 = 131072u32;
12755 pub const SEC_WINNT_AUTH_IDENTITY_FLAGS_PROCESS_ENCRYPTED: u32 = 16u32;
12756 pub const SEC_WINNT_AUTH_IDENTITY_FLAGS_RESERVED: u32 = 65536u32;
12757 pub const SEC_WINNT_AUTH_IDENTITY_FLAGS_SSPIPFC_CREDPROV_DO_NOT_LOAD: u32 = 268435456u32;
12758 pub const SEC_WINNT_AUTH_IDENTITY_FLAGS_SSPIPFC_CREDPROV_DO_NOT_SAVE: u32 = 2147483648u32;
12759 pub const SEC_WINNT_AUTH_IDENTITY_FLAGS_SSPIPFC_NO_CHECKBOX: u32 = 536870912u32;
12760 pub const SEC_WINNT_AUTH_IDENTITY_FLAGS_SSPIPFC_SAVE_CRED_BY_CALLER: u32 = 2147483648u32;
12761 pub const SEC_WINNT_AUTH_IDENTITY_FLAGS_SSPIPFC_SAVE_CRED_CHECKED: u32 = 1073741824u32;
12762 pub const SEC_WINNT_AUTH_IDENTITY_FLAGS_SSPIPFC_USE_MASK: u32 = 4278190080u32;
12763 pub const SEC_WINNT_AUTH_IDENTITY_FLAGS_SYSTEM_ENCRYPTED: u32 = 128u32;
12764 pub const SEC_WINNT_AUTH_IDENTITY_FLAGS_SYSTEM_PROTECTED: u32 = 32u32;
12765 pub const SEC_WINNT_AUTH_IDENTITY_FLAGS_USER_PROTECTED: u32 = 64u32;
12766 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12767 #[repr(C)]
12768 #[cfg(feature = "Win32_System_Rpc")]
12769 pub union SEC_WINNT_AUTH_IDENTITY_INFO {
12770     pub AuthIdExw: SEC_WINNT_AUTH_IDENTITY_EXW,
12771     pub AuthIdExa: SEC_WINNT_AUTH_IDENTITY_EXA,
12772     pub AuthId_a: super::super::super::System::Rpc::SEC_WINNT_AUTH_IDENTITY_A,
12773     pub AuthId_w: super::super::super::System::Rpc::SEC_WINNT_AUTH_IDENTITY_W,
12774     pub AuthIdEx2: SEC_WINNT_AUTH_IDENTITY_EX2,
12775 }
12776 #[cfg(feature = "Win32_System_Rpc")]
12777 impl SEC_WINNT_AUTH_IDENTITY_INFO {}
12778 #[cfg(feature = "Win32_System_Rpc")]
12779 impl ::std::default::Default for SEC_WINNT_AUTH_IDENTITY_INFO {
12780     fn default() -> Self {
12781         unsafe { ::std::mem::zeroed() }
12782     }
12783 }
12784 #[cfg(feature = "Win32_System_Rpc")]
12785 impl ::std::cmp::PartialEq for SEC_WINNT_AUTH_IDENTITY_INFO {
12786     fn eq(&self, _other: &Self) -> bool {
12787         unimplemented!()
12788     }
12789 }
12790 #[cfg(feature = "Win32_System_Rpc")]
12791 impl ::std::cmp::Eq for SEC_WINNT_AUTH_IDENTITY_INFO {}
12792 #[cfg(feature = "Win32_System_Rpc")]
12793 unsafe impl ::windows::runtime::Abi for SEC_WINNT_AUTH_IDENTITY_INFO {
12794     type Abi = Self;
12795     type DefaultType = Self;
12796 }
12797 pub const SEC_WINNT_AUTH_IDENTITY_MARSHALLED: u32 = 4u32;
12798 pub const SEC_WINNT_AUTH_IDENTITY_ONLY: u32 = 8u32;
12799 pub const SEC_WINNT_AUTH_IDENTITY_VERSION: u32 = 512u32;
12800 pub const SEC_WINNT_AUTH_IDENTITY_VERSION_2: u32 = 513u32;
12801 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12802 #[repr(C)]
12803 pub struct SEND_GENERIC_TLS_EXTENSION {
12804     pub ExtensionType: u16,
12805     pub HandshakeType: u16,
12806     pub Flags: u32,
12807     pub BufferSize: u16,
12808     pub Buffer: [u8; 1],
12809 }
12810 impl SEND_GENERIC_TLS_EXTENSION {}
12811 impl ::std::default::Default for SEND_GENERIC_TLS_EXTENSION {
12812     fn default() -> Self {
12813         unsafe { ::std::mem::zeroed() }
12814     }
12815 }
12816 impl ::std::fmt::Debug for SEND_GENERIC_TLS_EXTENSION {
12817     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12818         fmt.debug_struct("SEND_GENERIC_TLS_EXTENSION").field("ExtensionType", &self.ExtensionType).field("HandshakeType", &self.HandshakeType).field("Flags", &self.Flags).field("BufferSize", &self.BufferSize).field("Buffer", &self.Buffer).finish()
12819     }
12820 }
12821 impl ::std::cmp::PartialEq for SEND_GENERIC_TLS_EXTENSION {
12822     fn eq(&self, other: &Self) -> bool {
12823         self.ExtensionType == other.ExtensionType && self.HandshakeType == other.HandshakeType && self.Flags == other.Flags && self.BufferSize == other.BufferSize && self.Buffer == other.Buffer
12824     }
12825 }
12826 impl ::std::cmp::Eq for SEND_GENERIC_TLS_EXTENSION {}
12827 unsafe impl ::windows::runtime::Abi for SEND_GENERIC_TLS_EXTENSION {
12828     type Abi = Self;
12829     type DefaultType = Self;
12830 }
12831 pub const SESSION_TICKET_INFO_V0: u32 = 0u32;
12832 pub const SESSION_TICKET_INFO_VERSION: u32 = 0u32;
12833 #[cfg(feature = "Win32_Security_Credentials")]
12834 pub type SET_CONTEXT_ATTRIBUTES_FN_A = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: u32, param2: *mut ::std::ffi::c_void, param3: u32) -> i32;
12835 #[cfg(feature = "Win32_Security_Credentials")]
12836 pub type SET_CONTEXT_ATTRIBUTES_FN_W = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: u32, param2: *mut ::std::ffi::c_void, param3: u32) -> i32;
12837 #[cfg(feature = "Win32_Security_Credentials")]
12838 pub type SET_CREDENTIALS_ATTRIBUTES_FN_A = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: u32, param2: *mut ::std::ffi::c_void, param3: u32) -> i32;
12839 #[cfg(feature = "Win32_Security_Credentials")]
12840 pub type SET_CREDENTIALS_ATTRIBUTES_FN_W = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: u32, param2: *mut ::std::ffi::c_void, param3: u32) -> i32;
12841 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12842 #[repr(C)]
12843 #[cfg(feature = "Win32_Foundation")]
12844 pub struct SE_ADT_ACCESS_REASON {
12845     pub AccessMask: u32,
12846     pub AccessReasons: [u32; 32],
12847     pub ObjectTypeIndex: u32,
12848     pub AccessGranted: u32,
12849     pub SecurityDescriptor: *mut super::super::SECURITY_DESCRIPTOR,
12850 }
12851 #[cfg(feature = "Win32_Foundation")]
12852 impl SE_ADT_ACCESS_REASON {}
12853 #[cfg(feature = "Win32_Foundation")]
12854 impl ::std::default::Default for SE_ADT_ACCESS_REASON {
12855     fn default() -> Self {
12856         unsafe { ::std::mem::zeroed() }
12857     }
12858 }
12859 #[cfg(feature = "Win32_Foundation")]
12860 impl ::std::fmt::Debug for SE_ADT_ACCESS_REASON {
12861     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12862         fmt.debug_struct("SE_ADT_ACCESS_REASON").field("AccessMask", &self.AccessMask).field("AccessReasons", &self.AccessReasons).field("ObjectTypeIndex", &self.ObjectTypeIndex).field("AccessGranted", &self.AccessGranted).field("SecurityDescriptor", &self.SecurityDescriptor).finish()
12863     }
12864 }
12865 #[cfg(feature = "Win32_Foundation")]
12866 impl ::std::cmp::PartialEq for SE_ADT_ACCESS_REASON {
12867     fn eq(&self, other: &Self) -> bool {
12868         self.AccessMask == other.AccessMask && self.AccessReasons == other.AccessReasons && self.ObjectTypeIndex == other.ObjectTypeIndex && self.AccessGranted == other.AccessGranted && self.SecurityDescriptor == other.SecurityDescriptor
12869     }
12870 }
12871 #[cfg(feature = "Win32_Foundation")]
12872 impl ::std::cmp::Eq for SE_ADT_ACCESS_REASON {}
12873 #[cfg(feature = "Win32_Foundation")]
12874 unsafe impl ::windows::runtime::Abi for SE_ADT_ACCESS_REASON {
12875     type Abi = Self;
12876     type DefaultType = Self;
12877 }
12878 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12879 #[repr(C)]
12880 pub struct SE_ADT_CLAIMS {
12881     pub Length: u32,
12882     pub Claims: *mut ::std::ffi::c_void,
12883 }
12884 impl SE_ADT_CLAIMS {}
12885 impl ::std::default::Default for SE_ADT_CLAIMS {
12886     fn default() -> Self {
12887         unsafe { ::std::mem::zeroed() }
12888     }
12889 }
12890 impl ::std::fmt::Debug for SE_ADT_CLAIMS {
12891     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12892         fmt.debug_struct("SE_ADT_CLAIMS").field("Length", &self.Length).field("Claims", &self.Claims).finish()
12893     }
12894 }
12895 impl ::std::cmp::PartialEq for SE_ADT_CLAIMS {
12896     fn eq(&self, other: &Self) -> bool {
12897         self.Length == other.Length && self.Claims == other.Claims
12898     }
12899 }
12900 impl ::std::cmp::Eq for SE_ADT_CLAIMS {}
12901 unsafe impl ::windows::runtime::Abi for SE_ADT_CLAIMS {
12902     type Abi = Self;
12903     type DefaultType = Self;
12904 }
12905 pub const SE_ADT_OBJECT_ONLY: u32 = 1u32;
12906 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12907 #[repr(C)]
12908 pub struct SE_ADT_OBJECT_TYPE {
12909     pub ObjectType: ::windows::runtime::GUID,
12910     pub Flags: u16,
12911     pub Level: u16,
12912     pub AccessMask: u32,
12913 }
12914 impl SE_ADT_OBJECT_TYPE {}
12915 impl ::std::default::Default for SE_ADT_OBJECT_TYPE {
12916     fn default() -> Self {
12917         unsafe { ::std::mem::zeroed() }
12918     }
12919 }
12920 impl ::std::fmt::Debug for SE_ADT_OBJECT_TYPE {
12921     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12922         fmt.debug_struct("SE_ADT_OBJECT_TYPE").field("ObjectType", &self.ObjectType).field("Flags", &self.Flags).field("Level", &self.Level).field("AccessMask", &self.AccessMask).finish()
12923     }
12924 }
12925 impl ::std::cmp::PartialEq for SE_ADT_OBJECT_TYPE {
12926     fn eq(&self, other: &Self) -> bool {
12927         self.ObjectType == other.ObjectType && self.Flags == other.Flags && self.Level == other.Level && self.AccessMask == other.AccessMask
12928     }
12929 }
12930 impl ::std::cmp::Eq for SE_ADT_OBJECT_TYPE {}
12931 unsafe impl ::windows::runtime::Abi for SE_ADT_OBJECT_TYPE {
12932     type Abi = Self;
12933     type DefaultType = Self;
12934 }
12935 pub const SE_ADT_PARAMETERS_SELF_RELATIVE: u32 = 1u32;
12936 pub const SE_ADT_PARAMETERS_SEND_TO_LSA: u32 = 2u32;
12937 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12938 #[repr(C)]
12939 pub struct SE_ADT_PARAMETER_ARRAY {
12940     pub CategoryId: u32,
12941     pub AuditId: u32,
12942     pub ParameterCount: u32,
12943     pub Length: u32,
12944     pub FlatSubCategoryId: u16,
12945     pub Type: u16,
12946     pub Flags: u32,
12947     pub Parameters: [SE_ADT_PARAMETER_ARRAY_ENTRY; 32],
12948 }
12949 impl SE_ADT_PARAMETER_ARRAY {}
12950 impl ::std::default::Default for SE_ADT_PARAMETER_ARRAY {
12951     fn default() -> Self {
12952         unsafe { ::std::mem::zeroed() }
12953     }
12954 }
12955 impl ::std::fmt::Debug for SE_ADT_PARAMETER_ARRAY {
12956     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12957         fmt.debug_struct("SE_ADT_PARAMETER_ARRAY")
12958             .field("CategoryId", &self.CategoryId)
12959             .field("AuditId", &self.AuditId)
12960             .field("ParameterCount", &self.ParameterCount)
12961             .field("Length", &self.Length)
12962             .field("FlatSubCategoryId", &self.FlatSubCategoryId)
12963             .field("Type", &self.Type)
12964             .field("Flags", &self.Flags)
12965             .field("Parameters", &self.Parameters)
12966             .finish()
12967     }
12968 }
12969 impl ::std::cmp::PartialEq for SE_ADT_PARAMETER_ARRAY {
12970     fn eq(&self, other: &Self) -> bool {
12971         self.CategoryId == other.CategoryId && self.AuditId == other.AuditId && self.ParameterCount == other.ParameterCount && self.Length == other.Length && self.FlatSubCategoryId == other.FlatSubCategoryId && self.Type == other.Type && self.Flags == other.Flags && self.Parameters == other.Parameters
12972     }
12973 }
12974 impl ::std::cmp::Eq for SE_ADT_PARAMETER_ARRAY {}
12975 unsafe impl ::windows::runtime::Abi for SE_ADT_PARAMETER_ARRAY {
12976     type Abi = Self;
12977     type DefaultType = Self;
12978 }
12979 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12980 #[repr(C)]
12981 pub struct SE_ADT_PARAMETER_ARRAY_ENTRY {
12982     pub Type: SE_ADT_PARAMETER_TYPE,
12983     pub Length: u32,
12984     pub Data: [usize; 2],
12985     pub Address: *mut ::std::ffi::c_void,
12986 }
12987 impl SE_ADT_PARAMETER_ARRAY_ENTRY {}
12988 impl ::std::default::Default for SE_ADT_PARAMETER_ARRAY_ENTRY {
12989     fn default() -> Self {
12990         unsafe { ::std::mem::zeroed() }
12991     }
12992 }
12993 impl ::std::fmt::Debug for SE_ADT_PARAMETER_ARRAY_ENTRY {
12994     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12995         fmt.debug_struct("SE_ADT_PARAMETER_ARRAY_ENTRY").field("Type", &self.Type).field("Length", &self.Length).field("Data", &self.Data).field("Address", &self.Address).finish()
12996     }
12997 }
12998 impl ::std::cmp::PartialEq for SE_ADT_PARAMETER_ARRAY_ENTRY {
12999     fn eq(&self, other: &Self) -> bool {
13000         self.Type == other.Type && self.Length == other.Length && self.Data == other.Data && self.Address == other.Address
13001     }
13002 }
13003 impl ::std::cmp::Eq for SE_ADT_PARAMETER_ARRAY_ENTRY {}
13004 unsafe impl ::windows::runtime::Abi for SE_ADT_PARAMETER_ARRAY_ENTRY {
13005     type Abi = Self;
13006     type DefaultType = Self;
13007 }
13008 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13009 #[repr(C)]
13010 pub struct SE_ADT_PARAMETER_ARRAY_EX {
13011     pub CategoryId: u32,
13012     pub AuditId: u32,
13013     pub Version: u32,
13014     pub ParameterCount: u32,
13015     pub Length: u32,
13016     pub FlatSubCategoryId: u16,
13017     pub Type: u16,
13018     pub Flags: u32,
13019     pub Parameters: [SE_ADT_PARAMETER_ARRAY_ENTRY; 32],
13020 }
13021 impl SE_ADT_PARAMETER_ARRAY_EX {}
13022 impl ::std::default::Default for SE_ADT_PARAMETER_ARRAY_EX {
13023     fn default() -> Self {
13024         unsafe { ::std::mem::zeroed() }
13025     }
13026 }
13027 impl ::std::fmt::Debug for SE_ADT_PARAMETER_ARRAY_EX {
13028     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13029         fmt.debug_struct("SE_ADT_PARAMETER_ARRAY_EX")
13030             .field("CategoryId", &self.CategoryId)
13031             .field("AuditId", &self.AuditId)
13032             .field("Version", &self.Version)
13033             .field("ParameterCount", &self.ParameterCount)
13034             .field("Length", &self.Length)
13035             .field("FlatSubCategoryId", &self.FlatSubCategoryId)
13036             .field("Type", &self.Type)
13037             .field("Flags", &self.Flags)
13038             .field("Parameters", &self.Parameters)
13039             .finish()
13040     }
13041 }
13042 impl ::std::cmp::PartialEq for SE_ADT_PARAMETER_ARRAY_EX {
13043     fn eq(&self, other: &Self) -> bool {
13044         self.CategoryId == other.CategoryId && self.AuditId == other.AuditId && self.Version == other.Version && self.ParameterCount == other.ParameterCount && self.Length == other.Length && self.FlatSubCategoryId == other.FlatSubCategoryId && self.Type == other.Type && self.Flags == other.Flags && self.Parameters == other.Parameters
13045     }
13046 }
13047 impl ::std::cmp::Eq for SE_ADT_PARAMETER_ARRAY_EX {}
13048 unsafe impl ::windows::runtime::Abi for SE_ADT_PARAMETER_ARRAY_EX {
13049     type Abi = Self;
13050     type DefaultType = Self;
13051 }
13052 pub const SE_ADT_PARAMETER_EXTENSIBLE_AUDIT: u32 = 4u32;
13053 pub const SE_ADT_PARAMETER_GENERIC_AUDIT: u32 = 8u32;
13054 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
13055 #[repr(transparent)]
13056 pub struct SE_ADT_PARAMETER_TYPE(pub i32);
13057 pub const SeAdtParmTypeNone: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(0i32);
13058 pub const SeAdtParmTypeString: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(1i32);
13059 pub const SeAdtParmTypeFileSpec: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(2i32);
13060 pub const SeAdtParmTypeUlong: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(3i32);
13061 pub const SeAdtParmTypeSid: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(4i32);
13062 pub const SeAdtParmTypeLogonId: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(5i32);
13063 pub const SeAdtParmTypeNoLogonId: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(6i32);
13064 pub const SeAdtParmTypeAccessMask: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(7i32);
13065 pub const SeAdtParmTypePrivs: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(8i32);
13066 pub const SeAdtParmTypeObjectTypes: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(9i32);
13067 pub const SeAdtParmTypeHexUlong: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(10i32);
13068 pub const SeAdtParmTypePtr: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(11i32);
13069 pub const SeAdtParmTypeTime: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(12i32);
13070 pub const SeAdtParmTypeGuid: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(13i32);
13071 pub const SeAdtParmTypeLuid: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(14i32);
13072 pub const SeAdtParmTypeHexInt64: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(15i32);
13073 pub const SeAdtParmTypeStringList: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(16i32);
13074 pub const SeAdtParmTypeSidList: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(17i32);
13075 pub const SeAdtParmTypeDuration: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(18i32);
13076 pub const SeAdtParmTypeUserAccountControl: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(19i32);
13077 pub const SeAdtParmTypeNoUac: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(20i32);
13078 pub const SeAdtParmTypeMessage: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(21i32);
13079 pub const SeAdtParmTypeDateTime: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(22i32);
13080 pub const SeAdtParmTypeSockAddr: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(23i32);
13081 pub const SeAdtParmTypeSD: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(24i32);
13082 pub const SeAdtParmTypeLogonHours: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(25i32);
13083 pub const SeAdtParmTypeLogonIdNoSid: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(26i32);
13084 pub const SeAdtParmTypeUlongNoConv: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(27i32);
13085 pub const SeAdtParmTypeSockAddrNoPort: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(28i32);
13086 pub const SeAdtParmTypeAccessReason: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(29i32);
13087 pub const SeAdtParmTypeStagingReason: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(30i32);
13088 pub const SeAdtParmTypeResourceAttribute: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(31i32);
13089 pub const SeAdtParmTypeClaims: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(32i32);
13090 pub const SeAdtParmTypeLogonIdAsSid: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(33i32);
13091 pub const SeAdtParmTypeMultiSzString: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(34i32);
13092 pub const SeAdtParmTypeLogonIdEx: SE_ADT_PARAMETER_TYPE = SE_ADT_PARAMETER_TYPE(35i32);
13093 impl ::std::convert::From<i32> for SE_ADT_PARAMETER_TYPE {
13094     fn from(value: i32) -> Self {
13095         Self(value)
13096     }
13097 }
13098 unsafe impl ::windows::runtime::Abi for SE_ADT_PARAMETER_TYPE {
13099     type Abi = Self;
13100     type DefaultType = Self;
13101 }
13102 pub const SE_ADT_PARAMETER_WRITE_SYNCHRONOUS: u32 = 16u32;
13103 pub const SE_ADT_POLICY_AUDIT_EVENT_TYPE_EX_BEGIN: u32 = 100u32;
13104 pub const SE_MAX_AUDIT_PARAMETERS: u32 = 32u32;
13105 pub const SE_MAX_GENERIC_AUDIT_PARAMETERS: u32 = 28u32;
13106 #[cfg(feature = "Win32_Foundation")]
13107 #[inline]
13108 pub unsafe fn SLAcquireGenuineTicket<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(ppticketblob: *mut *mut ::std::ffi::c_void, pcbticketblob: *mut u32, pwsztemplateid: Param2, pwszserverurl: Param3, pwszclienttoken: Param4) -> ::windows::runtime::Result<()> {
13109     #[cfg(windows)]
13110     {
13111         #[link(name = "windows")]
13112         extern "system" {
13113             fn SLAcquireGenuineTicket(ppticketblob: *mut *mut ::std::ffi::c_void, pcbticketblob: *mut u32, pwsztemplateid: super::super::super::Foundation::PWSTR, pwszserverurl: super::super::super::Foundation::PWSTR, pwszclienttoken: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT;
13114         }
13115         SLAcquireGenuineTicket(::std::mem::transmute(ppticketblob), ::std::mem::transmute(pcbticketblob), pwsztemplateid.into_param().abi(), pwszserverurl.into_param().abi(), pwszclienttoken.into_param().abi()).ok()
13116     }
13117     #[cfg(not(windows))]
13118     unimplemented!("Unsupported target OS");
13119 }
13120 #[cfg(feature = "Win32_Foundation")]
13121 #[inline]
13122 pub unsafe fn SLActivateProduct<'a, Param5: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hslc: *const ::std::ffi::c_void, pproductskuid: *const ::windows::runtime::GUID, cbappspecificdata: u32, pvappspecificdata: *const ::std::ffi::c_void, pactivationinfo: *const SL_ACTIVATION_INFO_HEADER, pwszproxyserver: Param5, wproxyport: u16) -> ::windows::runtime::Result<()> {
13123     #[cfg(windows)]
13124     {
13125         #[link(name = "windows")]
13126         extern "system" {
13127             fn SLActivateProduct(hslc: *const ::std::ffi::c_void, pproductskuid: *const ::windows::runtime::GUID, cbappspecificdata: u32, pvappspecificdata: *const ::std::ffi::c_void, pactivationinfo: *const SL_ACTIVATION_INFO_HEADER, pwszproxyserver: super::super::super::Foundation::PWSTR, wproxyport: u16) -> ::windows::runtime::HRESULT;
13128         }
13129         SLActivateProduct(::std::mem::transmute(hslc), ::std::mem::transmute(pproductskuid), ::std::mem::transmute(cbappspecificdata), ::std::mem::transmute(pvappspecificdata), ::std::mem::transmute(pactivationinfo), pwszproxyserver.into_param().abi(), ::std::mem::transmute(wproxyport)).ok()
13130     }
13131     #[cfg(not(windows))]
13132     unimplemented!("Unsupported target OS");
13133 }
13134 #[inline]
13135 pub unsafe fn SLClose(hslc: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
13136     #[cfg(windows)]
13137     {
13138         #[link(name = "windows")]
13139         extern "system" {
13140             fn SLClose(hslc: *const ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
13141         }
13142         SLClose(::std::mem::transmute(hslc)).ok()
13143     }
13144     #[cfg(not(windows))]
13145     unimplemented!("Unsupported target OS");
13146 }
13147 #[cfg(feature = "Win32_Foundation")]
13148 #[inline]
13149 pub unsafe fn SLConsumeRight<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hslc: *const ::std::ffi::c_void, pappid: *const ::windows::runtime::GUID, pproductskuid: *const ::windows::runtime::GUID, pwszrightname: Param3, pvreserved: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
13150     #[cfg(windows)]
13151     {
13152         #[link(name = "windows")]
13153         extern "system" {
13154             fn SLConsumeRight(hslc: *const ::std::ffi::c_void, pappid: *const ::windows::runtime::GUID, pproductskuid: *const ::windows::runtime::GUID, pwszrightname: super::super::super::Foundation::PWSTR, pvreserved: *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
13155         }
13156         SLConsumeRight(::std::mem::transmute(hslc), ::std::mem::transmute(pappid), ::std::mem::transmute(pproductskuid), pwszrightname.into_param().abi(), ::std::mem::transmute(pvreserved)).ok()
13157     }
13158     #[cfg(not(windows))]
13159     unimplemented!("Unsupported target OS");
13160 }
13161 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
13162 #[repr(transparent)]
13163 pub struct SLDATATYPE(pub u32);
13164 pub const SL_DATA_NONE: SLDATATYPE = SLDATATYPE(0u32);
13165 pub const SL_DATA_SZ: SLDATATYPE = SLDATATYPE(1u32);
13166 pub const SL_DATA_DWORD: SLDATATYPE = SLDATATYPE(4u32);
13167 pub const SL_DATA_BINARY: SLDATATYPE = SLDATATYPE(3u32);
13168 pub const SL_DATA_MULTI_SZ: SLDATATYPE = SLDATATYPE(7u32);
13169 pub const SL_DATA_SUM: SLDATATYPE = SLDATATYPE(100u32);
13170 impl ::std::convert::From<u32> for SLDATATYPE {
13171     fn from(value: u32) -> Self {
13172         Self(value)
13173     }
13174 }
13175 unsafe impl ::windows::runtime::Abi for SLDATATYPE {
13176     type Abi = Self;
13177     type DefaultType = Self;
13178 }
13179 impl ::std::ops::BitOr for SLDATATYPE {
13180     type Output = Self;
13181     fn bitor(self, rhs: Self) -> Self {
13182         Self(self.0 | rhs.0)
13183     }
13184 }
13185 impl ::std::ops::BitAnd for SLDATATYPE {
13186     type Output = Self;
13187     fn bitand(self, rhs: Self) -> Self {
13188         Self(self.0 & rhs.0)
13189     }
13190 }
13191 impl ::std::ops::BitOrAssign for SLDATATYPE {
13192     fn bitor_assign(&mut self, rhs: Self) {
13193         self.0.bitor_assign(rhs.0)
13194     }
13195 }
13196 impl ::std::ops::BitAndAssign for SLDATATYPE {
13197     fn bitand_assign(&mut self, rhs: Self) {
13198         self.0.bitand_assign(rhs.0)
13199     }
13200 }
13201 impl ::std::ops::Not for SLDATATYPE {
13202     type Output = Self;
13203     fn not(self) -> Self {
13204         Self(self.0.not())
13205     }
13206 }
13207 #[cfg(feature = "Win32_Foundation")]
13208 #[inline]
13209 pub unsafe fn SLDepositOfflineConfirmationId<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hslc: *const ::std::ffi::c_void, pproductskuid: *const ::windows::runtime::GUID, pwszinstallationid: Param2, pwszconfirmationid: Param3) -> ::windows::runtime::Result<()> {
13210     #[cfg(windows)]
13211     {
13212         #[link(name = "windows")]
13213         extern "system" {
13214             fn SLDepositOfflineConfirmationId(hslc: *const ::std::ffi::c_void, pproductskuid: *const ::windows::runtime::GUID, pwszinstallationid: super::super::super::Foundation::PWSTR, pwszconfirmationid: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT;
13215         }
13216         SLDepositOfflineConfirmationId(::std::mem::transmute(hslc), ::std::mem::transmute(pproductskuid), pwszinstallationid.into_param().abi(), pwszconfirmationid.into_param().abi()).ok()
13217     }
13218     #[cfg(not(windows))]
13219     unimplemented!("Unsupported target OS");
13220 }
13221 #[cfg(feature = "Win32_Foundation")]
13222 #[inline]
13223 pub unsafe fn SLDepositOfflineConfirmationIdEx<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hslc: *const ::std::ffi::c_void, pproductskuid: *const ::windows::runtime::GUID, pactivationinfo: *const SL_ACTIVATION_INFO_HEADER, pwszinstallationid: Param3, pwszconfirmationid: Param4) -> ::windows::runtime::Result<()> {
13224     #[cfg(windows)]
13225     {
13226         #[link(name = "windows")]
13227         extern "system" {
13228             fn SLDepositOfflineConfirmationIdEx(hslc: *const ::std::ffi::c_void, pproductskuid: *const ::windows::runtime::GUID, pactivationinfo: *const SL_ACTIVATION_INFO_HEADER, pwszinstallationid: super::super::super::Foundation::PWSTR, pwszconfirmationid: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT;
13229         }
13230         SLDepositOfflineConfirmationIdEx(::std::mem::transmute(hslc), ::std::mem::transmute(pproductskuid), ::std::mem::transmute(pactivationinfo), pwszinstallationid.into_param().abi(), pwszconfirmationid.into_param().abi()).ok()
13231     }
13232     #[cfg(not(windows))]
13233     unimplemented!("Unsupported target OS");
13234 }
13235 #[cfg(feature = "Win32_Foundation")]
13236 #[inline]
13237 pub unsafe fn SLFireEvent<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hslc: *const ::std::ffi::c_void, pwszeventid: Param1, papplicationid: *const ::windows::runtime::GUID) -> ::windows::runtime::Result<()> {
13238     #[cfg(windows)]
13239     {
13240         #[link(name = "windows")]
13241         extern "system" {
13242             fn SLFireEvent(hslc: *const ::std::ffi::c_void, pwszeventid: super::super::super::Foundation::PWSTR, papplicationid: *const ::windows::runtime::GUID) -> ::windows::runtime::HRESULT;
13243         }
13244         SLFireEvent(::std::mem::transmute(hslc), pwszeventid.into_param().abi(), ::std::mem::transmute(papplicationid)).ok()
13245     }
13246     #[cfg(not(windows))]
13247     unimplemented!("Unsupported target OS");
13248 }
13249 #[cfg(feature = "Win32_Foundation")]
13250 #[inline]
13251 pub unsafe fn SLGenerateOfflineInstallationId(hslc: *const ::std::ffi::c_void, pproductskuid: *const ::windows::runtime::GUID) -> ::windows::runtime::Result<super::super::super::Foundation::PWSTR> {
13252     #[cfg(windows)]
13253     {
13254         #[link(name = "windows")]
13255         extern "system" {
13256             fn SLGenerateOfflineInstallationId(hslc: *const ::std::ffi::c_void, pproductskuid: *const ::windows::runtime::GUID, ppwszinstallationid: *mut super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT;
13257         }
13258         let mut result__: <super::super::super::Foundation::PWSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
13259         SLGenerateOfflineInstallationId(::std::mem::transmute(hslc), ::std::mem::transmute(pproductskuid), &mut result__).from_abi::<super::super::super::Foundation::PWSTR>(result__)
13260     }
13261     #[cfg(not(windows))]
13262     unimplemented!("Unsupported target OS");
13263 }
13264 #[cfg(feature = "Win32_Foundation")]
13265 #[inline]
13266 pub unsafe fn SLGenerateOfflineInstallationIdEx(hslc: *const ::std::ffi::c_void, pproductskuid: *const ::windows::runtime::GUID, pactivationinfo: *const SL_ACTIVATION_INFO_HEADER) -> ::windows::runtime::Result<super::super::super::Foundation::PWSTR> {
13267     #[cfg(windows)]
13268     {
13269         #[link(name = "windows")]
13270         extern "system" {
13271             fn SLGenerateOfflineInstallationIdEx(hslc: *const ::std::ffi::c_void, pproductskuid: *const ::windows::runtime::GUID, pactivationinfo: *const SL_ACTIVATION_INFO_HEADER, ppwszinstallationid: *mut super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT;
13272         }
13273         let mut result__: <super::super::super::Foundation::PWSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
13274         SLGenerateOfflineInstallationIdEx(::std::mem::transmute(hslc), ::std::mem::transmute(pproductskuid), ::std::mem::transmute(pactivationinfo), &mut result__).from_abi::<super::super::super::Foundation::PWSTR>(result__)
13275     }
13276     #[cfg(not(windows))]
13277     unimplemented!("Unsupported target OS");
13278 }
13279 #[cfg(feature = "Win32_Foundation")]
13280 #[inline]
13281 pub unsafe fn SLGetApplicationInformation<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hslc: *const ::std::ffi::c_void, papplicationid: *const ::windows::runtime::GUID, pwszvaluename: Param2, pedatatype: *mut SLDATATYPE, pcbvalue: *mut u32, ppbvalue: *mut *mut u8) -> ::windows::runtime::Result<()> {
13282     #[cfg(windows)]
13283     {
13284         #[link(name = "windows")]
13285         extern "system" {
13286             fn SLGetApplicationInformation(hslc: *const ::std::ffi::c_void, papplicationid: *const ::windows::runtime::GUID, pwszvaluename: super::super::super::Foundation::PWSTR, pedatatype: *mut SLDATATYPE, pcbvalue: *mut u32, ppbvalue: *mut *mut u8) -> ::windows::runtime::HRESULT;
13287         }
13288         SLGetApplicationInformation(::std::mem::transmute(hslc), ::std::mem::transmute(papplicationid), pwszvaluename.into_param().abi(), ::std::mem::transmute(pedatatype), ::std::mem::transmute(pcbvalue), ::std::mem::transmute(ppbvalue)).ok()
13289     }
13290     #[cfg(not(windows))]
13291     unimplemented!("Unsupported target OS");
13292 }
13293 #[cfg(feature = "Win32_Foundation")]
13294 #[inline]
13295 pub unsafe fn SLGetGenuineInformation<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pqueryid: *const ::windows::runtime::GUID, pwszvaluename: Param1, pedatatype: *mut SLDATATYPE, pcbvalue: *mut u32, ppbvalue: *mut *mut u8) -> ::windows::runtime::Result<()> {
13296     #[cfg(windows)]
13297     {
13298         #[link(name = "windows")]
13299         extern "system" {
13300             fn SLGetGenuineInformation(pqueryid: *const ::windows::runtime::GUID, pwszvaluename: super::super::super::Foundation::PWSTR, pedatatype: *mut SLDATATYPE, pcbvalue: *mut u32, ppbvalue: *mut *mut u8) -> ::windows::runtime::HRESULT;
13301         }
13302         SLGetGenuineInformation(::std::mem::transmute(pqueryid), pwszvaluename.into_param().abi(), ::std::mem::transmute(pedatatype), ::std::mem::transmute(pcbvalue), ::std::mem::transmute(ppbvalue)).ok()
13303     }
13304     #[cfg(not(windows))]
13305     unimplemented!("Unsupported target OS");
13306 }
13307 #[inline]
13308 pub unsafe fn SLGetInstalledProductKeyIds(hslc: *const ::std::ffi::c_void, pproductskuid: *const ::windows::runtime::GUID, pnproductkeyids: *mut u32, ppproductkeyids: *mut *mut ::windows::runtime::GUID) -> ::windows::runtime::Result<()> {
13309     #[cfg(windows)]
13310     {
13311         #[link(name = "windows")]
13312         extern "system" {
13313             fn SLGetInstalledProductKeyIds(hslc: *const ::std::ffi::c_void, pproductskuid: *const ::windows::runtime::GUID, pnproductkeyids: *mut u32, ppproductkeyids: *mut *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT;
13314         }
13315         SLGetInstalledProductKeyIds(::std::mem::transmute(hslc), ::std::mem::transmute(pproductskuid), ::std::mem::transmute(pnproductkeyids), ::std::mem::transmute(ppproductkeyids)).ok()
13316     }
13317     #[cfg(not(windows))]
13318     unimplemented!("Unsupported target OS");
13319 }
13320 #[inline]
13321 pub unsafe fn SLGetLicense(hslc: *const ::std::ffi::c_void, plicensefileid: *const ::windows::runtime::GUID, pcblicensefile: *mut u32, ppblicensefile: *mut *mut u8) -> ::windows::runtime::Result<()> {
13322     #[cfg(windows)]
13323     {
13324         #[link(name = "windows")]
13325         extern "system" {
13326             fn SLGetLicense(hslc: *const ::std::ffi::c_void, plicensefileid: *const ::windows::runtime::GUID, pcblicensefile: *mut u32, ppblicensefile: *mut *mut u8) -> ::windows::runtime::HRESULT;
13327         }
13328         SLGetLicense(::std::mem::transmute(hslc), ::std::mem::transmute(plicensefileid), ::std::mem::transmute(pcblicensefile), ::std::mem::transmute(ppblicensefile)).ok()
13329     }
13330     #[cfg(not(windows))]
13331     unimplemented!("Unsupported target OS");
13332 }
13333 #[inline]
13334 pub unsafe fn SLGetLicenseFileId(hslc: *const ::std::ffi::c_void, cblicenseblob: u32, pblicenseblob: *const u8) -> ::windows::runtime::Result<::windows::runtime::GUID> {
13335     #[cfg(windows)]
13336     {
13337         #[link(name = "windows")]
13338         extern "system" {
13339             fn SLGetLicenseFileId(hslc: *const ::std::ffi::c_void, cblicenseblob: u32, pblicenseblob: *const u8, plicensefileid: *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT;
13340         }
13341         let mut result__: <::windows::runtime::GUID as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
13342         SLGetLicenseFileId(::std::mem::transmute(hslc), ::std::mem::transmute(cblicenseblob), ::std::mem::transmute(pblicenseblob), &mut result__).from_abi::<::windows::runtime::GUID>(result__)
13343     }
13344     #[cfg(not(windows))]
13345     unimplemented!("Unsupported target OS");
13346 }
13347 #[cfg(feature = "Win32_Foundation")]
13348 #[inline]
13349 pub unsafe fn SLGetLicenseInformation<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hslc: *const ::std::ffi::c_void, psllicenseid: *const ::windows::runtime::GUID, pwszvaluename: Param2, pedatatype: *mut SLDATATYPE, pcbvalue: *mut u32, ppbvalue: *mut *mut u8) -> ::windows::runtime::Result<()> {
13350     #[cfg(windows)]
13351     {
13352         #[link(name = "windows")]
13353         extern "system" {
13354             fn SLGetLicenseInformation(hslc: *const ::std::ffi::c_void, psllicenseid: *const ::windows::runtime::GUID, pwszvaluename: super::super::super::Foundation::PWSTR, pedatatype: *mut SLDATATYPE, pcbvalue: *mut u32, ppbvalue: *mut *mut u8) -> ::windows::runtime::HRESULT;
13355         }
13356         SLGetLicenseInformation(::std::mem::transmute(hslc), ::std::mem::transmute(psllicenseid), pwszvaluename.into_param().abi(), ::std::mem::transmute(pedatatype), ::std::mem::transmute(pcbvalue), ::std::mem::transmute(ppbvalue)).ok()
13357     }
13358     #[cfg(not(windows))]
13359     unimplemented!("Unsupported target OS");
13360 }
13361 #[cfg(feature = "Win32_Foundation")]
13362 #[inline]
13363 pub unsafe fn SLGetLicensingStatusInformation<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hslc: *const ::std::ffi::c_void, pappid: *const ::windows::runtime::GUID, pproductskuid: *const ::windows::runtime::GUID, pwszrightname: Param3, pnstatuscount: *mut u32, pplicensingstatus: *mut *mut SL_LICENSING_STATUS) -> ::windows::runtime::Result<()> {
13364     #[cfg(windows)]
13365     {
13366         #[link(name = "windows")]
13367         extern "system" {
13368             fn SLGetLicensingStatusInformation(hslc: *const ::std::ffi::c_void, pappid: *const ::windows::runtime::GUID, pproductskuid: *const ::windows::runtime::GUID, pwszrightname: super::super::super::Foundation::PWSTR, pnstatuscount: *mut u32, pplicensingstatus: *mut *mut SL_LICENSING_STATUS) -> ::windows::runtime::HRESULT;
13369         }
13370         SLGetLicensingStatusInformation(::std::mem::transmute(hslc), ::std::mem::transmute(pappid), ::std::mem::transmute(pproductskuid), pwszrightname.into_param().abi(), ::std::mem::transmute(pnstatuscount), ::std::mem::transmute(pplicensingstatus)).ok()
13371     }
13372     #[cfg(not(windows))]
13373     unimplemented!("Unsupported target OS");
13374 }
13375 #[cfg(feature = "Win32_Foundation")]
13376 #[inline]
13377 pub unsafe fn SLGetPKeyId<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hslc: *const ::std::ffi::c_void, pwszpkeyalgorithm: Param1, pwszpkeystring: Param2, cbpkeyspecificdata: u32, pbpkeyspecificdata: *const u8) -> ::windows::runtime::Result<::windows::runtime::GUID> {
13378     #[cfg(windows)]
13379     {
13380         #[link(name = "windows")]
13381         extern "system" {
13382             fn SLGetPKeyId(hslc: *const ::std::ffi::c_void, pwszpkeyalgorithm: super::super::super::Foundation::PWSTR, pwszpkeystring: super::super::super::Foundation::PWSTR, cbpkeyspecificdata: u32, pbpkeyspecificdata: *const u8, ppkeyid: *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT;
13383         }
13384         let mut result__: <::windows::runtime::GUID as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
13385         SLGetPKeyId(::std::mem::transmute(hslc), pwszpkeyalgorithm.into_param().abi(), pwszpkeystring.into_param().abi(), ::std::mem::transmute(cbpkeyspecificdata), ::std::mem::transmute(pbpkeyspecificdata), &mut result__).from_abi::<::windows::runtime::GUID>(result__)
13386     }
13387     #[cfg(not(windows))]
13388     unimplemented!("Unsupported target OS");
13389 }
13390 #[cfg(feature = "Win32_Foundation")]
13391 #[inline]
13392 pub unsafe fn SLGetPKeyInformation<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hslc: *const ::std::ffi::c_void, ppkeyid: *const ::windows::runtime::GUID, pwszvaluename: Param2, pedatatype: *mut SLDATATYPE, pcbvalue: *mut u32, ppbvalue: *mut *mut u8) -> ::windows::runtime::Result<()> {
13393     #[cfg(windows)]
13394     {
13395         #[link(name = "windows")]
13396         extern "system" {
13397             fn SLGetPKeyInformation(hslc: *const ::std::ffi::c_void, ppkeyid: *const ::windows::runtime::GUID, pwszvaluename: super::super::super::Foundation::PWSTR, pedatatype: *mut SLDATATYPE, pcbvalue: *mut u32, ppbvalue: *mut *mut u8) -> ::windows::runtime::HRESULT;
13398         }
13399         SLGetPKeyInformation(::std::mem::transmute(hslc), ::std::mem::transmute(ppkeyid), pwszvaluename.into_param().abi(), ::std::mem::transmute(pedatatype), ::std::mem::transmute(pcbvalue), ::std::mem::transmute(ppbvalue)).ok()
13400     }
13401     #[cfg(not(windows))]
13402     unimplemented!("Unsupported target OS");
13403 }
13404 #[cfg(feature = "Win32_Foundation")]
13405 #[inline]
13406 pub unsafe fn SLGetPolicyInformation<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hslc: *const ::std::ffi::c_void, pwszvaluename: Param1, pedatatype: *mut SLDATATYPE, pcbvalue: *mut u32, ppbvalue: *mut *mut u8) -> ::windows::runtime::Result<()> {
13407     #[cfg(windows)]
13408     {
13409         #[link(name = "windows")]
13410         extern "system" {
13411             fn SLGetPolicyInformation(hslc: *const ::std::ffi::c_void, pwszvaluename: super::super::super::Foundation::PWSTR, pedatatype: *mut SLDATATYPE, pcbvalue: *mut u32, ppbvalue: *mut *mut u8) -> ::windows::runtime::HRESULT;
13412         }
13413         SLGetPolicyInformation(::std::mem::transmute(hslc), pwszvaluename.into_param().abi(), ::std::mem::transmute(pedatatype), ::std::mem::transmute(pcbvalue), ::std::mem::transmute(ppbvalue)).ok()
13414     }
13415     #[cfg(not(windows))]
13416     unimplemented!("Unsupported target OS");
13417 }
13418 #[cfg(feature = "Win32_Foundation")]
13419 #[inline]
13420 pub unsafe fn SLGetPolicyInformationDWORD<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hslc: *const ::std::ffi::c_void, pwszvaluename: Param1) -> ::windows::runtime::Result<u32> {
13421     #[cfg(windows)]
13422     {
13423         #[link(name = "windows")]
13424         extern "system" {
13425             fn SLGetPolicyInformationDWORD(hslc: *const ::std::ffi::c_void, pwszvaluename: super::super::super::Foundation::PWSTR, pdwvalue: *mut u32) -> ::windows::runtime::HRESULT;
13426         }
13427         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
13428         SLGetPolicyInformationDWORD(::std::mem::transmute(hslc), pwszvaluename.into_param().abi(), &mut result__).from_abi::<u32>(result__)
13429     }
13430     #[cfg(not(windows))]
13431     unimplemented!("Unsupported target OS");
13432 }
13433 #[cfg(feature = "Win32_Foundation")]
13434 #[inline]
13435 pub unsafe fn SLGetProductSkuInformation<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hslc: *const ::std::ffi::c_void, pproductskuid: *const ::windows::runtime::GUID, pwszvaluename: Param2, pedatatype: *mut SLDATATYPE, pcbvalue: *mut u32, ppbvalue: *mut *mut u8) -> ::windows::runtime::Result<()> {
13436     #[cfg(windows)]
13437     {
13438         #[link(name = "windows")]
13439         extern "system" {
13440             fn SLGetProductSkuInformation(hslc: *const ::std::ffi::c_void, pproductskuid: *const ::windows::runtime::GUID, pwszvaluename: super::super::super::Foundation::PWSTR, pedatatype: *mut SLDATATYPE, pcbvalue: *mut u32, ppbvalue: *mut *mut u8) -> ::windows::runtime::HRESULT;
13441         }
13442         SLGetProductSkuInformation(::std::mem::transmute(hslc), ::std::mem::transmute(pproductskuid), pwszvaluename.into_param().abi(), ::std::mem::transmute(pedatatype), ::std::mem::transmute(pcbvalue), ::std::mem::transmute(ppbvalue)).ok()
13443     }
13444     #[cfg(not(windows))]
13445     unimplemented!("Unsupported target OS");
13446 }
13447 #[cfg(feature = "Win32_Foundation")]
13448 #[inline]
13449 pub unsafe fn SLGetReferralInformation<'a, Param3: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hslc: *const ::std::ffi::c_void, ereferraltype: SLREFERRALTYPE, pskuorappid: *const ::windows::runtime::GUID, pwszvaluename: Param3) -> ::windows::runtime::Result<super::super::super::Foundation::PWSTR> {
13450     #[cfg(windows)]
13451     {
13452         #[link(name = "windows")]
13453         extern "system" {
13454             fn SLGetReferralInformation(hslc: *const ::std::ffi::c_void, ereferraltype: SLREFERRALTYPE, pskuorappid: *const ::windows::runtime::GUID, pwszvaluename: super::super::super::Foundation::PWSTR, ppwszvalue: *mut super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT;
13455         }
13456         let mut result__: <super::super::super::Foundation::PWSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
13457         SLGetReferralInformation(::std::mem::transmute(hslc), ::std::mem::transmute(ereferraltype), ::std::mem::transmute(pskuorappid), pwszvaluename.into_param().abi(), &mut result__).from_abi::<super::super::super::Foundation::PWSTR>(result__)
13458     }
13459     #[cfg(not(windows))]
13460     unimplemented!("Unsupported target OS");
13461 }
13462 #[inline]
13463 pub unsafe fn SLGetSLIDList(hslc: *const ::std::ffi::c_void, equeryidtype: SLIDTYPE, pqueryid: *const ::windows::runtime::GUID, ereturnidtype: SLIDTYPE, pnreturnids: *mut u32, ppreturnids: *mut *mut ::windows::runtime::GUID) -> ::windows::runtime::Result<()> {
13464     #[cfg(windows)]
13465     {
13466         #[link(name = "windows")]
13467         extern "system" {
13468             fn SLGetSLIDList(hslc: *const ::std::ffi::c_void, equeryidtype: SLIDTYPE, pqueryid: *const ::windows::runtime::GUID, ereturnidtype: SLIDTYPE, pnreturnids: *mut u32, ppreturnids: *mut *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT;
13469         }
13470         SLGetSLIDList(::std::mem::transmute(hslc), ::std::mem::transmute(equeryidtype), ::std::mem::transmute(pqueryid), ::std::mem::transmute(ereturnidtype), ::std::mem::transmute(pnreturnids), ::std::mem::transmute(ppreturnids)).ok()
13471     }
13472     #[cfg(not(windows))]
13473     unimplemented!("Unsupported target OS");
13474 }
13475 #[cfg(feature = "Win32_Foundation")]
13476 #[inline]
13477 pub unsafe fn SLGetServerStatus<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pwszserverurl: Param0, pwszacquisitiontype: Param1, pwszproxyserver: Param2, wproxyport: u16) -> ::windows::runtime::Result<::windows::runtime::HRESULT> {
13478     #[cfg(windows)]
13479     {
13480         #[link(name = "windows")]
13481         extern "system" {
13482             fn SLGetServerStatus(pwszserverurl: super::super::super::Foundation::PWSTR, pwszacquisitiontype: super::super::super::Foundation::PWSTR, pwszproxyserver: super::super::super::Foundation::PWSTR, wproxyport: u16, phrstatus: *mut ::windows::runtime::HRESULT) -> ::windows::runtime::HRESULT;
13483         }
13484         let mut result__: <::windows::runtime::HRESULT as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
13485         SLGetServerStatus(pwszserverurl.into_param().abi(), pwszacquisitiontype.into_param().abi(), pwszproxyserver.into_param().abi(), ::std::mem::transmute(wproxyport), &mut result__).from_abi::<::windows::runtime::HRESULT>(result__)
13486     }
13487     #[cfg(not(windows))]
13488     unimplemented!("Unsupported target OS");
13489 }
13490 #[cfg(feature = "Win32_Foundation")]
13491 #[inline]
13492 pub unsafe fn SLGetServiceInformation<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hslc: *const ::std::ffi::c_void, pwszvaluename: Param1, pedatatype: *mut SLDATATYPE, pcbvalue: *mut u32, ppbvalue: *mut *mut u8) -> ::windows::runtime::Result<()> {
13493     #[cfg(windows)]
13494     {
13495         #[link(name = "windows")]
13496         extern "system" {
13497             fn SLGetServiceInformation(hslc: *const ::std::ffi::c_void, pwszvaluename: super::super::super::Foundation::PWSTR, pedatatype: *mut SLDATATYPE, pcbvalue: *mut u32, ppbvalue: *mut *mut u8) -> ::windows::runtime::HRESULT;
13498         }
13499         SLGetServiceInformation(::std::mem::transmute(hslc), pwszvaluename.into_param().abi(), ::std::mem::transmute(pedatatype), ::std::mem::transmute(pcbvalue), ::std::mem::transmute(ppbvalue)).ok()
13500     }
13501     #[cfg(not(windows))]
13502     unimplemented!("Unsupported target OS");
13503 }
13504 #[cfg(feature = "Win32_Foundation")]
13505 #[inline]
13506 pub unsafe fn SLGetWindowsInformation<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pwszvaluename: Param0, pedatatype: *mut SLDATATYPE, pcbvalue: *mut u32, ppbvalue: *mut *mut u8) -> ::windows::runtime::Result<()> {
13507     #[cfg(windows)]
13508     {
13509         #[link(name = "windows")]
13510         extern "system" {
13511             fn SLGetWindowsInformation(pwszvaluename: super::super::super::Foundation::PWSTR, pedatatype: *mut SLDATATYPE, pcbvalue: *mut u32, ppbvalue: *mut *mut u8) -> ::windows::runtime::HRESULT;
13512         }
13513         SLGetWindowsInformation(pwszvaluename.into_param().abi(), ::std::mem::transmute(pedatatype), ::std::mem::transmute(pcbvalue), ::std::mem::transmute(ppbvalue)).ok()
13514     }
13515     #[cfg(not(windows))]
13516     unimplemented!("Unsupported target OS");
13517 }
13518 #[cfg(feature = "Win32_Foundation")]
13519 #[inline]
13520 pub unsafe fn SLGetWindowsInformationDWORD<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pwszvaluename: Param0) -> ::windows::runtime::Result<u32> {
13521     #[cfg(windows)]
13522     {
13523         #[link(name = "windows")]
13524         extern "system" {
13525             fn SLGetWindowsInformationDWORD(pwszvaluename: super::super::super::Foundation::PWSTR, pdwvalue: *mut u32) -> ::windows::runtime::HRESULT;
13526         }
13527         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
13528         SLGetWindowsInformationDWORD(pwszvaluename.into_param().abi(), &mut result__).from_abi::<u32>(result__)
13529     }
13530     #[cfg(not(windows))]
13531     unimplemented!("Unsupported target OS");
13532 }
13533 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
13534 #[repr(transparent)]
13535 pub struct SLIDTYPE(pub i32);
13536 pub const SL_ID_APPLICATION: SLIDTYPE = SLIDTYPE(0i32);
13537 pub const SL_ID_PRODUCT_SKU: SLIDTYPE = SLIDTYPE(1i32);
13538 pub const SL_ID_LICENSE_FILE: SLIDTYPE = SLIDTYPE(2i32);
13539 pub const SL_ID_LICENSE: SLIDTYPE = SLIDTYPE(3i32);
13540 pub const SL_ID_PKEY: SLIDTYPE = SLIDTYPE(4i32);
13541 pub const SL_ID_ALL_LICENSES: SLIDTYPE = SLIDTYPE(5i32);
13542 pub const SL_ID_ALL_LICENSE_FILES: SLIDTYPE = SLIDTYPE(6i32);
13543 pub const SL_ID_STORE_TOKEN: SLIDTYPE = SLIDTYPE(7i32);
13544 pub const SL_ID_LAST: SLIDTYPE = SLIDTYPE(8i32);
13545 impl ::std::convert::From<i32> for SLIDTYPE {
13546     fn from(value: i32) -> Self {
13547         Self(value)
13548     }
13549 }
13550 unsafe impl ::windows::runtime::Abi for SLIDTYPE {
13551     type Abi = Self;
13552     type DefaultType = Self;
13553 }
13554 #[inline]
13555 pub unsafe fn SLInstallLicense(hslc: *const ::std::ffi::c_void, cblicenseblob: u32, pblicenseblob: *const u8) -> ::windows::runtime::Result<::windows::runtime::GUID> {
13556     #[cfg(windows)]
13557     {
13558         #[link(name = "windows")]
13559         extern "system" {
13560             fn SLInstallLicense(hslc: *const ::std::ffi::c_void, cblicenseblob: u32, pblicenseblob: *const u8, plicensefileid: *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT;
13561         }
13562         let mut result__: <::windows::runtime::GUID as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
13563         SLInstallLicense(::std::mem::transmute(hslc), ::std::mem::transmute(cblicenseblob), ::std::mem::transmute(pblicenseblob), &mut result__).from_abi::<::windows::runtime::GUID>(result__)
13564     }
13565     #[cfg(not(windows))]
13566     unimplemented!("Unsupported target OS");
13567 }
13568 #[cfg(feature = "Win32_Foundation")]
13569 #[inline]
13570 pub unsafe fn SLInstallProofOfPurchase<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hslc: *const ::std::ffi::c_void, pwszpkeyalgorithm: Param1, pwszpkeystring: Param2, cbpkeyspecificdata: u32, pbpkeyspecificdata: *const u8) -> ::windows::runtime::Result<::windows::runtime::GUID> {
13571     #[cfg(windows)]
13572     {
13573         #[link(name = "windows")]
13574         extern "system" {
13575             fn SLInstallProofOfPurchase(hslc: *const ::std::ffi::c_void, pwszpkeyalgorithm: super::super::super::Foundation::PWSTR, pwszpkeystring: super::super::super::Foundation::PWSTR, cbpkeyspecificdata: u32, pbpkeyspecificdata: *const u8, ppkeyid: *mut ::windows::runtime::GUID) -> ::windows::runtime::HRESULT;
13576         }
13577         let mut result__: <::windows::runtime::GUID as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
13578         SLInstallProofOfPurchase(::std::mem::transmute(hslc), pwszpkeyalgorithm.into_param().abi(), pwszpkeystring.into_param().abi(), ::std::mem::transmute(cbpkeyspecificdata), ::std::mem::transmute(pbpkeyspecificdata), &mut result__).from_abi::<::windows::runtime::GUID>(result__)
13579     }
13580     #[cfg(not(windows))]
13581     unimplemented!("Unsupported target OS");
13582 }
13583 #[inline]
13584 pub unsafe fn SLIsGenuineLocal(pappid: *const ::windows::runtime::GUID, pgenuinestate: *mut SL_GENUINE_STATE, puioptions: *mut SL_NONGENUINE_UI_OPTIONS) -> ::windows::runtime::Result<()> {
13585     #[cfg(windows)]
13586     {
13587         #[link(name = "windows")]
13588         extern "system" {
13589             fn SLIsGenuineLocal(pappid: *const ::windows::runtime::GUID, pgenuinestate: *mut SL_GENUINE_STATE, puioptions: *mut SL_NONGENUINE_UI_OPTIONS) -> ::windows::runtime::HRESULT;
13590         }
13591         SLIsGenuineLocal(::std::mem::transmute(pappid), ::std::mem::transmute(pgenuinestate), ::std::mem::transmute(puioptions)).ok()
13592     }
13593     #[cfg(not(windows))]
13594     unimplemented!("Unsupported target OS");
13595 }
13596 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
13597 #[repr(transparent)]
13598 pub struct SLLICENSINGSTATUS(pub i32);
13599 pub const SL_LICENSING_STATUS_UNLICENSED: SLLICENSINGSTATUS = SLLICENSINGSTATUS(0i32);
13600 pub const SL_LICENSING_STATUS_LICENSED: SLLICENSINGSTATUS = SLLICENSINGSTATUS(1i32);
13601 pub const SL_LICENSING_STATUS_IN_GRACE_PERIOD: SLLICENSINGSTATUS = SLLICENSINGSTATUS(2i32);
13602 pub const SL_LICENSING_STATUS_NOTIFICATION: SLLICENSINGSTATUS = SLLICENSINGSTATUS(3i32);
13603 pub const SL_LICENSING_STATUS_LAST: SLLICENSINGSTATUS = SLLICENSINGSTATUS(4i32);
13604 impl ::std::convert::From<i32> for SLLICENSINGSTATUS {
13605     fn from(value: i32) -> Self {
13606         Self(value)
13607     }
13608 }
13609 unsafe impl ::windows::runtime::Abi for SLLICENSINGSTATUS {
13610     type Abi = Self;
13611     type DefaultType = Self;
13612 }
13613 #[inline]
13614 pub unsafe fn SLOpen(phslc: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
13615     #[cfg(windows)]
13616     {
13617         #[link(name = "windows")]
13618         extern "system" {
13619             fn SLOpen(phslc: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
13620         }
13621         SLOpen(::std::mem::transmute(phslc)).ok()
13622     }
13623     #[cfg(not(windows))]
13624     unimplemented!("Unsupported target OS");
13625 }
13626 #[cfg(feature = "Win32_Foundation")]
13627 #[inline]
13628 pub unsafe fn SLQueryLicenseValueFromApp<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(valuename: Param0, valuetype: *mut u32, databuffer: *mut ::std::ffi::c_void, datasize: u32, resultdatasize: *mut u32) -> ::windows::runtime::Result<()> {
13629     #[cfg(windows)]
13630     {
13631         #[link(name = "windows")]
13632         extern "system" {
13633             fn SLQueryLicenseValueFromApp(valuename: super::super::super::Foundation::PWSTR, valuetype: *mut u32, databuffer: *mut ::std::ffi::c_void, datasize: u32, resultdatasize: *mut u32) -> ::windows::runtime::HRESULT;
13634         }
13635         SLQueryLicenseValueFromApp(valuename.into_param().abi(), ::std::mem::transmute(valuetype), ::std::mem::transmute(databuffer), ::std::mem::transmute(datasize), ::std::mem::transmute(resultdatasize)).ok()
13636     }
13637     #[cfg(not(windows))]
13638     unimplemented!("Unsupported target OS");
13639 }
13640 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
13641 #[repr(transparent)]
13642 pub struct SLREFERRALTYPE(pub i32);
13643 pub const SL_REFERRALTYPE_SKUID: SLREFERRALTYPE = SLREFERRALTYPE(0i32);
13644 pub const SL_REFERRALTYPE_APPID: SLREFERRALTYPE = SLREFERRALTYPE(1i32);
13645 pub const SL_REFERRALTYPE_OVERRIDE_SKUID: SLREFERRALTYPE = SLREFERRALTYPE(2i32);
13646 pub const SL_REFERRALTYPE_OVERRIDE_APPID: SLREFERRALTYPE = SLREFERRALTYPE(3i32);
13647 pub const SL_REFERRALTYPE_BEST_MATCH: SLREFERRALTYPE = SLREFERRALTYPE(4i32);
13648 impl ::std::convert::From<i32> for SLREFERRALTYPE {
13649     fn from(value: i32) -> Self {
13650         Self(value)
13651     }
13652 }
13653 unsafe impl ::windows::runtime::Abi for SLREFERRALTYPE {
13654     type Abi = Self;
13655     type DefaultType = Self;
13656 }
13657 #[cfg(feature = "Win32_Foundation")]
13658 #[inline]
13659 pub unsafe fn SLRegisterEvent<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hslc: *const ::std::ffi::c_void, pwszeventid: Param1, papplicationid: *const ::windows::runtime::GUID, hevent: Param3) -> ::windows::runtime::Result<()> {
13660     #[cfg(windows)]
13661     {
13662         #[link(name = "windows")]
13663         extern "system" {
13664             fn SLRegisterEvent(hslc: *const ::std::ffi::c_void, pwszeventid: super::super::super::Foundation::PWSTR, papplicationid: *const ::windows::runtime::GUID, hevent: super::super::super::Foundation::HANDLE) -> ::windows::runtime::HRESULT;
13665         }
13666         SLRegisterEvent(::std::mem::transmute(hslc), pwszeventid.into_param().abi(), ::std::mem::transmute(papplicationid), hevent.into_param().abi()).ok()
13667     }
13668     #[cfg(not(windows))]
13669     unimplemented!("Unsupported target OS");
13670 }
13671 #[inline]
13672 pub unsafe fn SLSetCurrentProductKey(hslc: *const ::std::ffi::c_void, pproductskuid: *const ::windows::runtime::GUID, pproductkeyid: *const ::windows::runtime::GUID) -> ::windows::runtime::Result<()> {
13673     #[cfg(windows)]
13674     {
13675         #[link(name = "windows")]
13676         extern "system" {
13677             fn SLSetCurrentProductKey(hslc: *const ::std::ffi::c_void, pproductskuid: *const ::windows::runtime::GUID, pproductkeyid: *const ::windows::runtime::GUID) -> ::windows::runtime::HRESULT;
13678         }
13679         SLSetCurrentProductKey(::std::mem::transmute(hslc), ::std::mem::transmute(pproductskuid), ::std::mem::transmute(pproductkeyid)).ok()
13680     }
13681     #[cfg(not(windows))]
13682     unimplemented!("Unsupported target OS");
13683 }
13684 #[cfg(feature = "Win32_Foundation")]
13685 #[inline]
13686 pub unsafe fn SLSetGenuineInformation<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pqueryid: *const ::windows::runtime::GUID, pwszvaluename: Param1, edatatype: SLDATATYPE, cbvalue: u32, pbvalue: *const u8) -> ::windows::runtime::Result<()> {
13687     #[cfg(windows)]
13688     {
13689         #[link(name = "windows")]
13690         extern "system" {
13691             fn SLSetGenuineInformation(pqueryid: *const ::windows::runtime::GUID, pwszvaluename: super::super::super::Foundation::PWSTR, edatatype: SLDATATYPE, cbvalue: u32, pbvalue: *const u8) -> ::windows::runtime::HRESULT;
13692         }
13693         SLSetGenuineInformation(::std::mem::transmute(pqueryid), pwszvaluename.into_param().abi(), ::std::mem::transmute(edatatype), ::std::mem::transmute(cbvalue), ::std::mem::transmute(pbvalue)).ok()
13694     }
13695     #[cfg(not(windows))]
13696     unimplemented!("Unsupported target OS");
13697 }
13698 #[inline]
13699 pub unsafe fn SLUninstallLicense(hslc: *const ::std::ffi::c_void, plicensefileid: *const ::windows::runtime::GUID) -> ::windows::runtime::Result<()> {
13700     #[cfg(windows)]
13701     {
13702         #[link(name = "windows")]
13703         extern "system" {
13704             fn SLUninstallLicense(hslc: *const ::std::ffi::c_void, plicensefileid: *const ::windows::runtime::GUID) -> ::windows::runtime::HRESULT;
13705         }
13706         SLUninstallLicense(::std::mem::transmute(hslc), ::std::mem::transmute(plicensefileid)).ok()
13707     }
13708     #[cfg(not(windows))]
13709     unimplemented!("Unsupported target OS");
13710 }
13711 #[inline]
13712 pub unsafe fn SLUninstallProofOfPurchase(hslc: *const ::std::ffi::c_void, ppkeyid: *const ::windows::runtime::GUID) -> ::windows::runtime::Result<()> {
13713     #[cfg(windows)]
13714     {
13715         #[link(name = "windows")]
13716         extern "system" {
13717             fn SLUninstallProofOfPurchase(hslc: *const ::std::ffi::c_void, ppkeyid: *const ::windows::runtime::GUID) -> ::windows::runtime::HRESULT;
13718         }
13719         SLUninstallProofOfPurchase(::std::mem::transmute(hslc), ::std::mem::transmute(ppkeyid)).ok()
13720     }
13721     #[cfg(not(windows))]
13722     unimplemented!("Unsupported target OS");
13723 }
13724 #[cfg(feature = "Win32_Foundation")]
13725 #[inline]
13726 pub unsafe fn SLUnregisterEvent<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hslc: *const ::std::ffi::c_void, pwszeventid: Param1, papplicationid: *const ::windows::runtime::GUID, hevent: Param3) -> ::windows::runtime::Result<()> {
13727     #[cfg(windows)]
13728     {
13729         #[link(name = "windows")]
13730         extern "system" {
13731             fn SLUnregisterEvent(hslc: *const ::std::ffi::c_void, pwszeventid: super::super::super::Foundation::PWSTR, papplicationid: *const ::windows::runtime::GUID, hevent: super::super::super::Foundation::HANDLE) -> ::windows::runtime::HRESULT;
13732         }
13733         SLUnregisterEvent(::std::mem::transmute(hslc), pwszeventid.into_param().abi(), ::std::mem::transmute(papplicationid), hevent.into_param().abi()).ok()
13734     }
13735     #[cfg(not(windows))]
13736     unimplemented!("Unsupported target OS");
13737 }
13738 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13739 #[repr(C)]
13740 pub struct SL_ACTIVATION_INFO_HEADER {
13741     pub cbSize: u32,
13742     pub r#type: SL_ACTIVATION_TYPE,
13743 }
13744 impl SL_ACTIVATION_INFO_HEADER {}
13745 impl ::std::default::Default for SL_ACTIVATION_INFO_HEADER {
13746     fn default() -> Self {
13747         unsafe { ::std::mem::zeroed() }
13748     }
13749 }
13750 impl ::std::fmt::Debug for SL_ACTIVATION_INFO_HEADER {
13751     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13752         fmt.debug_struct("SL_ACTIVATION_INFO_HEADER").field("cbSize", &self.cbSize).field("r#type", &self.r#type).finish()
13753     }
13754 }
13755 impl ::std::cmp::PartialEq for SL_ACTIVATION_INFO_HEADER {
13756     fn eq(&self, other: &Self) -> bool {
13757         self.cbSize == other.cbSize && self.r#type == other.r#type
13758     }
13759 }
13760 impl ::std::cmp::Eq for SL_ACTIVATION_INFO_HEADER {}
13761 unsafe impl ::windows::runtime::Abi for SL_ACTIVATION_INFO_HEADER {
13762     type Abi = Self;
13763     type DefaultType = Self;
13764 }
13765 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
13766 #[repr(transparent)]
13767 pub struct SL_ACTIVATION_TYPE(pub i32);
13768 pub const SL_ACTIVATION_TYPE_DEFAULT: SL_ACTIVATION_TYPE = SL_ACTIVATION_TYPE(0i32);
13769 pub const SL_ACTIVATION_TYPE_ACTIVE_DIRECTORY: SL_ACTIVATION_TYPE = SL_ACTIVATION_TYPE(1i32);
13770 impl ::std::convert::From<i32> for SL_ACTIVATION_TYPE {
13771     fn from(value: i32) -> Self {
13772         Self(value)
13773     }
13774 }
13775 unsafe impl ::windows::runtime::Abi for SL_ACTIVATION_TYPE {
13776     type Abi = Self;
13777     type DefaultType = Self;
13778 }
13779 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13780 #[repr(C)]
13781 #[cfg(feature = "Win32_Foundation")]
13782 pub struct SL_AD_ACTIVATION_INFO {
13783     pub header: SL_ACTIVATION_INFO_HEADER,
13784     pub pwszProductKey: super::super::super::Foundation::PWSTR,
13785     pub pwszActivationObjectName: super::super::super::Foundation::PWSTR,
13786 }
13787 #[cfg(feature = "Win32_Foundation")]
13788 impl SL_AD_ACTIVATION_INFO {}
13789 #[cfg(feature = "Win32_Foundation")]
13790 impl ::std::default::Default for SL_AD_ACTIVATION_INFO {
13791     fn default() -> Self {
13792         unsafe { ::std::mem::zeroed() }
13793     }
13794 }
13795 #[cfg(feature = "Win32_Foundation")]
13796 impl ::std::fmt::Debug for SL_AD_ACTIVATION_INFO {
13797     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13798         fmt.debug_struct("SL_AD_ACTIVATION_INFO").field("header", &self.header).field("pwszProductKey", &self.pwszProductKey).field("pwszActivationObjectName", &self.pwszActivationObjectName).finish()
13799     }
13800 }
13801 #[cfg(feature = "Win32_Foundation")]
13802 impl ::std::cmp::PartialEq for SL_AD_ACTIVATION_INFO {
13803     fn eq(&self, other: &Self) -> bool {
13804         self.header == other.header && self.pwszProductKey == other.pwszProductKey && self.pwszActivationObjectName == other.pwszActivationObjectName
13805     }
13806 }
13807 #[cfg(feature = "Win32_Foundation")]
13808 impl ::std::cmp::Eq for SL_AD_ACTIVATION_INFO {}
13809 #[cfg(feature = "Win32_Foundation")]
13810 unsafe impl ::windows::runtime::Abi for SL_AD_ACTIVATION_INFO {
13811     type Abi = Self;
13812     type DefaultType = Self;
13813 }
13814 pub const SL_CLIENTAPI_ZONE: u32 = 61440u32;
13815 pub const SL_E_ACTIVATION_IN_PROGRESS: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422296i32 as _);
13816 pub const SL_E_APPLICATION_POLICIES_MISSING: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418126i32 as _);
13817 pub const SL_E_APPLICATION_POLICIES_NOT_LOADED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418125i32 as _);
13818 pub const SL_E_AUTHN_CANT_VERIFY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418118i32 as _);
13819 pub const SL_E_AUTHN_CHALLENGE_NOT_SET: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418119i32 as _);
13820 pub const SL_E_AUTHN_MISMATCHED_KEY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418120i32 as _);
13821 pub const SL_E_AUTHN_WRONG_VERSION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418121i32 as _);
13822 pub const SL_E_BASE_SKU_NOT_AVAILABLE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418155i32 as _);
13823 pub const SL_E_BIOS_KEY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417707i32 as _);
13824 pub const SL_E_BLOCKED_PRODUCT_KEY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418159i32 as _);
13825 pub const SL_E_CHPA_ACTCONFIG_ID_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430519i32 as _);
13826 pub const SL_E_CHPA_BINDING_MAPPING_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430522i32 as _);
13827 pub const SL_E_CHPA_BINDING_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430523i32 as _);
13828 pub const SL_E_CHPA_BUSINESS_RULE_INPUT_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073428736i32 as _);
13829 pub const SL_E_CHPA_DATABASE_ERROR: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430509i32 as _);
13830 pub const SL_E_CHPA_DIGITALMARKER_BINDING_NOT_CONFIGURED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430446i32 as _);
13831 pub const SL_E_CHPA_DIGITALMARKER_INVALID_BINDING: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430447i32 as _);
13832 pub const SL_E_CHPA_DMAK_EXTENSION_LIMIT_EXCEEDED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430495i32 as _);
13833 pub const SL_E_CHPA_DMAK_LIMIT_EXCEEDED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430496i32 as _);
13834 pub const SL_E_CHPA_DYNAMICALLY_BLOCKED_PRODUCT_KEY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430432i32 as _);
13835 pub const SL_E_CHPA_FAILED_TO_DELETE_PRODUCTKEY_BINDING: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073428649i32 as _);
13836 pub const SL_E_CHPA_FAILED_TO_DELETE_PRODUCT_KEY_PROPERTY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073428644i32 as _);
13837 pub const SL_E_CHPA_FAILED_TO_INSERT_PRODUCTKEY_BINDING: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073428650i32 as _);
13838 pub const SL_E_CHPA_FAILED_TO_INSERT_PRODUCT_KEY_PROPERTY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073428646i32 as _);
13839 pub const SL_E_CHPA_FAILED_TO_INSERT_PRODUCT_KEY_RECORD: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073428608i32 as _);
13840 pub const SL_E_CHPA_FAILED_TO_PROCESS_PRODUCT_KEY_BINDINGS_XML: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073428648i32 as _);
13841 pub const SL_E_CHPA_FAILED_TO_UPDATE_PRODUCTKEY_BINDING: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073428651i32 as _);
13842 pub const SL_E_CHPA_FAILED_TO_UPDATE_PRODUCT_KEY_PROPERTY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073428645i32 as _);
13843 pub const SL_E_CHPA_FAILED_TO_UPDATE_PRODUCT_KEY_RECORD: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073428607i32 as _);
13844 pub const SL_E_CHPA_GENERAL_ERROR: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430448i32 as _);
13845 pub const SL_E_CHPA_INVALID_ACTCONFIG_ID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430515i32 as _);
13846 pub const SL_E_CHPA_INVALID_ARGUMENT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430508i32 as _);
13847 pub const SL_E_CHPA_INVALID_BINDING: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430526i32 as _);
13848 pub const SL_E_CHPA_INVALID_BINDING_URI: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430511i32 as _);
13849 pub const SL_E_CHPA_INVALID_PRODUCT_DATA: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430517i32 as _);
13850 pub const SL_E_CHPA_INVALID_PRODUCT_DATA_ID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430518i32 as _);
13851 pub const SL_E_CHPA_INVALID_PRODUCT_KEY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430524i32 as _);
13852 pub const SL_E_CHPA_INVALID_PRODUCT_KEY_CHAR: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430512i32 as _);
13853 pub const SL_E_CHPA_INVALID_PRODUCT_KEY_FORMAT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430513i32 as _);
13854 pub const SL_E_CHPA_INVALID_PRODUCT_KEY_LENGTH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430514i32 as _);
13855 pub const SL_E_CHPA_MAXIMUM_UNLOCK_EXCEEDED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430520i32 as _);
13856 pub const SL_E_CHPA_MSCH_RESPONSE_NOT_AVAILABLE_VGA: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429505i32 as _);
13857 pub const SL_E_CHPA_NETWORK_ERROR: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430510i32 as _);
13858 pub const SL_E_CHPA_NO_RULES_TO_ACTIVATE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430449i32 as _);
13859 pub const SL_E_CHPA_NULL_VALUE_FOR_PROPERTY_NAME_OR_ID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073428656i32 as _);
13860 pub const SL_E_CHPA_OEM_SLP_COA0: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430506i32 as _);
13861 pub const SL_E_CHPA_OVERRIDE_REQUEST_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430493i32 as _);
13862 pub const SL_E_CHPA_PRODUCT_KEY_BEING_USED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073428624i32 as _);
13863 pub const SL_E_CHPA_PRODUCT_KEY_BLOCKED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430525i32 as _);
13864 pub const SL_E_CHPA_PRODUCT_KEY_BLOCKED_IPLOCATION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430505i32 as _);
13865 pub const SL_E_CHPA_PRODUCT_KEY_OUT_OF_RANGE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430527i32 as _);
13866 pub const SL_E_CHPA_REISSUANCE_LIMIT_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430494i32 as _);
13867 pub const SL_E_CHPA_RESPONSE_NOT_AVAILABLE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430507i32 as _);
13868 pub const SL_E_CHPA_SYSTEM_ERROR: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430516i32 as _);
13869 pub const SL_E_CHPA_TIMEBASED_ACTIVATION_AFTER_END_DATE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430479i32 as _);
13870 pub const SL_E_CHPA_TIMEBASED_ACTIVATION_BEFORE_START_DATE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430480i32 as _);
13871 pub const SL_E_CHPA_TIMEBASED_ACTIVATION_NOT_AVAILABLE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430478i32 as _);
13872 pub const SL_E_CHPA_TIMEBASED_PRODUCT_KEY_NOT_CONFIGURED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430477i32 as _);
13873 pub const SL_E_CHPA_UNKNOWN_PRODUCT_KEY_TYPE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073428636i32 as _);
13874 pub const SL_E_CHPA_UNKNOWN_PROPERTY_ID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073428654i32 as _);
13875 pub const SL_E_CHPA_UNKNOWN_PROPERTY_NAME: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073428655i32 as _);
13876 pub const SL_E_CHPA_UNSUPPORTED_PRODUCT_KEY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073430521i32 as _);
13877 pub const SL_E_CIDIID_INVALID_CHECK_DIGITS: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418163i32 as _);
13878 pub const SL_E_CIDIID_INVALID_DATA: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418196i32 as _);
13879 pub const SL_E_CIDIID_INVALID_DATA_LENGTH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418193i32 as _);
13880 pub const SL_E_CIDIID_INVALID_VERSION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418195i32 as _);
13881 pub const SL_E_CIDIID_MISMATCHED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418191i32 as _);
13882 pub const SL_E_CIDIID_MISMATCHED_PKEY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418114i32 as _);
13883 pub const SL_E_CIDIID_NOT_BOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418113i32 as _);
13884 pub const SL_E_CIDIID_NOT_DEPOSITED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418192i32 as _);
13885 pub const SL_E_CIDIID_VERSION_NOT_SUPPORTED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418194i32 as _);
13886 pub const SL_E_DATATYPE_MISMATCHED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418210i32 as _);
13887 pub const SL_E_DECRYPTION_LICENSES_NOT_AVAILABLE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418212i32 as _);
13888 pub const SL_E_DEPENDENT_PROPERTY_NOT_SET: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418138i32 as _);
13889 pub const SL_E_DOWNLEVEL_SETUP_KEY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417708i32 as _);
13890 pub const SL_E_DUPLICATE_POLICY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418158i32 as _);
13891 pub const SL_E_EDITION_MISMATCHED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417712i32 as _);
13892 pub const SL_E_ENGINE_DETECTED_EXPLOIT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429327i32 as _);
13893 pub const SL_E_EUL_CONSUMPTION_FAILED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422315i32 as _);
13894 pub const SL_E_EUL_NOT_AVAILABLE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418188i32 as _);
13895 pub const SL_E_EVALUATION_FAILED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422333i32 as _);
13896 pub const SL_E_EVENT_ALREADY_REGISTERED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418213i32 as _);
13897 pub const SL_E_EVENT_NOT_REGISTERED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418214i32 as _);
13898 pub const SL_E_EXTERNAL_SIGNATURE_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418234i32 as _);
13899 pub const SL_E_GRACE_TIME_EXPIRED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418231i32 as _);
13900 pub const SL_E_HEALTH_CHECK_FAILED_MUI_FILES: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429330i32 as _);
13901 pub const SL_E_HEALTH_CHECK_FAILED_NEUTRAL_FILES: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429331i32 as _);
13902 pub const SL_E_HWID_CHANGED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417711i32 as _);
13903 pub const SL_E_HWID_ERROR: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422309i32 as _);
13904 pub const SL_E_IA_ID_MISMATCH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073414909i32 as _);
13905 pub const SL_E_IA_INVALID_VIRTUALIZATION_PLATFORM: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073414911i32 as _);
13906 pub const SL_E_IA_MACHINE_NOT_BOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073414908i32 as _);
13907 pub const SL_E_IA_PARENT_PARTITION_NOT_ACTIVATED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073414910i32 as _);
13908 pub const SL_E_IA_THROTTLE_LIMIT_EXCEEDED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073414912i32 as _);
13909 pub const SL_E_INTERNAL_ERROR: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418239i32 as _);
13910 pub const SL_E_INVALID_AD_DATA: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429329i32 as _);
13911 pub const SL_E_INVALID_BINDING_BLOB: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418190i32 as _);
13912 pub const SL_E_INVALID_CLIENT_TOKEN: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429720i32 as _);
13913 pub const SL_E_INVALID_CONTEXT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422335i32 as _);
13914 pub const SL_E_INVALID_CONTEXT_DATA: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422300i32 as _);
13915 pub const SL_E_INVALID_EVENT_ID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418215i32 as _);
13916 pub const SL_E_INVALID_FILE_HASH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429343i32 as _);
13917 pub const SL_E_INVALID_GUID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422330i32 as _);
13918 pub const SL_E_INVALID_HASH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422299i32 as _);
13919 pub const SL_E_INVALID_LICENSE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418209i32 as _);
13920 pub const SL_E_INVALID_LICENSE_STATE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429336i32 as _);
13921 pub const SL_E_INVALID_LICENSE_STATE_BREACH_GRACE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429871i32 as _);
13922 pub const SL_E_INVALID_LICENSE_STATE_BREACH_GRACE_EXPIRED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429870i32 as _);
13923 pub const SL_E_INVALID_OEM_OR_VOLUME_BINDING_DATA: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429337i32 as _);
13924 pub const SL_E_INVALID_OFFLINE_BLOB: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429719i32 as _);
13925 pub const SL_E_INVALID_OSVERSION_TEMPLATEID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429717i32 as _);
13926 pub const SL_E_INVALID_OS_FOR_PRODUCT_KEY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429503i32 as _);
13927 pub const SL_E_INVALID_PACKAGE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418208i32 as _);
13928 pub const SL_E_INVALID_PACKAGE_VERSION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418144i32 as _);
13929 pub const SL_E_INVALID_PKEY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418224i32 as _);
13930 pub const SL_E_INVALID_PRODUCT_KEY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418160i32 as _);
13931 pub const SL_E_INVALID_PRODUCT_KEY_TYPE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418115i32 as _);
13932 pub const SL_E_INVALID_RSDP_COUNT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429328i32 as _);
13933 pub const SL_E_INVALID_RULESET_RULE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422301i32 as _);
13934 pub const SL_E_INVALID_RUNNING_MODE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418199i32 as _);
13935 pub const SL_E_INVALID_TEMPLATE_ID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429770i32 as _);
13936 pub const SL_E_INVALID_TOKEN_DATA: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429332i32 as _);
13937 pub const SL_E_INVALID_USE_OF_ADD_ON_PKEY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2147164122i32 as _);
13938 pub const SL_E_INVALID_XML_BLOB: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429766i32 as _);
13939 pub const SL_E_IP_LOCATION_FALIED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429335i32 as _);
13940 pub const SL_E_ISSUANCE_LICENSE_NOT_INSTALLED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418142i32 as _);
13941 pub const SL_E_LICENSE_AUTHORIZATION_FAILED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418206i32 as _);
13942 pub const SL_E_LICENSE_DECRYPTION_FAILED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418205i32 as _);
13943 pub const SL_E_LICENSE_FILE_NOT_INSTALLED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418223i32 as _);
13944 pub const SL_E_LICENSE_INVALID_ADDON_INFO: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422310i32 as _);
13945 pub const SL_E_LICENSE_MANAGEMENT_DATA_DUPLICATED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418156i32 as _);
13946 pub const SL_E_LICENSE_MANAGEMENT_DATA_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418161i32 as _);
13947 pub const SL_E_LICENSE_NOT_BOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418112i32 as _);
13948 pub const SL_E_LICENSE_SERVER_URL_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418216i32 as _);
13949 pub const SL_E_LICENSE_SIGNATURE_VERIFICATION_FAILED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418211i32 as _);
13950 pub const SL_E_LUA_ACCESSDENIED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418203i32 as _);
13951 pub const SL_E_MISMATCHED_APPID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418230i32 as _);
13952 pub const SL_E_MISMATCHED_KEY_TYPES: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429340i32 as _);
13953 pub const SL_E_MISMATCHED_PID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418235i32 as _);
13954 pub const SL_E_MISMATCHED_PKEY_RANGE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418236i32 as _);
13955 pub const SL_E_MISMATCHED_PRODUCT_SKU: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418135i32 as _);
13956 pub const SL_E_MISMATCHED_SECURITY_PROCESSOR: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418226i32 as _);
13957 pub const SL_E_MISSING_OVERRIDE_ONLY_ATTRIBUTE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418157i32 as _);
13958 pub const SL_E_NONGENUINE_GRACE_TIME_EXPIRED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418140i32 as _);
13959 pub const SL_E_NONGENUINE_GRACE_TIME_EXPIRED_2: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418137i32 as _);
13960 pub const SL_E_NON_GENUINE_STATUS_LAST: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073428992i32 as _);
13961 pub const SL_E_NOTIFICATION_BREACH_DETECTED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429199i32 as _);
13962 pub const SL_E_NOTIFICATION_GRACE_EXPIRED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429198i32 as _);
13963 pub const SL_E_NOTIFICATION_OTHER_REASONS: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429197i32 as _);
13964 pub const SL_E_NOT_ACTIVATED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422331i32 as _);
13965 pub const SL_E_NOT_EVALUATED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422332i32 as _);
13966 pub const SL_E_NOT_GENUINE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417728i32 as _);
13967 pub const SL_E_NOT_SUPPORTED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418218i32 as _);
13968 pub const SL_E_NO_PID_CONFIG_DATA: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418229i32 as _);
13969 pub const SL_E_NO_PRODUCT_KEY_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417709i32 as _);
13970 pub const SL_E_OEM_KEY_EDITION_MISMATCH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417710i32 as _);
13971 pub const SL_E_OFFLINE_GENUINE_BLOB_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429715i32 as _);
13972 pub const SL_E_OFFLINE_GENUINE_BLOB_REVOKED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429716i32 as _);
13973 pub const SL_E_OFFLINE_VALIDATION_BLOB_PARAM_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429718i32 as _);
13974 pub const SL_E_OPERATION_NOT_ALLOWED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418134i32 as _);
13975 pub const SL_E_OUT_OF_TOLERANCE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418225i32 as _);
13976 pub const SL_E_PKEY_INTERNAL_ERROR: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422311i32 as _);
13977 pub const SL_E_PKEY_INVALID_ALGORITHM: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422312i32 as _);
13978 pub const SL_E_PKEY_INVALID_CONFIG: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422314i32 as _);
13979 pub const SL_E_PKEY_INVALID_KEYCHANGE1: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422308i32 as _);
13980 pub const SL_E_PKEY_INVALID_KEYCHANGE2: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422307i32 as _);
13981 pub const SL_E_PKEY_INVALID_KEYCHANGE3: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422306i32 as _);
13982 pub const SL_E_PKEY_INVALID_UNIQUEID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422313i32 as _);
13983 pub const SL_E_PKEY_INVALID_UPGRADE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418143i32 as _);
13984 pub const SL_E_PKEY_NOT_INSTALLED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418220i32 as _);
13985 pub const SL_E_PLUGIN_INVALID_MANIFEST: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418127i32 as _);
13986 pub const SL_E_PLUGIN_NOT_REGISTERED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418122i32 as _);
13987 pub const SL_E_POLICY_CACHE_INVALID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418200i32 as _);
13988 pub const SL_E_POLICY_OTHERINFO_MISMATCH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422304i32 as _);
13989 pub const SL_E_PRODUCT_KEY_INSTALLATION_NOT_ALLOWED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418189i32 as _);
13990 pub const SL_E_PRODUCT_SKU_NOT_INSTALLED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418219i32 as _);
13991 pub const SL_E_PRODUCT_UNIQUENESS_GROUP_ID_INVALID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422303i32 as _);
13992 pub const SL_E_PROXY_KEY_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418202i32 as _);
13993 pub const SL_E_PROXY_POLICY_NOT_UPDATED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418169i32 as _);
13994 pub const SL_E_PUBLISHING_LICENSE_NOT_INSTALLED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418217i32 as _);
13995 pub const SL_E_RAC_NOT_AVAILABLE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418233i32 as _);
13996 pub const SL_E_RIGHT_NOT_CONSUMED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418238i32 as _);
13997 pub const SL_E_RIGHT_NOT_GRANTED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418221i32 as _);
13998 pub const SL_E_SECURE_STORE_ID_MISMATCH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422302i32 as _);
13999 pub const SL_E_SERVICE_RUNNING: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418117i32 as _);
14000 pub const SL_E_SERVICE_STOPPING: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418123i32 as _);
14001 pub const SL_E_SFS_BAD_TOKEN_EXT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2147163899i32 as _);
14002 pub const SL_E_SFS_BAD_TOKEN_NAME: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2147163900i32 as _);
14003 pub const SL_E_SFS_DUPLICATE_TOKEN_NAME: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2147163898i32 as _);
14004 pub const SL_E_SFS_FILE_READ_ERROR: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2147163895i32 as _);
14005 pub const SL_E_SFS_FILE_WRITE_ERROR: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2147163894i32 as _);
14006 pub const SL_E_SFS_INVALID_FD_TABLE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2147163902i32 as _);
14007 pub const SL_E_SFS_INVALID_FILE_POSITION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2147163893i32 as _);
14008 pub const SL_E_SFS_INVALID_FS_HEADER: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2147163891i32 as _);
14009 pub const SL_E_SFS_INVALID_FS_VERSION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2147163903i32 as _);
14010 pub const SL_E_SFS_INVALID_SYNC: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2147163901i32 as _);
14011 pub const SL_E_SFS_INVALID_TOKEN_DATA_HASH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2147163896i32 as _);
14012 pub const SL_E_SFS_INVALID_TOKEN_DESCRIPTOR: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2147163890i32 as _);
14013 pub const SL_E_SFS_NO_ACTIVE_TRANSACTION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2147163892i32 as _);
14014 pub const SL_E_SFS_TOKEN_SIZE_MISMATCH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2147163897i32 as _);
14015 pub const SL_E_SLP_BAD_FORMAT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418151i32 as _);
14016 pub const SL_E_SLP_INVALID_MARKER_VERSION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418116i32 as _);
14017 pub const SL_E_SLP_MISSING_ACPI_SLIC: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418153i32 as _);
14018 pub const SL_E_SLP_MISSING_SLP_MARKER: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418152i32 as _);
14019 pub const SL_E_SLP_NOT_SIGNED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418198i32 as _);
14020 pub const SL_E_SLP_OEM_CERT_MISSING: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418141i32 as _);
14021 pub const SL_E_SOFTMOD_EXPLOIT_DETECTED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429333i32 as _);
14022 pub const SL_E_SPC_NOT_AVAILABLE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418232i32 as _);
14023 pub const SL_E_SRV_AUTHORIZATION_FAILED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073434619i32 as _);
14024 pub const SL_E_SRV_BUSINESS_TOKEN_ENTRY_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073434608i32 as _);
14025 pub const SL_E_SRV_CLIENT_CLOCK_OUT_OF_SYNC: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073434607i32 as _);
14026 pub const SL_E_SRV_GENERAL_ERROR: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073434368i32 as _);
14027 pub const SL_E_SRV_INVALID_BINDING: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073434618i32 as _);
14028 pub const SL_E_SRV_INVALID_LICENSE_STRUCTURE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073434620i32 as _);
14029 pub const SL_E_SRV_INVALID_PAYLOAD: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073434616i32 as _);
14030 pub const SL_E_SRV_INVALID_PRODUCT_KEY_LICENSE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073434622i32 as _);
14031 pub const SL_E_SRV_INVALID_PUBLISH_LICENSE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073434623i32 as _);
14032 pub const SL_E_SRV_INVALID_RIGHTS_ACCOUNT_LICENSE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073434621i32 as _);
14033 pub const SL_E_SRV_INVALID_SECURITY_PROCESSOR_LICENSE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073434615i32 as _);
14034 pub const SL_E_SRV_SERVER_PONG: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073434617i32 as _);
14035 pub const SL_E_STORE_UPGRADE_TOKEN_NOT_AUTHORIZED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422290i32 as _);
14036 pub const SL_E_STORE_UPGRADE_TOKEN_NOT_PRS_SIGNED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422292i32 as _);
14037 pub const SL_E_STORE_UPGRADE_TOKEN_REQUIRED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422295i32 as _);
14038 pub const SL_E_STORE_UPGRADE_TOKEN_WRONG_EDITION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422294i32 as _);
14039 pub const SL_E_STORE_UPGRADE_TOKEN_WRONG_PID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422293i32 as _);
14040 pub const SL_E_STORE_UPGRADE_TOKEN_WRONG_VERSION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422291i32 as _);
14041 pub const SL_E_TAMPER_DETECTED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418201i32 as _);
14042 pub const SL_E_TAMPER_RECOVERY_REQUIRES_ACTIVATION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073414656i32 as _);
14043 pub const SL_E_TKA_CERT_CNG_NOT_AVAILABLE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417453i32 as _);
14044 pub const SL_E_TKA_CERT_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417467i32 as _);
14045 pub const SL_E_TKA_CHALLENGE_EXPIRED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417471i32 as _);
14046 pub const SL_E_TKA_CHALLENGE_MISMATCH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417463i32 as _);
14047 pub const SL_E_TKA_CRITERIA_MISMATCH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417457i32 as _);
14048 pub const SL_E_TKA_FAILED_GRANT_PARSING: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417460i32 as _);
14049 pub const SL_E_TKA_GRANT_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417468i32 as _);
14050 pub const SL_E_TKA_INVALID_BLOB: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417465i32 as _);
14051 pub const SL_E_TKA_INVALID_CERTIFICATE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417462i32 as _);
14052 pub const SL_E_TKA_INVALID_CERT_CHAIN: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417469i32 as _);
14053 pub const SL_E_TKA_INVALID_SKU_ID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417466i32 as _);
14054 pub const SL_E_TKA_INVALID_SMARTCARD: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417461i32 as _);
14055 pub const SL_E_TKA_INVALID_THUMBPRINT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417459i32 as _);
14056 pub const SL_E_TKA_SILENT_ACTIVATION_FAILURE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417470i32 as _);
14057 pub const SL_E_TKA_SOFT_CERT_DISALLOWED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417455i32 as _);
14058 pub const SL_E_TKA_SOFT_CERT_INVALID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417454i32 as _);
14059 pub const SL_E_TKA_TAMPERED_CERT_CHAIN: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417464i32 as _);
14060 pub const SL_E_TKA_THUMBPRINT_CERT_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417458i32 as _);
14061 pub const SL_E_TKA_TPID_MISMATCH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073417456i32 as _);
14062 pub const SL_E_TOKEN_STORE_INVALID_STATE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422334i32 as _);
14063 pub const SL_E_TOKSTO_ALREADY_INITIALIZED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422326i32 as _);
14064 pub const SL_E_TOKSTO_CANT_ACQUIRE_MUTEX: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422317i32 as _);
14065 pub const SL_E_TOKSTO_CANT_CREATE_FILE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422324i32 as _);
14066 pub const SL_E_TOKSTO_CANT_CREATE_MUTEX: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422318i32 as _);
14067 pub const SL_E_TOKSTO_CANT_PARSE_PROPERTIES: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422321i32 as _);
14068 pub const SL_E_TOKSTO_CANT_READ_FILE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422322i32 as _);
14069 pub const SL_E_TOKSTO_CANT_WRITE_TO_FILE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422323i32 as _);
14070 pub const SL_E_TOKSTO_INVALID_FILE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422319i32 as _);
14071 pub const SL_E_TOKSTO_NOT_INITIALIZED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422327i32 as _);
14072 pub const SL_E_TOKSTO_NO_ID_SET: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422325i32 as _);
14073 pub const SL_E_TOKSTO_NO_PROPERTIES: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422328i32 as _);
14074 pub const SL_E_TOKSTO_NO_TOKEN_DATA: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422316i32 as _);
14075 pub const SL_E_TOKSTO_PROPERTY_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422320i32 as _);
14076 pub const SL_E_TOKSTO_TOKEN_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422329i32 as _);
14077 pub const SL_E_USE_LICENSE_NOT_INSTALLED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418237i32 as _);
14078 pub const SL_E_VALIDATION_BLOB_PARAM_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429721i32 as _);
14079 pub const SL_E_VALIDATION_BLOCKED_PRODUCT_KEY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429342i32 as _);
14080 pub const SL_E_VALIDATION_INVALID_PRODUCT_KEY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073429339i32 as _);
14081 pub const SL_E_VALIDITY_PERIOD_EXPIRED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073415161i32 as _);
14082 pub const SL_E_VALIDITY_TIME_EXPIRED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418207i32 as _);
14083 pub const SL_E_VALUE_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418222i32 as _);
14084 pub const SL_E_VL_AD_AO_NAME_TOO_LONG: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418110i32 as _);
14085 pub const SL_E_VL_AD_AO_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418111i32 as _);
14086 pub const SL_E_VL_AD_SCHEMA_VERSION_NOT_SUPPORTED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418109i32 as _);
14087 pub const SL_E_VL_BINDING_SERVICE_NOT_ENABLED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418183i32 as _);
14088 pub const SL_E_VL_BINDING_SERVICE_UNAVAILABLE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418124i32 as _);
14089 pub const SL_E_VL_INFO_PRODUCT_USER_RIGHT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(1074065472i32 as _);
14090 pub const SL_E_VL_INVALID_TIMESTAMP: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418132i32 as _);
14091 pub const SL_E_VL_KEY_MANAGEMENT_SERVICE_ID_MISMATCH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418174i32 as _);
14092 pub const SL_E_VL_KEY_MANAGEMENT_SERVICE_NOT_ACTIVATED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418175i32 as _);
14093 pub const SL_E_VL_KEY_MANAGEMENT_SERVICE_VM_NOT_SUPPORTED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418133i32 as _);
14094 pub const SL_E_VL_MACHINE_NOT_BOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418154i32 as _);
14095 pub const SL_E_VL_NOT_ENOUGH_COUNT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418184i32 as _);
14096 pub const SL_E_VL_NOT_WINDOWS_SLP: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418187i32 as _);
14097 pub const SL_E_WINDOWS_INVALID_LICENSE_STATE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073418204i32 as _);
14098 pub const SL_E_WINDOWS_VERSION_MISMATCH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073422297i32 as _);
14099 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
14100 #[repr(transparent)]
14101 pub struct SL_GENUINE_STATE(pub i32);
14102 pub const SL_GEN_STATE_IS_GENUINE: SL_GENUINE_STATE = SL_GENUINE_STATE(0i32);
14103 pub const SL_GEN_STATE_INVALID_LICENSE: SL_GENUINE_STATE = SL_GENUINE_STATE(1i32);
14104 pub const SL_GEN_STATE_TAMPERED: SL_GENUINE_STATE = SL_GENUINE_STATE(2i32);
14105 pub const SL_GEN_STATE_OFFLINE: SL_GENUINE_STATE = SL_GENUINE_STATE(3i32);
14106 pub const SL_GEN_STATE_LAST: SL_GENUINE_STATE = SL_GENUINE_STATE(4i32);
14107 impl ::std::convert::From<i32> for SL_GENUINE_STATE {
14108     fn from(value: i32) -> Self {
14109         Self(value)
14110     }
14111 }
14112 unsafe impl ::windows::runtime::Abi for SL_GENUINE_STATE {
14113     type Abi = Self;
14114     type DefaultType = Self;
14115 }
14116 pub const SL_INTERNAL_ZONE: u32 = 57344u32;
14117 pub const SL_I_NONGENUINE_GRACE_PERIOD: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(1074065509i32 as _);
14118 pub const SL_I_NONGENUINE_GRACE_PERIOD_2: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(1074065512i32 as _);
14119 pub const SL_I_OOB_GRACE_PERIOD: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(1074065420i32 as _);
14120 pub const SL_I_OOT_GRACE_PERIOD: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(1074065421i32 as _);
14121 pub const SL_I_PERPETUAL_OOB_GRACE_PERIOD: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(1074068485i32 as _);
14122 pub const SL_I_STORE_BASED_ACTIVATION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(1074066433i32 as _);
14123 pub const SL_I_TIMEBASED_EXTENDED_GRACE_PERIOD: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(1074068486i32 as _);
14124 pub const SL_I_TIMEBASED_VALIDITY_PERIOD: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(1074068484i32 as _);
14125 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14126 #[repr(C)]
14127 pub struct SL_LICENSING_STATUS {
14128     pub SkuId: ::windows::runtime::GUID,
14129     pub eStatus: SLLICENSINGSTATUS,
14130     pub dwGraceTime: u32,
14131     pub dwTotalGraceDays: u32,
14132     pub hrReason: ::windows::runtime::HRESULT,
14133     pub qwValidityExpiration: u64,
14134 }
14135 impl SL_LICENSING_STATUS {}
14136 impl ::std::default::Default for SL_LICENSING_STATUS {
14137     fn default() -> Self {
14138         unsafe { ::std::mem::zeroed() }
14139     }
14140 }
14141 impl ::std::fmt::Debug for SL_LICENSING_STATUS {
14142     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14143         fmt.debug_struct("SL_LICENSING_STATUS").field("SkuId", &self.SkuId).field("eStatus", &self.eStatus).field("dwGraceTime", &self.dwGraceTime).field("dwTotalGraceDays", &self.dwTotalGraceDays).field("hrReason", &self.hrReason).field("qwValidityExpiration", &self.qwValidityExpiration).finish()
14144     }
14145 }
14146 impl ::std::cmp::PartialEq for SL_LICENSING_STATUS {
14147     fn eq(&self, other: &Self) -> bool {
14148         self.SkuId == other.SkuId && self.eStatus == other.eStatus && self.dwGraceTime == other.dwGraceTime && self.dwTotalGraceDays == other.dwTotalGraceDays && self.hrReason == other.hrReason && self.qwValidityExpiration == other.qwValidityExpiration
14149     }
14150 }
14151 impl ::std::cmp::Eq for SL_LICENSING_STATUS {}
14152 unsafe impl ::windows::runtime::Abi for SL_LICENSING_STATUS {
14153     type Abi = Self;
14154     type DefaultType = Self;
14155 }
14156 pub const SL_MDOLLAR_ZONE: u32 = 40960u32;
14157 pub const SL_MSCH_ZONE: u32 = 49152u32;
14158 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14159 #[repr(C)]
14160 pub struct SL_NONGENUINE_UI_OPTIONS {
14161     pub cbSize: u32,
14162     pub pComponentId: *mut ::windows::runtime::GUID,
14163     pub hResultUI: ::windows::runtime::HRESULT,
14164 }
14165 impl SL_NONGENUINE_UI_OPTIONS {}
14166 impl ::std::default::Default for SL_NONGENUINE_UI_OPTIONS {
14167     fn default() -> Self {
14168         unsafe { ::std::mem::zeroed() }
14169     }
14170 }
14171 impl ::std::fmt::Debug for SL_NONGENUINE_UI_OPTIONS {
14172     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14173         fmt.debug_struct("SL_NONGENUINE_UI_OPTIONS").field("cbSize", &self.cbSize).field("pComponentId", &self.pComponentId).field("hResultUI", &self.hResultUI).finish()
14174     }
14175 }
14176 impl ::std::cmp::PartialEq for SL_NONGENUINE_UI_OPTIONS {
14177     fn eq(&self, other: &Self) -> bool {
14178         self.cbSize == other.cbSize && self.pComponentId == other.pComponentId && self.hResultUI == other.hResultUI
14179     }
14180 }
14181 impl ::std::cmp::Eq for SL_NONGENUINE_UI_OPTIONS {}
14182 unsafe impl ::windows::runtime::Abi for SL_NONGENUINE_UI_OPTIONS {
14183     type Abi = Self;
14184     type DefaultType = Self;
14185 }
14186 pub const SL_REARM_REBOOT_REQUIRED: u32 = 1u32;
14187 pub const SL_REMAPPING_MDOLLAR_CIDIID_INVALID_CHECK_DIGITS: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313776i32 as _);
14188 pub const SL_REMAPPING_MDOLLAR_CIDIID_INVALID_DATA: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313778i32 as _);
14189 pub const SL_REMAPPING_MDOLLAR_CIDIID_INVALID_DATA_LENGTH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313777i32 as _);
14190 pub const SL_REMAPPING_MDOLLAR_CIDIID_INVALID_VERSION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313779i32 as _);
14191 pub const SL_REMAPPING_MDOLLAR_DIGITALMARKER_BINDING_NOT_CONFIGURED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313708i32 as _);
14192 pub const SL_REMAPPING_MDOLLAR_DIGITALMARKER_INVALID_BINDING: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313709i32 as _);
14193 pub const SL_REMAPPING_MDOLLAR_DMAK_EXTENSION_LIMIT_EXCEEDED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313792i32 as _);
14194 pub const SL_REMAPPING_MDOLLAR_DMAK_LIMIT_EXCEEDED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313793i32 as _);
14195 pub const SL_REMAPPING_MDOLLAR_DMAK_OVERRIDE_LIMIT_REACHED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313706i32 as _);
14196 pub const SL_REMAPPING_MDOLLAR_FREE_OFFER_EXPIRED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143312896i32 as _);
14197 pub const SL_REMAPPING_MDOLLAR_INVALID_ACTCONFIG_ID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313802i32 as _);
14198 pub const SL_REMAPPING_MDOLLAR_INVALID_ARGUMENT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313795i32 as _);
14199 pub const SL_REMAPPING_MDOLLAR_INVALID_BINDING: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313818i32 as _);
14200 pub const SL_REMAPPING_MDOLLAR_INVALID_BINDING_URI: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313798i32 as _);
14201 pub const SL_REMAPPING_MDOLLAR_INVALID_PRODUCT_DATA: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313804i32 as _);
14202 pub const SL_REMAPPING_MDOLLAR_INVALID_PRODUCT_DATA_ID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313805i32 as _);
14203 pub const SL_REMAPPING_MDOLLAR_INVALID_PRODUCT_KEY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313816i32 as _);
14204 pub const SL_REMAPPING_MDOLLAR_INVALID_PRODUCT_KEY_FORMAT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313800i32 as _);
14205 pub const SL_REMAPPING_MDOLLAR_INVALID_PRODUCT_KEY_LENGTH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313801i32 as _);
14206 pub const SL_REMAPPING_MDOLLAR_MAXIMUM_UNLOCK_EXCEEDED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313807i32 as _);
14207 pub const SL_REMAPPING_MDOLLAR_NO_RULES_TO_ACTIVATE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313720i32 as _);
14208 pub const SL_REMAPPING_MDOLLAR_OEM_SLP_COA0: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313789i32 as _);
14209 pub const SL_REMAPPING_MDOLLAR_OSR_DEVICE_BLOCKED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143310909i32 as _);
14210 pub const SL_REMAPPING_MDOLLAR_OSR_DEVICE_THROTTLED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143310914i32 as _);
14211 pub const SL_REMAPPING_MDOLLAR_OSR_DONOR_HWID_NO_ENTITLEMENT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143310920i32 as _);
14212 pub const SL_REMAPPING_MDOLLAR_OSR_GENERIC_ERROR: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143310919i32 as _);
14213 pub const SL_REMAPPING_MDOLLAR_OSR_GP_DISABLED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143310913i32 as _);
14214 pub const SL_REMAPPING_MDOLLAR_OSR_HARDWARE_BLOCKED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143310912i32 as _);
14215 pub const SL_REMAPPING_MDOLLAR_OSR_LICENSE_BLOCKED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143310910i32 as _);
14216 pub const SL_REMAPPING_MDOLLAR_OSR_LICENSE_THROTTLED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143310915i32 as _);
14217 pub const SL_REMAPPING_MDOLLAR_OSR_NOT_ADMIN: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143310917i32 as _);
14218 pub const SL_REMAPPING_MDOLLAR_OSR_NO_ASSOCIATION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143310918i32 as _);
14219 pub const SL_REMAPPING_MDOLLAR_OSR_USER_BLOCKED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143310911i32 as _);
14220 pub const SL_REMAPPING_MDOLLAR_OSR_USER_THROTTLED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143310916i32 as _);
14221 pub const SL_REMAPPING_MDOLLAR_PRODUCT_KEY_BLOCKED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313817i32 as _);
14222 pub const SL_REMAPPING_MDOLLAR_PRODUCT_KEY_BLOCKED_IPLOCATION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313717i32 as _);
14223 pub const SL_REMAPPING_MDOLLAR_PRODUCT_KEY_OUT_OF_RANGE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313819i32 as _);
14224 pub const SL_REMAPPING_MDOLLAR_ROT_OVERRIDE_LIMIT_REACHED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313707i32 as _);
14225 pub const SL_REMAPPING_MDOLLAR_TIMEBASED_ACTIVATION_AFTER_END_DATE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313768i32 as _);
14226 pub const SL_REMAPPING_MDOLLAR_TIMEBASED_ACTIVATION_BEFORE_START_DATE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313769i32 as _);
14227 pub const SL_REMAPPING_MDOLLAR_TIMEBASED_ACTIVATION_NOT_AVAILABLE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313767i32 as _);
14228 pub const SL_REMAPPING_MDOLLAR_TIMEBASED_PRODUCT_KEY_NOT_CONFIGURED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313766i32 as _);
14229 pub const SL_REMAPPING_MDOLLAR_UNSUPPORTED_PRODUCT_KEY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2143313812i32 as _);
14230 pub const SL_REMAPPING_SP_PUB_API_BAD_GET_INFO_QUERY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073426414i32 as _);
14231 pub const SL_REMAPPING_SP_PUB_API_HANDLE_NOT_COMMITED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073426303i32 as _);
14232 pub const SL_REMAPPING_SP_PUB_API_INVALID_ALGORITHM_TYPE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073426423i32 as _);
14233 pub const SL_REMAPPING_SP_PUB_API_INVALID_HANDLE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073426388i32 as _);
14234 pub const SL_REMAPPING_SP_PUB_API_INVALID_KEY_LENGTH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073426347i32 as _);
14235 pub const SL_REMAPPING_SP_PUB_API_INVALID_LICENSE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073426432i32 as _);
14236 pub const SL_REMAPPING_SP_PUB_API_NO_AES_PROVIDER: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073426317i32 as _);
14237 pub const SL_REMAPPING_SP_PUB_API_TOO_MANY_LOADED_ENVIRONMENTS: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073426420i32 as _);
14238 pub const SL_REMAPPING_SP_PUB_CRYPTO_HASH_FINALIZED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425911i32 as _);
14239 pub const SL_REMAPPING_SP_PUB_CRYPTO_INVALID_BLOCK: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425905i32 as _);
14240 pub const SL_REMAPPING_SP_PUB_CRYPTO_INVALID_BLOCKLENGTH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425918i32 as _);
14241 pub const SL_REMAPPING_SP_PUB_CRYPTO_INVALID_CIPHER: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425917i32 as _);
14242 pub const SL_REMAPPING_SP_PUB_CRYPTO_INVALID_CIPHERMODE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425916i32 as _);
14243 pub const SL_REMAPPING_SP_PUB_CRYPTO_INVALID_FORMAT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425904i32 as _);
14244 pub const SL_REMAPPING_SP_PUB_CRYPTO_INVALID_KEYLENGTH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425919i32 as _);
14245 pub const SL_REMAPPING_SP_PUB_CRYPTO_INVALID_PADDING: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425903i32 as _);
14246 pub const SL_REMAPPING_SP_PUB_CRYPTO_INVALID_SIGNATURE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425906i32 as _);
14247 pub const SL_REMAPPING_SP_PUB_CRYPTO_INVALID_SIGNATURELENGTH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425907i32 as _);
14248 pub const SL_REMAPPING_SP_PUB_CRYPTO_KEY_NOT_AVAILABLE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425910i32 as _);
14249 pub const SL_REMAPPING_SP_PUB_CRYPTO_KEY_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425909i32 as _);
14250 pub const SL_REMAPPING_SP_PUB_CRYPTO_NOT_BLOCK_ALIGNED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425908i32 as _);
14251 pub const SL_REMAPPING_SP_PUB_CRYPTO_UNKNOWN_ATTRIBUTEID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425912i32 as _);
14252 pub const SL_REMAPPING_SP_PUB_CRYPTO_UNKNOWN_HASHID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425913i32 as _);
14253 pub const SL_REMAPPING_SP_PUB_CRYPTO_UNKNOWN_KEYID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425914i32 as _);
14254 pub const SL_REMAPPING_SP_PUB_CRYPTO_UNKNOWN_PROVIDERID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425915i32 as _);
14255 pub const SL_REMAPPING_SP_PUB_GENERAL_NOT_INITIALIZED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073426175i32 as _);
14256 pub const SL_REMAPPING_SP_PUB_KM_CACHE_IDENTICAL: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(1074058753i32 as _);
14257 pub const SL_REMAPPING_SP_PUB_KM_CACHE_POLICY_CHANGED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(1074058754i32 as _);
14258 pub const SL_REMAPPING_SP_PUB_KM_CACHE_TAMPER: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425151i32 as _);
14259 pub const SL_REMAPPING_SP_PUB_KM_CACHE_TAMPER_RESTORE_FAILED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425150i32 as _);
14260 pub const SL_REMAPPING_SP_PUB_PROXY_SOFT_TAMPER: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073424638i32 as _);
14261 pub const SL_REMAPPING_SP_PUB_TAMPER_MODULE_AUTHENTICATION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425407i32 as _);
14262 pub const SL_REMAPPING_SP_PUB_TAMPER_SECURITY_PROCESSOR_PATCHED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425406i32 as _);
14263 pub const SL_REMAPPING_SP_PUB_TIMER_ALREADY_EXISTS: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425654i32 as _);
14264 pub const SL_REMAPPING_SP_PUB_TIMER_EXPIRED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425652i32 as _);
14265 pub const SL_REMAPPING_SP_PUB_TIMER_NAME_SIZE_TOO_BIG: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425651i32 as _);
14266 pub const SL_REMAPPING_SP_PUB_TIMER_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425653i32 as _);
14267 pub const SL_REMAPPING_SP_PUB_TIMER_READ_ONLY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425647i32 as _);
14268 pub const SL_REMAPPING_SP_PUB_TRUSTED_TIME_OK: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(1074057999i32 as _);
14269 pub const SL_REMAPPING_SP_PUB_TS_ACCESS_DENIED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425644i32 as _);
14270 pub const SL_REMAPPING_SP_PUB_TS_ATTRIBUTE_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425645i32 as _);
14271 pub const SL_REMAPPING_SP_PUB_TS_ATTRIBUTE_READ_ONLY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425646i32 as _);
14272 pub const SL_REMAPPING_SP_PUB_TS_DATA_SIZE_TOO_BIG: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425656i32 as _);
14273 pub const SL_REMAPPING_SP_PUB_TS_ENTRY_KEY_ALREADY_EXISTS: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425659i32 as _);
14274 pub const SL_REMAPPING_SP_PUB_TS_ENTRY_KEY_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425660i32 as _);
14275 pub const SL_REMAPPING_SP_PUB_TS_ENTRY_KEY_SIZE_TOO_BIG: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425658i32 as _);
14276 pub const SL_REMAPPING_SP_PUB_TS_ENTRY_READ_ONLY: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425648i32 as _);
14277 pub const SL_REMAPPING_SP_PUB_TS_FULL: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425650i32 as _);
14278 pub const SL_REMAPPING_SP_PUB_TS_INVALID_HW_BINDING: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425655i32 as _);
14279 pub const SL_REMAPPING_SP_PUB_TS_MAX_REARM_REACHED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425657i32 as _);
14280 pub const SL_REMAPPING_SP_PUB_TS_NAMESPACE_IN_USE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425642i32 as _);
14281 pub const SL_REMAPPING_SP_PUB_TS_NAMESPACE_NOT_FOUND: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425643i32 as _);
14282 pub const SL_REMAPPING_SP_PUB_TS_REARMED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425662i32 as _);
14283 pub const SL_REMAPPING_SP_PUB_TS_RECREATED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425661i32 as _);
14284 pub const SL_REMAPPING_SP_PUB_TS_TAMPERED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425663i32 as _);
14285 pub const SL_REMAPPING_SP_PUB_TS_TAMPERED_BREADCRUMB_GENERATION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425640i32 as _);
14286 pub const SL_REMAPPING_SP_PUB_TS_TAMPERED_BREADCRUMB_LOAD_INVALID: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425641i32 as _);
14287 pub const SL_REMAPPING_SP_PUB_TS_TAMPERED_DATA_BREADCRUMB_MISMATCH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425637i32 as _);
14288 pub const SL_REMAPPING_SP_PUB_TS_TAMPERED_DATA_VERSION_MISMATCH: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425636i32 as _);
14289 pub const SL_REMAPPING_SP_PUB_TS_TAMPERED_INVALID_DATA: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425639i32 as _);
14290 pub const SL_REMAPPING_SP_PUB_TS_TAMPERED_NO_DATA: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073425638i32 as _);
14291 pub const SL_REMAPPING_SP_STATUS_ALREADY_EXISTS: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073426171i32 as _);
14292 pub const SL_REMAPPING_SP_STATUS_DEBUGGER_DETECTED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2147167989i32 as _);
14293 pub const SL_REMAPPING_SP_STATUS_GENERIC_FAILURE: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073426173i32 as _);
14294 pub const SL_REMAPPING_SP_STATUS_INSUFFICIENT_BUFFER: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073426169i32 as _);
14295 pub const SL_REMAPPING_SP_STATUS_INVALIDARG: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073426172i32 as _);
14296 pub const SL_REMAPPING_SP_STATUS_INVALIDDATA: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073426168i32 as _);
14297 pub const SL_REMAPPING_SP_STATUS_INVALID_SPAPI_CALL: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073426167i32 as _);
14298 pub const SL_REMAPPING_SP_STATUS_INVALID_SPAPI_VERSION: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073426166i32 as _);
14299 pub const SL_REMAPPING_SP_STATUS_NO_MORE_DATA: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073426164i32 as _);
14300 pub const SL_REMAPPING_SP_STATUS_PUSHKEY_CONFLICT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-1073424639i32 as _);
14301 pub const SL_REMAPPING_SP_STATUS_SYSTEM_TIME_SKEWED: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2147167998i32 as _);
14302 pub const SL_SERVER_ZONE: u32 = 45056u32;
14303 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14304 #[repr(C)]
14305 pub struct SL_SYSTEM_POLICY_INFORMATION {
14306     pub Reserved1: [*mut ::std::ffi::c_void; 2],
14307     pub Reserved2: [u32; 3],
14308 }
14309 impl SL_SYSTEM_POLICY_INFORMATION {}
14310 impl ::std::default::Default for SL_SYSTEM_POLICY_INFORMATION {
14311     fn default() -> Self {
14312         unsafe { ::std::mem::zeroed() }
14313     }
14314 }
14315 impl ::std::fmt::Debug for SL_SYSTEM_POLICY_INFORMATION {
14316     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14317         fmt.debug_struct("SL_SYSTEM_POLICY_INFORMATION").field("Reserved1", &self.Reserved1).field("Reserved2", &self.Reserved2).finish()
14318     }
14319 }
14320 impl ::std::cmp::PartialEq for SL_SYSTEM_POLICY_INFORMATION {
14321     fn eq(&self, other: &Self) -> bool {
14322         self.Reserved1 == other.Reserved1 && self.Reserved2 == other.Reserved2
14323     }
14324 }
14325 impl ::std::cmp::Eq for SL_SYSTEM_POLICY_INFORMATION {}
14326 unsafe impl ::windows::runtime::Abi for SL_SYSTEM_POLICY_INFORMATION {
14327     type Abi = Self;
14328     type DefaultType = Self;
14329 }
14330 pub const SL_SYSTEM_STATE_REBOOT_POLICY_FOUND: u32 = 1u32;
14331 pub const SL_SYSTEM_STATE_TAMPERED: u32 = 2u32;
14332 pub const SPP_MIGRATION_GATHER_ACTIVATED_WINDOWS_STATE: u32 = 2u32;
14333 pub const SPP_MIGRATION_GATHER_ALL: u32 = 4294967295u32;
14334 pub const SPP_MIGRATION_GATHER_MIGRATABLE_APPS: u32 = 1u32;
14335 pub const SP_PROT_ALL: u32 = 4294967295u32;
14336 pub const SP_PROT_DTLS1_0_CLIENT: u32 = 131072u32;
14337 pub const SP_PROT_DTLS1_0_SERVER: u32 = 65536u32;
14338 pub const SP_PROT_DTLS1_2_CLIENT: u32 = 524288u32;
14339 pub const SP_PROT_DTLS1_2_SERVER: u32 = 262144u32;
14340 pub const SP_PROT_DTLS_CLIENT: u32 = 131072u32;
14341 pub const SP_PROT_DTLS_SERVER: u32 = 65536u32;
14342 pub const SP_PROT_NONE: u32 = 0u32;
14343 pub const SP_PROT_PCT1_CLIENT: u32 = 2u32;
14344 pub const SP_PROT_PCT1_SERVER: u32 = 1u32;
14345 pub const SP_PROT_SSL2_CLIENT: u32 = 8u32;
14346 pub const SP_PROT_SSL2_SERVER: u32 = 4u32;
14347 pub const SP_PROT_SSL3_CLIENT: u32 = 32u32;
14348 pub const SP_PROT_SSL3_SERVER: u32 = 16u32;
14349 pub const SP_PROT_TLS1_0_CLIENT: u32 = 128u32;
14350 pub const SP_PROT_TLS1_0_SERVER: u32 = 64u32;
14351 pub const SP_PROT_TLS1_1_CLIENT: u32 = 512u32;
14352 pub const SP_PROT_TLS1_1_SERVER: u32 = 256u32;
14353 pub const SP_PROT_TLS1_2_CLIENT: u32 = 2048u32;
14354 pub const SP_PROT_TLS1_2_SERVER: u32 = 1024u32;
14355 pub const SP_PROT_TLS1_3PLUS_CLIENT: u32 = 8192u32;
14356 pub const SP_PROT_TLS1_3PLUS_SERVER: u32 = 4096u32;
14357 pub const SP_PROT_TLS1_3_CLIENT: u32 = 8192u32;
14358 pub const SP_PROT_TLS1_3_SERVER: u32 = 4096u32;
14359 pub const SP_PROT_TLS1_CLIENT: u32 = 128u32;
14360 pub const SP_PROT_TLS1_SERVER: u32 = 64u32;
14361 pub const SP_PROT_UNI_CLIENT: u32 = 2147483648u32;
14362 pub const SP_PROT_UNI_SERVER: u32 = 1073741824u32;
14363 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14364 #[repr(C)]
14365 pub struct SR_SECURITY_DESCRIPTOR {
14366     pub Length: u32,
14367     pub SecurityDescriptor: *mut u8,
14368 }
14369 impl SR_SECURITY_DESCRIPTOR {}
14370 impl ::std::default::Default for SR_SECURITY_DESCRIPTOR {
14371     fn default() -> Self {
14372         unsafe { ::std::mem::zeroed() }
14373     }
14374 }
14375 impl ::std::fmt::Debug for SR_SECURITY_DESCRIPTOR {
14376     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14377         fmt.debug_struct("SR_SECURITY_DESCRIPTOR").field("Length", &self.Length).field("SecurityDescriptor", &self.SecurityDescriptor).finish()
14378     }
14379 }
14380 impl ::std::cmp::PartialEq for SR_SECURITY_DESCRIPTOR {
14381     fn eq(&self, other: &Self) -> bool {
14382         self.Length == other.Length && self.SecurityDescriptor == other.SecurityDescriptor
14383     }
14384 }
14385 impl ::std::cmp::Eq for SR_SECURITY_DESCRIPTOR {}
14386 unsafe impl ::windows::runtime::Abi for SR_SECURITY_DESCRIPTOR {
14387     type Abi = Self;
14388     type DefaultType = Self;
14389 }
14390 #[cfg(feature = "Win32_Foundation")]
14391 pub type SSL_CRACK_CERTIFICATE_FN = unsafe extern "system" fn(pbcertificate: *mut u8, cbcertificate: u32, verifysignature: super::super::super::Foundation::BOOL, ppcertificate: *mut *mut X509Certificate) -> super::super::super::Foundation::BOOL;
14392 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14393 #[repr(C)]
14394 #[cfg(feature = "Win32_Foundation")]
14395 pub struct SSL_CREDENTIAL_CERTIFICATE {
14396     pub cbPrivateKey: u32,
14397     pub pPrivateKey: *mut u8,
14398     pub cbCertificate: u32,
14399     pub pCertificate: *mut u8,
14400     pub pszPassword: super::super::super::Foundation::PSTR,
14401 }
14402 #[cfg(feature = "Win32_Foundation")]
14403 impl SSL_CREDENTIAL_CERTIFICATE {}
14404 #[cfg(feature = "Win32_Foundation")]
14405 impl ::std::default::Default for SSL_CREDENTIAL_CERTIFICATE {
14406     fn default() -> Self {
14407         unsafe { ::std::mem::zeroed() }
14408     }
14409 }
14410 #[cfg(feature = "Win32_Foundation")]
14411 impl ::std::fmt::Debug for SSL_CREDENTIAL_CERTIFICATE {
14412     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14413         fmt.debug_struct("SSL_CREDENTIAL_CERTIFICATE").field("cbPrivateKey", &self.cbPrivateKey).field("pPrivateKey", &self.pPrivateKey).field("cbCertificate", &self.cbCertificate).field("pCertificate", &self.pCertificate).field("pszPassword", &self.pszPassword).finish()
14414     }
14415 }
14416 #[cfg(feature = "Win32_Foundation")]
14417 impl ::std::cmp::PartialEq for SSL_CREDENTIAL_CERTIFICATE {
14418     fn eq(&self, other: &Self) -> bool {
14419         self.cbPrivateKey == other.cbPrivateKey && self.pPrivateKey == other.pPrivateKey && self.cbCertificate == other.cbCertificate && self.pCertificate == other.pCertificate && self.pszPassword == other.pszPassword
14420     }
14421 }
14422 #[cfg(feature = "Win32_Foundation")]
14423 impl ::std::cmp::Eq for SSL_CREDENTIAL_CERTIFICATE {}
14424 #[cfg(feature = "Win32_Foundation")]
14425 unsafe impl ::windows::runtime::Abi for SSL_CREDENTIAL_CERTIFICATE {
14426     type Abi = Self;
14427     type DefaultType = Self;
14428 }
14429 #[cfg(feature = "Win32_Foundation")]
14430 pub type SSL_EMPTY_CACHE_FN_A = unsafe extern "system" fn(psztargetname: super::super::super::Foundation::PSTR, dwflags: u32) -> super::super::super::Foundation::BOOL;
14431 #[cfg(feature = "Win32_Foundation")]
14432 pub type SSL_EMPTY_CACHE_FN_W = unsafe extern "system" fn(psztargetname: super::super::super::Foundation::PWSTR, dwflags: u32) -> super::super::super::Foundation::BOOL;
14433 #[cfg(feature = "Win32_Foundation")]
14434 pub type SSL_FREE_CERTIFICATE_FN = unsafe extern "system" fn(pcertificate: *mut X509Certificate);
14435 pub const SSL_SESSION_RECONNECT: u32 = 1u32;
14436 pub const SSPIPFC_CREDPROV_DO_NOT_LOAD: u32 = 4u32;
14437 pub const SSPIPFC_CREDPROV_DO_NOT_SAVE: u32 = 1u32;
14438 pub const SSPIPFC_NO_CHECKBOX: u32 = 2u32;
14439 pub const SSPIPFC_SAVE_CRED_BY_CALLER: u32 = 1u32;
14440 pub const SSPIPFC_USE_CREDUIBROKER: u32 = 8u32;
14441 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14442 #[repr(C)]
14443 pub struct SUBSCRIBE_GENERIC_TLS_EXTENSION {
14444     pub Flags: u32,
14445     pub SubscriptionsCount: u32,
14446     pub Subscriptions: [TLS_EXTENSION_SUBSCRIPTION; 1],
14447 }
14448 impl SUBSCRIBE_GENERIC_TLS_EXTENSION {}
14449 impl ::std::default::Default for SUBSCRIBE_GENERIC_TLS_EXTENSION {
14450     fn default() -> Self {
14451         unsafe { ::std::mem::zeroed() }
14452     }
14453 }
14454 impl ::std::fmt::Debug for SUBSCRIBE_GENERIC_TLS_EXTENSION {
14455     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14456         fmt.debug_struct("SUBSCRIBE_GENERIC_TLS_EXTENSION").field("Flags", &self.Flags).field("SubscriptionsCount", &self.SubscriptionsCount).field("Subscriptions", &self.Subscriptions).finish()
14457     }
14458 }
14459 impl ::std::cmp::PartialEq for SUBSCRIBE_GENERIC_TLS_EXTENSION {
14460     fn eq(&self, other: &Self) -> bool {
14461         self.Flags == other.Flags && self.SubscriptionsCount == other.SubscriptionsCount && self.Subscriptions == other.Subscriptions
14462     }
14463 }
14464 impl ::std::cmp::Eq for SUBSCRIBE_GENERIC_TLS_EXTENSION {}
14465 unsafe impl ::windows::runtime::Abi for SUBSCRIBE_GENERIC_TLS_EXTENSION {
14466     type Abi = Self;
14467     type DefaultType = Self;
14468 }
14469 pub const SZ_ALG_MAX_SIZE: u32 = 64u32;
14470 #[cfg(feature = "Win32_Security_Credentials")]
14471 #[inline]
14472 pub unsafe fn SaslAcceptSecurityContext(phcredential: *const super::super::Credentials::SecHandle, phcontext: *const super::super::Credentials::SecHandle, pinput: *const SecBufferDesc, fcontextreq: u32, targetdatarep: u32, phnewcontext: *mut super::super::Credentials::SecHandle, poutput: *mut SecBufferDesc, pfcontextattr: *mut u32, ptsexpiry: *mut i64) -> i32 {
14473     #[cfg(windows)]
14474     {
14475         #[link(name = "windows")]
14476         extern "system" {
14477             fn SaslAcceptSecurityContext(phcredential: *const super::super::Credentials::SecHandle, phcontext: *const super::super::Credentials::SecHandle, pinput: *const SecBufferDesc, fcontextreq: u32, targetdatarep: u32, phnewcontext: *mut super::super::Credentials::SecHandle, poutput: *mut SecBufferDesc, pfcontextattr: *mut u32, ptsexpiry: *mut i64) -> i32;
14478         }
14479         ::std::mem::transmute(SaslAcceptSecurityContext(
14480             ::std::mem::transmute(phcredential),
14481             ::std::mem::transmute(phcontext),
14482             ::std::mem::transmute(pinput),
14483             ::std::mem::transmute(fcontextreq),
14484             ::std::mem::transmute(targetdatarep),
14485             ::std::mem::transmute(phnewcontext),
14486             ::std::mem::transmute(poutput),
14487             ::std::mem::transmute(pfcontextattr),
14488             ::std::mem::transmute(ptsexpiry),
14489         ))
14490     }
14491     #[cfg(not(windows))]
14492     unimplemented!("Unsupported target OS");
14493 }
14494 #[cfg(feature = "Win32_Foundation")]
14495 #[inline]
14496 pub unsafe fn SaslEnumerateProfilesA(profilelist: *mut super::super::super::Foundation::PSTR, profilecount: *mut u32) -> i32 {
14497     #[cfg(windows)]
14498     {
14499         #[link(name = "windows")]
14500         extern "system" {
14501             fn SaslEnumerateProfilesA(profilelist: *mut super::super::super::Foundation::PSTR, profilecount: *mut u32) -> i32;
14502         }
14503         ::std::mem::transmute(SaslEnumerateProfilesA(::std::mem::transmute(profilelist), ::std::mem::transmute(profilecount)))
14504     }
14505     #[cfg(not(windows))]
14506     unimplemented!("Unsupported target OS");
14507 }
14508 #[cfg(feature = "Win32_Foundation")]
14509 #[inline]
14510 pub unsafe fn SaslEnumerateProfilesW(profilelist: *mut super::super::super::Foundation::PWSTR, profilecount: *mut u32) -> i32 {
14511     #[cfg(windows)]
14512     {
14513         #[link(name = "windows")]
14514         extern "system" {
14515             fn SaslEnumerateProfilesW(profilelist: *mut super::super::super::Foundation::PWSTR, profilecount: *mut u32) -> i32;
14516         }
14517         ::std::mem::transmute(SaslEnumerateProfilesW(::std::mem::transmute(profilelist), ::std::mem::transmute(profilecount)))
14518     }
14519     #[cfg(not(windows))]
14520     unimplemented!("Unsupported target OS");
14521 }
14522 #[cfg(feature = "Win32_Security_Credentials")]
14523 #[inline]
14524 pub unsafe fn SaslGetContextOption(contexthandle: *const super::super::Credentials::SecHandle, option: u32, value: *mut ::std::ffi::c_void, size: u32, needed: *mut u32) -> i32 {
14525     #[cfg(windows)]
14526     {
14527         #[link(name = "windows")]
14528         extern "system" {
14529             fn SaslGetContextOption(contexthandle: *const super::super::Credentials::SecHandle, option: u32, value: *mut ::std::ffi::c_void, size: u32, needed: *mut u32) -> i32;
14530         }
14531         ::std::mem::transmute(SaslGetContextOption(::std::mem::transmute(contexthandle), ::std::mem::transmute(option), ::std::mem::transmute(value), ::std::mem::transmute(size), ::std::mem::transmute(needed)))
14532     }
14533     #[cfg(not(windows))]
14534     unimplemented!("Unsupported target OS");
14535 }
14536 #[cfg(feature = "Win32_Foundation")]
14537 #[inline]
14538 pub unsafe fn SaslGetProfilePackageA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSTR>>(profilename: Param0, packageinfo: *mut *mut SecPkgInfoA) -> i32 {
14539     #[cfg(windows)]
14540     {
14541         #[link(name = "windows")]
14542         extern "system" {
14543             fn SaslGetProfilePackageA(profilename: super::super::super::Foundation::PSTR, packageinfo: *mut *mut SecPkgInfoA) -> i32;
14544         }
14545         ::std::mem::transmute(SaslGetProfilePackageA(profilename.into_param().abi(), ::std::mem::transmute(packageinfo)))
14546     }
14547     #[cfg(not(windows))]
14548     unimplemented!("Unsupported target OS");
14549 }
14550 #[cfg(feature = "Win32_Foundation")]
14551 #[inline]
14552 pub unsafe fn SaslGetProfilePackageW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(profilename: Param0, packageinfo: *mut *mut SecPkgInfoW) -> i32 {
14553     #[cfg(windows)]
14554     {
14555         #[link(name = "windows")]
14556         extern "system" {
14557             fn SaslGetProfilePackageW(profilename: super::super::super::Foundation::PWSTR, packageinfo: *mut *mut SecPkgInfoW) -> i32;
14558         }
14559         ::std::mem::transmute(SaslGetProfilePackageW(profilename.into_param().abi(), ::std::mem::transmute(packageinfo)))
14560     }
14561     #[cfg(not(windows))]
14562     unimplemented!("Unsupported target OS");
14563 }
14564 #[inline]
14565 pub unsafe fn SaslIdentifyPackageA(pinput: *const SecBufferDesc, packageinfo: *mut *mut SecPkgInfoA) -> i32 {
14566     #[cfg(windows)]
14567     {
14568         #[link(name = "windows")]
14569         extern "system" {
14570             fn SaslIdentifyPackageA(pinput: *const SecBufferDesc, packageinfo: *mut *mut SecPkgInfoA) -> i32;
14571         }
14572         ::std::mem::transmute(SaslIdentifyPackageA(::std::mem::transmute(pinput), ::std::mem::transmute(packageinfo)))
14573     }
14574     #[cfg(not(windows))]
14575     unimplemented!("Unsupported target OS");
14576 }
14577 #[inline]
14578 pub unsafe fn SaslIdentifyPackageW(pinput: *const SecBufferDesc, packageinfo: *mut *mut SecPkgInfoW) -> i32 {
14579     #[cfg(windows)]
14580     {
14581         #[link(name = "windows")]
14582         extern "system" {
14583             fn SaslIdentifyPackageW(pinput: *const SecBufferDesc, packageinfo: *mut *mut SecPkgInfoW) -> i32;
14584         }
14585         ::std::mem::transmute(SaslIdentifyPackageW(::std::mem::transmute(pinput), ::std::mem::transmute(packageinfo)))
14586     }
14587     #[cfg(not(windows))]
14588     unimplemented!("Unsupported target OS");
14589 }
14590 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
14591 #[inline]
14592 pub unsafe fn SaslInitializeSecurityContextA<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSTR>>(
14593     phcredential: *const super::super::Credentials::SecHandle,
14594     phcontext: *const super::super::Credentials::SecHandle,
14595     psztargetname: Param2,
14596     fcontextreq: u32,
14597     reserved1: u32,
14598     targetdatarep: u32,
14599     pinput: *const SecBufferDesc,
14600     reserved2: u32,
14601     phnewcontext: *mut super::super::Credentials::SecHandle,
14602     poutput: *mut SecBufferDesc,
14603     pfcontextattr: *mut u32,
14604     ptsexpiry: *mut i64,
14605 ) -> i32 {
14606     #[cfg(windows)]
14607     {
14608         #[link(name = "windows")]
14609         extern "system" {
14610             fn SaslInitializeSecurityContextA(phcredential: *const super::super::Credentials::SecHandle, phcontext: *const super::super::Credentials::SecHandle, psztargetname: super::super::super::Foundation::PSTR, fcontextreq: u32, reserved1: u32, targetdatarep: u32, pinput: *const SecBufferDesc, reserved2: u32, phnewcontext: *mut super::super::Credentials::SecHandle, poutput: *mut SecBufferDesc, pfcontextattr: *mut u32, ptsexpiry: *mut i64) -> i32;
14611         }
14612         ::std::mem::transmute(SaslInitializeSecurityContextA(
14613             ::std::mem::transmute(phcredential),
14614             ::std::mem::transmute(phcontext),
14615             psztargetname.into_param().abi(),
14616             ::std::mem::transmute(fcontextreq),
14617             ::std::mem::transmute(reserved1),
14618             ::std::mem::transmute(targetdatarep),
14619             ::std::mem::transmute(pinput),
14620             ::std::mem::transmute(reserved2),
14621             ::std::mem::transmute(phnewcontext),
14622             ::std::mem::transmute(poutput),
14623             ::std::mem::transmute(pfcontextattr),
14624             ::std::mem::transmute(ptsexpiry),
14625         ))
14626     }
14627     #[cfg(not(windows))]
14628     unimplemented!("Unsupported target OS");
14629 }
14630 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
14631 #[inline]
14632 pub unsafe fn SaslInitializeSecurityContextW<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(
14633     phcredential: *const super::super::Credentials::SecHandle,
14634     phcontext: *const super::super::Credentials::SecHandle,
14635     psztargetname: Param2,
14636     fcontextreq: u32,
14637     reserved1: u32,
14638     targetdatarep: u32,
14639     pinput: *const SecBufferDesc,
14640     reserved2: u32,
14641     phnewcontext: *mut super::super::Credentials::SecHandle,
14642     poutput: *mut SecBufferDesc,
14643     pfcontextattr: *mut u32,
14644     ptsexpiry: *mut i64,
14645 ) -> i32 {
14646     #[cfg(windows)]
14647     {
14648         #[link(name = "windows")]
14649         extern "system" {
14650             fn SaslInitializeSecurityContextW(phcredential: *const super::super::Credentials::SecHandle, phcontext: *const super::super::Credentials::SecHandle, psztargetname: super::super::super::Foundation::PWSTR, fcontextreq: u32, reserved1: u32, targetdatarep: u32, pinput: *const SecBufferDesc, reserved2: u32, phnewcontext: *mut super::super::Credentials::SecHandle, poutput: *mut SecBufferDesc, pfcontextattr: *mut u32, ptsexpiry: *mut i64) -> i32;
14651         }
14652         ::std::mem::transmute(SaslInitializeSecurityContextW(
14653             ::std::mem::transmute(phcredential),
14654             ::std::mem::transmute(phcontext),
14655             psztargetname.into_param().abi(),
14656             ::std::mem::transmute(fcontextreq),
14657             ::std::mem::transmute(reserved1),
14658             ::std::mem::transmute(targetdatarep),
14659             ::std::mem::transmute(pinput),
14660             ::std::mem::transmute(reserved2),
14661             ::std::mem::transmute(phnewcontext),
14662             ::std::mem::transmute(poutput),
14663             ::std::mem::transmute(pfcontextattr),
14664             ::std::mem::transmute(ptsexpiry),
14665         ))
14666     }
14667     #[cfg(not(windows))]
14668     unimplemented!("Unsupported target OS");
14669 }
14670 #[cfg(feature = "Win32_Security_Credentials")]
14671 #[inline]
14672 pub unsafe fn SaslSetContextOption(contexthandle: *const super::super::Credentials::SecHandle, option: u32, value: *const ::std::ffi::c_void, size: u32) -> i32 {
14673     #[cfg(windows)]
14674     {
14675         #[link(name = "windows")]
14676         extern "system" {
14677             fn SaslSetContextOption(contexthandle: *const super::super::Credentials::SecHandle, option: u32, value: *const ::std::ffi::c_void, size: u32) -> i32;
14678         }
14679         ::std::mem::transmute(SaslSetContextOption(::std::mem::transmute(contexthandle), ::std::mem::transmute(option), ::std::mem::transmute(value), ::std::mem::transmute(size)))
14680     }
14681     #[cfg(not(windows))]
14682     unimplemented!("Unsupported target OS");
14683 }
14684 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
14685 #[repr(transparent)]
14686 pub struct SchGetExtensionsOptions(pub u32);
14687 pub const SCH_EXTENSIONS_OPTIONS_NONE: SchGetExtensionsOptions = SchGetExtensionsOptions(0u32);
14688 pub const SCH_NO_RECORD_HEADER: SchGetExtensionsOptions = SchGetExtensionsOptions(1u32);
14689 impl ::std::convert::From<u32> for SchGetExtensionsOptions {
14690     fn from(value: u32) -> Self {
14691         Self(value)
14692     }
14693 }
14694 unsafe impl ::windows::runtime::Abi for SchGetExtensionsOptions {
14695     type Abi = Self;
14696     type DefaultType = Self;
14697 }
14698 impl ::std::ops::BitOr for SchGetExtensionsOptions {
14699     type Output = Self;
14700     fn bitor(self, rhs: Self) -> Self {
14701         Self(self.0 | rhs.0)
14702     }
14703 }
14704 impl ::std::ops::BitAnd for SchGetExtensionsOptions {
14705     type Output = Self;
14706     fn bitand(self, rhs: Self) -> Self {
14707         Self(self.0 & rhs.0)
14708     }
14709 }
14710 impl ::std::ops::BitOrAssign for SchGetExtensionsOptions {
14711     fn bitor_assign(&mut self, rhs: Self) {
14712         self.0.bitor_assign(rhs.0)
14713     }
14714 }
14715 impl ::std::ops::BitAndAssign for SchGetExtensionsOptions {
14716     fn bitand_assign(&mut self, rhs: Self) {
14717         self.0.bitand_assign(rhs.0)
14718     }
14719 }
14720 impl ::std::ops::Not for SchGetExtensionsOptions {
14721     type Output = Self;
14722     fn not(self) -> Self {
14723         Self(self.0.not())
14724     }
14725 }
14726 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14727 #[repr(C)]
14728 pub struct SecBuffer {
14729     pub cbBuffer: u32,
14730     pub BufferType: u32,
14731     pub pvBuffer: *mut ::std::ffi::c_void,
14732 }
14733 impl SecBuffer {}
14734 impl ::std::default::Default for SecBuffer {
14735     fn default() -> Self {
14736         unsafe { ::std::mem::zeroed() }
14737     }
14738 }
14739 impl ::std::fmt::Debug for SecBuffer {
14740     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14741         fmt.debug_struct("SecBuffer").field("cbBuffer", &self.cbBuffer).field("BufferType", &self.BufferType).field("pvBuffer", &self.pvBuffer).finish()
14742     }
14743 }
14744 impl ::std::cmp::PartialEq for SecBuffer {
14745     fn eq(&self, other: &Self) -> bool {
14746         self.cbBuffer == other.cbBuffer && self.BufferType == other.BufferType && self.pvBuffer == other.pvBuffer
14747     }
14748 }
14749 impl ::std::cmp::Eq for SecBuffer {}
14750 unsafe impl ::windows::runtime::Abi for SecBuffer {
14751     type Abi = Self;
14752     type DefaultType = Self;
14753 }
14754 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14755 #[repr(C)]
14756 pub struct SecBufferDesc {
14757     pub ulVersion: u32,
14758     pub cBuffers: u32,
14759     pub pBuffers: *mut SecBuffer,
14760 }
14761 impl SecBufferDesc {}
14762 impl ::std::default::Default for SecBufferDesc {
14763     fn default() -> Self {
14764         unsafe { ::std::mem::zeroed() }
14765     }
14766 }
14767 impl ::std::fmt::Debug for SecBufferDesc {
14768     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14769         fmt.debug_struct("SecBufferDesc").field("ulVersion", &self.ulVersion).field("cBuffers", &self.cBuffers).field("pBuffers", &self.pBuffers).finish()
14770     }
14771 }
14772 impl ::std::cmp::PartialEq for SecBufferDesc {
14773     fn eq(&self, other: &Self) -> bool {
14774         self.ulVersion == other.ulVersion && self.cBuffers == other.cBuffers && self.pBuffers == other.pBuffers
14775     }
14776 }
14777 impl ::std::cmp::Eq for SecBufferDesc {}
14778 unsafe impl ::windows::runtime::Abi for SecBufferDesc {
14779     type Abi = Self;
14780     type DefaultType = Self;
14781 }
14782 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
14783 #[repr(transparent)]
14784 pub struct SecDelegationType(pub i32);
14785 pub const SecFull: SecDelegationType = SecDelegationType(0i32);
14786 pub const SecService: SecDelegationType = SecDelegationType(1i32);
14787 pub const SecTree: SecDelegationType = SecDelegationType(2i32);
14788 pub const SecDirectory: SecDelegationType = SecDelegationType(3i32);
14789 pub const SecObject: SecDelegationType = SecDelegationType(4i32);
14790 impl ::std::convert::From<i32> for SecDelegationType {
14791     fn from(value: i32) -> Self {
14792         Self(value)
14793     }
14794 }
14795 unsafe impl ::windows::runtime::Abi for SecDelegationType {
14796     type Abi = Self;
14797     type DefaultType = Self;
14798 }
14799 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14800 #[repr(C)]
14801 pub struct SecPkgContext_AccessToken {
14802     pub AccessToken: *mut ::std::ffi::c_void,
14803 }
14804 impl SecPkgContext_AccessToken {}
14805 impl ::std::default::Default for SecPkgContext_AccessToken {
14806     fn default() -> Self {
14807         unsafe { ::std::mem::zeroed() }
14808     }
14809 }
14810 impl ::std::fmt::Debug for SecPkgContext_AccessToken {
14811     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14812         fmt.debug_struct("SecPkgContext_AccessToken").field("AccessToken", &self.AccessToken).finish()
14813     }
14814 }
14815 impl ::std::cmp::PartialEq for SecPkgContext_AccessToken {
14816     fn eq(&self, other: &Self) -> bool {
14817         self.AccessToken == other.AccessToken
14818     }
14819 }
14820 impl ::std::cmp::Eq for SecPkgContext_AccessToken {}
14821 unsafe impl ::windows::runtime::Abi for SecPkgContext_AccessToken {
14822     type Abi = Self;
14823     type DefaultType = Self;
14824 }
14825 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14826 #[repr(C)]
14827 pub struct SecPkgContext_ApplicationProtocol {
14828     pub ProtoNegoStatus: SEC_APPLICATION_PROTOCOL_NEGOTIATION_STATUS,
14829     pub ProtoNegoExt: SEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT,
14830     pub ProtocolIdSize: u8,
14831     pub ProtocolId: [u8; 255],
14832 }
14833 impl SecPkgContext_ApplicationProtocol {}
14834 impl ::std::default::Default for SecPkgContext_ApplicationProtocol {
14835     fn default() -> Self {
14836         unsafe { ::std::mem::zeroed() }
14837     }
14838 }
14839 impl ::std::fmt::Debug for SecPkgContext_ApplicationProtocol {
14840     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14841         fmt.debug_struct("SecPkgContext_ApplicationProtocol").field("ProtoNegoStatus", &self.ProtoNegoStatus).field("ProtoNegoExt", &self.ProtoNegoExt).field("ProtocolIdSize", &self.ProtocolIdSize).field("ProtocolId", &self.ProtocolId).finish()
14842     }
14843 }
14844 impl ::std::cmp::PartialEq for SecPkgContext_ApplicationProtocol {
14845     fn eq(&self, other: &Self) -> bool {
14846         self.ProtoNegoStatus == other.ProtoNegoStatus && self.ProtoNegoExt == other.ProtoNegoExt && self.ProtocolIdSize == other.ProtocolIdSize && self.ProtocolId == other.ProtocolId
14847     }
14848 }
14849 impl ::std::cmp::Eq for SecPkgContext_ApplicationProtocol {}
14850 unsafe impl ::windows::runtime::Abi for SecPkgContext_ApplicationProtocol {
14851     type Abi = Self;
14852     type DefaultType = Self;
14853 }
14854 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14855 #[repr(C)]
14856 pub struct SecPkgContext_AuthorityA {
14857     pub sAuthorityName: *mut i8,
14858 }
14859 impl SecPkgContext_AuthorityA {}
14860 impl ::std::default::Default for SecPkgContext_AuthorityA {
14861     fn default() -> Self {
14862         unsafe { ::std::mem::zeroed() }
14863     }
14864 }
14865 impl ::std::fmt::Debug for SecPkgContext_AuthorityA {
14866     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14867         fmt.debug_struct("SecPkgContext_AuthorityA").field("sAuthorityName", &self.sAuthorityName).finish()
14868     }
14869 }
14870 impl ::std::cmp::PartialEq for SecPkgContext_AuthorityA {
14871     fn eq(&self, other: &Self) -> bool {
14872         self.sAuthorityName == other.sAuthorityName
14873     }
14874 }
14875 impl ::std::cmp::Eq for SecPkgContext_AuthorityA {}
14876 unsafe impl ::windows::runtime::Abi for SecPkgContext_AuthorityA {
14877     type Abi = Self;
14878     type DefaultType = Self;
14879 }
14880 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14881 #[repr(C)]
14882 pub struct SecPkgContext_AuthorityW {
14883     pub sAuthorityName: *mut u16,
14884 }
14885 impl SecPkgContext_AuthorityW {}
14886 impl ::std::default::Default for SecPkgContext_AuthorityW {
14887     fn default() -> Self {
14888         unsafe { ::std::mem::zeroed() }
14889     }
14890 }
14891 impl ::std::fmt::Debug for SecPkgContext_AuthorityW {
14892     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14893         fmt.debug_struct("SecPkgContext_AuthorityW").field("sAuthorityName", &self.sAuthorityName).finish()
14894     }
14895 }
14896 impl ::std::cmp::PartialEq for SecPkgContext_AuthorityW {
14897     fn eq(&self, other: &Self) -> bool {
14898         self.sAuthorityName == other.sAuthorityName
14899     }
14900 }
14901 impl ::std::cmp::Eq for SecPkgContext_AuthorityW {}
14902 unsafe impl ::windows::runtime::Abi for SecPkgContext_AuthorityW {
14903     type Abi = Self;
14904     type DefaultType = Self;
14905 }
14906 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14907 #[repr(C)]
14908 #[cfg(feature = "Win32_Foundation")]
14909 pub struct SecPkgContext_AuthzID {
14910     pub AuthzIDLength: u32,
14911     pub AuthzID: super::super::super::Foundation::PSTR,
14912 }
14913 #[cfg(feature = "Win32_Foundation")]
14914 impl SecPkgContext_AuthzID {}
14915 #[cfg(feature = "Win32_Foundation")]
14916 impl ::std::default::Default for SecPkgContext_AuthzID {
14917     fn default() -> Self {
14918         unsafe { ::std::mem::zeroed() }
14919     }
14920 }
14921 #[cfg(feature = "Win32_Foundation")]
14922 impl ::std::fmt::Debug for SecPkgContext_AuthzID {
14923     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14924         fmt.debug_struct("SecPkgContext_AuthzID").field("AuthzIDLength", &self.AuthzIDLength).field("AuthzID", &self.AuthzID).finish()
14925     }
14926 }
14927 #[cfg(feature = "Win32_Foundation")]
14928 impl ::std::cmp::PartialEq for SecPkgContext_AuthzID {
14929     fn eq(&self, other: &Self) -> bool {
14930         self.AuthzIDLength == other.AuthzIDLength && self.AuthzID == other.AuthzID
14931     }
14932 }
14933 #[cfg(feature = "Win32_Foundation")]
14934 impl ::std::cmp::Eq for SecPkgContext_AuthzID {}
14935 #[cfg(feature = "Win32_Foundation")]
14936 unsafe impl ::windows::runtime::Abi for SecPkgContext_AuthzID {
14937     type Abi = Self;
14938     type DefaultType = Self;
14939 }
14940 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14941 #[repr(C)]
14942 pub struct SecPkgContext_Bindings {
14943     pub BindingsLength: u32,
14944     pub Bindings: *mut SEC_CHANNEL_BINDINGS,
14945 }
14946 impl SecPkgContext_Bindings {}
14947 impl ::std::default::Default for SecPkgContext_Bindings {
14948     fn default() -> Self {
14949         unsafe { ::std::mem::zeroed() }
14950     }
14951 }
14952 impl ::std::fmt::Debug for SecPkgContext_Bindings {
14953     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14954         fmt.debug_struct("SecPkgContext_Bindings").field("BindingsLength", &self.BindingsLength).field("Bindings", &self.Bindings).finish()
14955     }
14956 }
14957 impl ::std::cmp::PartialEq for SecPkgContext_Bindings {
14958     fn eq(&self, other: &Self) -> bool {
14959         self.BindingsLength == other.BindingsLength && self.Bindings == other.Bindings
14960     }
14961 }
14962 impl ::std::cmp::Eq for SecPkgContext_Bindings {}
14963 unsafe impl ::windows::runtime::Abi for SecPkgContext_Bindings {
14964     type Abi = Self;
14965     type DefaultType = Self;
14966 }
14967 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
14968 #[repr(C)]
14969 #[cfg(feature = "Win32_Foundation")]
14970 pub struct SecPkgContext_CertInfo {
14971     pub dwVersion: u32,
14972     pub cbSubjectName: u32,
14973     pub pwszSubjectName: super::super::super::Foundation::PWSTR,
14974     pub cbIssuerName: u32,
14975     pub pwszIssuerName: super::super::super::Foundation::PWSTR,
14976     pub dwKeySize: u32,
14977 }
14978 #[cfg(feature = "Win32_Foundation")]
14979 impl SecPkgContext_CertInfo {}
14980 #[cfg(feature = "Win32_Foundation")]
14981 impl ::std::default::Default for SecPkgContext_CertInfo {
14982     fn default() -> Self {
14983         unsafe { ::std::mem::zeroed() }
14984     }
14985 }
14986 #[cfg(feature = "Win32_Foundation")]
14987 impl ::std::fmt::Debug for SecPkgContext_CertInfo {
14988     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
14989         fmt.debug_struct("SecPkgContext_CertInfo")
14990             .field("dwVersion", &self.dwVersion)
14991             .field("cbSubjectName", &self.cbSubjectName)
14992             .field("pwszSubjectName", &self.pwszSubjectName)
14993             .field("cbIssuerName", &self.cbIssuerName)
14994             .field("pwszIssuerName", &self.pwszIssuerName)
14995             .field("dwKeySize", &self.dwKeySize)
14996             .finish()
14997     }
14998 }
14999 #[cfg(feature = "Win32_Foundation")]
15000 impl ::std::cmp::PartialEq for SecPkgContext_CertInfo {
15001     fn eq(&self, other: &Self) -> bool {
15002         self.dwVersion == other.dwVersion && self.cbSubjectName == other.cbSubjectName && self.pwszSubjectName == other.pwszSubjectName && self.cbIssuerName == other.cbIssuerName && self.pwszIssuerName == other.pwszIssuerName && self.dwKeySize == other.dwKeySize
15003     }
15004 }
15005 #[cfg(feature = "Win32_Foundation")]
15006 impl ::std::cmp::Eq for SecPkgContext_CertInfo {}
15007 #[cfg(feature = "Win32_Foundation")]
15008 unsafe impl ::windows::runtime::Abi for SecPkgContext_CertInfo {
15009     type Abi = Self;
15010     type DefaultType = Self;
15011 }
15012 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15013 #[repr(C)]
15014 pub struct SecPkgContext_CertificateValidationResult {
15015     pub dwChainErrorStatus: u32,
15016     pub hrVerifyChainStatus: ::windows::runtime::HRESULT,
15017 }
15018 impl SecPkgContext_CertificateValidationResult {}
15019 impl ::std::default::Default for SecPkgContext_CertificateValidationResult {
15020     fn default() -> Self {
15021         unsafe { ::std::mem::zeroed() }
15022     }
15023 }
15024 impl ::std::fmt::Debug for SecPkgContext_CertificateValidationResult {
15025     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15026         fmt.debug_struct("SecPkgContext_CertificateValidationResult").field("dwChainErrorStatus", &self.dwChainErrorStatus).field("hrVerifyChainStatus", &self.hrVerifyChainStatus).finish()
15027     }
15028 }
15029 impl ::std::cmp::PartialEq for SecPkgContext_CertificateValidationResult {
15030     fn eq(&self, other: &Self) -> bool {
15031         self.dwChainErrorStatus == other.dwChainErrorStatus && self.hrVerifyChainStatus == other.hrVerifyChainStatus
15032     }
15033 }
15034 impl ::std::cmp::Eq for SecPkgContext_CertificateValidationResult {}
15035 unsafe impl ::windows::runtime::Abi for SecPkgContext_CertificateValidationResult {
15036     type Abi = Self;
15037     type DefaultType = Self;
15038 }
15039 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15040 #[repr(C)]
15041 pub struct SecPkgContext_Certificates {
15042     pub cCertificates: u32,
15043     pub cbCertificateChain: u32,
15044     pub pbCertificateChain: *mut u8,
15045 }
15046 impl SecPkgContext_Certificates {}
15047 impl ::std::default::Default for SecPkgContext_Certificates {
15048     fn default() -> Self {
15049         unsafe { ::std::mem::zeroed() }
15050     }
15051 }
15052 impl ::std::fmt::Debug for SecPkgContext_Certificates {
15053     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15054         fmt.debug_struct("SecPkgContext_Certificates").field("cCertificates", &self.cCertificates).field("cbCertificateChain", &self.cbCertificateChain).field("pbCertificateChain", &self.pbCertificateChain).finish()
15055     }
15056 }
15057 impl ::std::cmp::PartialEq for SecPkgContext_Certificates {
15058     fn eq(&self, other: &Self) -> bool {
15059         self.cCertificates == other.cCertificates && self.cbCertificateChain == other.cbCertificateChain && self.pbCertificateChain == other.pbCertificateChain
15060     }
15061 }
15062 impl ::std::cmp::Eq for SecPkgContext_Certificates {}
15063 unsafe impl ::windows::runtime::Abi for SecPkgContext_Certificates {
15064     type Abi = Self;
15065     type DefaultType = Self;
15066 }
15067 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15068 #[repr(C)]
15069 pub struct SecPkgContext_CipherInfo {
15070     pub dwVersion: u32,
15071     pub dwProtocol: u32,
15072     pub dwCipherSuite: u32,
15073     pub dwBaseCipherSuite: u32,
15074     pub szCipherSuite: [u16; 64],
15075     pub szCipher: [u16; 64],
15076     pub dwCipherLen: u32,
15077     pub dwCipherBlockLen: u32,
15078     pub szHash: [u16; 64],
15079     pub dwHashLen: u32,
15080     pub szExchange: [u16; 64],
15081     pub dwMinExchangeLen: u32,
15082     pub dwMaxExchangeLen: u32,
15083     pub szCertificate: [u16; 64],
15084     pub dwKeyType: u32,
15085 }
15086 impl SecPkgContext_CipherInfo {}
15087 impl ::std::default::Default for SecPkgContext_CipherInfo {
15088     fn default() -> Self {
15089         unsafe { ::std::mem::zeroed() }
15090     }
15091 }
15092 impl ::std::fmt::Debug for SecPkgContext_CipherInfo {
15093     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15094         fmt.debug_struct("SecPkgContext_CipherInfo")
15095             .field("dwVersion", &self.dwVersion)
15096             .field("dwProtocol", &self.dwProtocol)
15097             .field("dwCipherSuite", &self.dwCipherSuite)
15098             .field("dwBaseCipherSuite", &self.dwBaseCipherSuite)
15099             .field("szCipherSuite", &self.szCipherSuite)
15100             .field("szCipher", &self.szCipher)
15101             .field("dwCipherLen", &self.dwCipherLen)
15102             .field("dwCipherBlockLen", &self.dwCipherBlockLen)
15103             .field("szHash", &self.szHash)
15104             .field("dwHashLen", &self.dwHashLen)
15105             .field("szExchange", &self.szExchange)
15106             .field("dwMinExchangeLen", &self.dwMinExchangeLen)
15107             .field("dwMaxExchangeLen", &self.dwMaxExchangeLen)
15108             .field("szCertificate", &self.szCertificate)
15109             .field("dwKeyType", &self.dwKeyType)
15110             .finish()
15111     }
15112 }
15113 impl ::std::cmp::PartialEq for SecPkgContext_CipherInfo {
15114     fn eq(&self, other: &Self) -> bool {
15115         self.dwVersion == other.dwVersion
15116             && self.dwProtocol == other.dwProtocol
15117             && self.dwCipherSuite == other.dwCipherSuite
15118             && self.dwBaseCipherSuite == other.dwBaseCipherSuite
15119             && self.szCipherSuite == other.szCipherSuite
15120             && self.szCipher == other.szCipher
15121             && self.dwCipherLen == other.dwCipherLen
15122             && self.dwCipherBlockLen == other.dwCipherBlockLen
15123             && self.szHash == other.szHash
15124             && self.dwHashLen == other.dwHashLen
15125             && self.szExchange == other.szExchange
15126             && self.dwMinExchangeLen == other.dwMinExchangeLen
15127             && self.dwMaxExchangeLen == other.dwMaxExchangeLen
15128             && self.szCertificate == other.szCertificate
15129             && self.dwKeyType == other.dwKeyType
15130     }
15131 }
15132 impl ::std::cmp::Eq for SecPkgContext_CipherInfo {}
15133 unsafe impl ::windows::runtime::Abi for SecPkgContext_CipherInfo {
15134     type Abi = Self;
15135     type DefaultType = Self;
15136 }
15137 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15138 #[repr(C)]
15139 pub struct SecPkgContext_ClientCertPolicyResult {
15140     pub dwPolicyResult: ::windows::runtime::HRESULT,
15141     pub guidPolicyId: ::windows::runtime::GUID,
15142 }
15143 impl SecPkgContext_ClientCertPolicyResult {}
15144 impl ::std::default::Default for SecPkgContext_ClientCertPolicyResult {
15145     fn default() -> Self {
15146         unsafe { ::std::mem::zeroed() }
15147     }
15148 }
15149 impl ::std::fmt::Debug for SecPkgContext_ClientCertPolicyResult {
15150     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15151         fmt.debug_struct("SecPkgContext_ClientCertPolicyResult").field("dwPolicyResult", &self.dwPolicyResult).field("guidPolicyId", &self.guidPolicyId).finish()
15152     }
15153 }
15154 impl ::std::cmp::PartialEq for SecPkgContext_ClientCertPolicyResult {
15155     fn eq(&self, other: &Self) -> bool {
15156         self.dwPolicyResult == other.dwPolicyResult && self.guidPolicyId == other.guidPolicyId
15157     }
15158 }
15159 impl ::std::cmp::Eq for SecPkgContext_ClientCertPolicyResult {}
15160 unsafe impl ::windows::runtime::Abi for SecPkgContext_ClientCertPolicyResult {
15161     type Abi = Self;
15162     type DefaultType = Self;
15163 }
15164 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15165 #[repr(C)]
15166 pub struct SecPkgContext_ClientSpecifiedTarget {
15167     pub sTargetName: *mut u16,
15168 }
15169 impl SecPkgContext_ClientSpecifiedTarget {}
15170 impl ::std::default::Default for SecPkgContext_ClientSpecifiedTarget {
15171     fn default() -> Self {
15172         unsafe { ::std::mem::zeroed() }
15173     }
15174 }
15175 impl ::std::fmt::Debug for SecPkgContext_ClientSpecifiedTarget {
15176     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15177         fmt.debug_struct("SecPkgContext_ClientSpecifiedTarget").field("sTargetName", &self.sTargetName).finish()
15178     }
15179 }
15180 impl ::std::cmp::PartialEq for SecPkgContext_ClientSpecifiedTarget {
15181     fn eq(&self, other: &Self) -> bool {
15182         self.sTargetName == other.sTargetName
15183     }
15184 }
15185 impl ::std::cmp::Eq for SecPkgContext_ClientSpecifiedTarget {}
15186 unsafe impl ::windows::runtime::Abi for SecPkgContext_ClientSpecifiedTarget {
15187     type Abi = Self;
15188     type DefaultType = Self;
15189 }
15190 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15191 #[repr(C)]
15192 pub struct SecPkgContext_ConnectionInfo {
15193     pub dwProtocol: u32,
15194     pub aiCipher: u32,
15195     pub dwCipherStrength: u32,
15196     pub aiHash: u32,
15197     pub dwHashStrength: u32,
15198     pub aiExch: u32,
15199     pub dwExchStrength: u32,
15200 }
15201 impl SecPkgContext_ConnectionInfo {}
15202 impl ::std::default::Default for SecPkgContext_ConnectionInfo {
15203     fn default() -> Self {
15204         unsafe { ::std::mem::zeroed() }
15205     }
15206 }
15207 impl ::std::fmt::Debug for SecPkgContext_ConnectionInfo {
15208     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15209         fmt.debug_struct("SecPkgContext_ConnectionInfo")
15210             .field("dwProtocol", &self.dwProtocol)
15211             .field("aiCipher", &self.aiCipher)
15212             .field("dwCipherStrength", &self.dwCipherStrength)
15213             .field("aiHash", &self.aiHash)
15214             .field("dwHashStrength", &self.dwHashStrength)
15215             .field("aiExch", &self.aiExch)
15216             .field("dwExchStrength", &self.dwExchStrength)
15217             .finish()
15218     }
15219 }
15220 impl ::std::cmp::PartialEq for SecPkgContext_ConnectionInfo {
15221     fn eq(&self, other: &Self) -> bool {
15222         self.dwProtocol == other.dwProtocol && self.aiCipher == other.aiCipher && self.dwCipherStrength == other.dwCipherStrength && self.aiHash == other.aiHash && self.dwHashStrength == other.dwHashStrength && self.aiExch == other.aiExch && self.dwExchStrength == other.dwExchStrength
15223     }
15224 }
15225 impl ::std::cmp::Eq for SecPkgContext_ConnectionInfo {}
15226 unsafe impl ::windows::runtime::Abi for SecPkgContext_ConnectionInfo {
15227     type Abi = Self;
15228     type DefaultType = Self;
15229 }
15230 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15231 #[repr(C)]
15232 pub struct SecPkgContext_ConnectionInfoEx {
15233     pub dwVersion: u32,
15234     pub dwProtocol: u32,
15235     pub szCipher: [u16; 64],
15236     pub dwCipherStrength: u32,
15237     pub szHash: [u16; 64],
15238     pub dwHashStrength: u32,
15239     pub szExchange: [u16; 64],
15240     pub dwExchStrength: u32,
15241 }
15242 impl SecPkgContext_ConnectionInfoEx {}
15243 impl ::std::default::Default for SecPkgContext_ConnectionInfoEx {
15244     fn default() -> Self {
15245         unsafe { ::std::mem::zeroed() }
15246     }
15247 }
15248 impl ::std::fmt::Debug for SecPkgContext_ConnectionInfoEx {
15249     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15250         fmt.debug_struct("SecPkgContext_ConnectionInfoEx")
15251             .field("dwVersion", &self.dwVersion)
15252             .field("dwProtocol", &self.dwProtocol)
15253             .field("szCipher", &self.szCipher)
15254             .field("dwCipherStrength", &self.dwCipherStrength)
15255             .field("szHash", &self.szHash)
15256             .field("dwHashStrength", &self.dwHashStrength)
15257             .field("szExchange", &self.szExchange)
15258             .field("dwExchStrength", &self.dwExchStrength)
15259             .finish()
15260     }
15261 }
15262 impl ::std::cmp::PartialEq for SecPkgContext_ConnectionInfoEx {
15263     fn eq(&self, other: &Self) -> bool {
15264         self.dwVersion == other.dwVersion && self.dwProtocol == other.dwProtocol && self.szCipher == other.szCipher && self.dwCipherStrength == other.dwCipherStrength && self.szHash == other.szHash && self.dwHashStrength == other.dwHashStrength && self.szExchange == other.szExchange && self.dwExchStrength == other.dwExchStrength
15265     }
15266 }
15267 impl ::std::cmp::Eq for SecPkgContext_ConnectionInfoEx {}
15268 unsafe impl ::windows::runtime::Abi for SecPkgContext_ConnectionInfoEx {
15269     type Abi = Self;
15270     type DefaultType = Self;
15271 }
15272 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15273 #[repr(C)]
15274 pub struct SecPkgContext_CredInfo {
15275     pub CredClass: SECPKG_CRED_CLASS,
15276     pub IsPromptingNeeded: u32,
15277 }
15278 impl SecPkgContext_CredInfo {}
15279 impl ::std::default::Default for SecPkgContext_CredInfo {
15280     fn default() -> Self {
15281         unsafe { ::std::mem::zeroed() }
15282     }
15283 }
15284 impl ::std::fmt::Debug for SecPkgContext_CredInfo {
15285     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15286         fmt.debug_struct("SecPkgContext_CredInfo").field("CredClass", &self.CredClass).field("IsPromptingNeeded", &self.IsPromptingNeeded).finish()
15287     }
15288 }
15289 impl ::std::cmp::PartialEq for SecPkgContext_CredInfo {
15290     fn eq(&self, other: &Self) -> bool {
15291         self.CredClass == other.CredClass && self.IsPromptingNeeded == other.IsPromptingNeeded
15292     }
15293 }
15294 impl ::std::cmp::Eq for SecPkgContext_CredInfo {}
15295 unsafe impl ::windows::runtime::Abi for SecPkgContext_CredInfo {
15296     type Abi = Self;
15297     type DefaultType = Self;
15298 }
15299 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15300 #[repr(C)]
15301 pub struct SecPkgContext_CredentialNameA {
15302     pub CredentialType: u32,
15303     pub sCredentialName: *mut i8,
15304 }
15305 impl SecPkgContext_CredentialNameA {}
15306 impl ::std::default::Default for SecPkgContext_CredentialNameA {
15307     fn default() -> Self {
15308         unsafe { ::std::mem::zeroed() }
15309     }
15310 }
15311 impl ::std::fmt::Debug for SecPkgContext_CredentialNameA {
15312     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15313         fmt.debug_struct("SecPkgContext_CredentialNameA").field("CredentialType", &self.CredentialType).field("sCredentialName", &self.sCredentialName).finish()
15314     }
15315 }
15316 impl ::std::cmp::PartialEq for SecPkgContext_CredentialNameA {
15317     fn eq(&self, other: &Self) -> bool {
15318         self.CredentialType == other.CredentialType && self.sCredentialName == other.sCredentialName
15319     }
15320 }
15321 impl ::std::cmp::Eq for SecPkgContext_CredentialNameA {}
15322 unsafe impl ::windows::runtime::Abi for SecPkgContext_CredentialNameA {
15323     type Abi = Self;
15324     type DefaultType = Self;
15325 }
15326 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15327 #[repr(C)]
15328 pub struct SecPkgContext_CredentialNameW {
15329     pub CredentialType: u32,
15330     pub sCredentialName: *mut u16,
15331 }
15332 impl SecPkgContext_CredentialNameW {}
15333 impl ::std::default::Default for SecPkgContext_CredentialNameW {
15334     fn default() -> Self {
15335         unsafe { ::std::mem::zeroed() }
15336     }
15337 }
15338 impl ::std::fmt::Debug for SecPkgContext_CredentialNameW {
15339     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15340         fmt.debug_struct("SecPkgContext_CredentialNameW").field("CredentialType", &self.CredentialType).field("sCredentialName", &self.sCredentialName).finish()
15341     }
15342 }
15343 impl ::std::cmp::PartialEq for SecPkgContext_CredentialNameW {
15344     fn eq(&self, other: &Self) -> bool {
15345         self.CredentialType == other.CredentialType && self.sCredentialName == other.sCredentialName
15346     }
15347 }
15348 impl ::std::cmp::Eq for SecPkgContext_CredentialNameW {}
15349 unsafe impl ::windows::runtime::Abi for SecPkgContext_CredentialNameW {
15350     type Abi = Self;
15351     type DefaultType = Self;
15352 }
15353 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15354 #[repr(C)]
15355 pub struct SecPkgContext_DceInfo {
15356     pub AuthzSvc: u32,
15357     pub pPac: *mut ::std::ffi::c_void,
15358 }
15359 impl SecPkgContext_DceInfo {}
15360 impl ::std::default::Default for SecPkgContext_DceInfo {
15361     fn default() -> Self {
15362         unsafe { ::std::mem::zeroed() }
15363     }
15364 }
15365 impl ::std::fmt::Debug for SecPkgContext_DceInfo {
15366     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15367         fmt.debug_struct("SecPkgContext_DceInfo").field("AuthzSvc", &self.AuthzSvc).field("pPac", &self.pPac).finish()
15368     }
15369 }
15370 impl ::std::cmp::PartialEq for SecPkgContext_DceInfo {
15371     fn eq(&self, other: &Self) -> bool {
15372         self.AuthzSvc == other.AuthzSvc && self.pPac == other.pPac
15373     }
15374 }
15375 impl ::std::cmp::Eq for SecPkgContext_DceInfo {}
15376 unsafe impl ::windows::runtime::Abi for SecPkgContext_DceInfo {
15377     type Abi = Self;
15378     type DefaultType = Self;
15379 }
15380 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15381 #[repr(C)]
15382 pub struct SecPkgContext_EapKeyBlock {
15383     pub rgbKeys: [u8; 128],
15384     pub rgbIVs: [u8; 64],
15385 }
15386 impl SecPkgContext_EapKeyBlock {}
15387 impl ::std::default::Default for SecPkgContext_EapKeyBlock {
15388     fn default() -> Self {
15389         unsafe { ::std::mem::zeroed() }
15390     }
15391 }
15392 impl ::std::fmt::Debug for SecPkgContext_EapKeyBlock {
15393     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15394         fmt.debug_struct("SecPkgContext_EapKeyBlock").field("rgbKeys", &self.rgbKeys).field("rgbIVs", &self.rgbIVs).finish()
15395     }
15396 }
15397 impl ::std::cmp::PartialEq for SecPkgContext_EapKeyBlock {
15398     fn eq(&self, other: &Self) -> bool {
15399         self.rgbKeys == other.rgbKeys && self.rgbIVs == other.rgbIVs
15400     }
15401 }
15402 impl ::std::cmp::Eq for SecPkgContext_EapKeyBlock {}
15403 unsafe impl ::windows::runtime::Abi for SecPkgContext_EapKeyBlock {
15404     type Abi = Self;
15405     type DefaultType = Self;
15406 }
15407 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15408 #[repr(C)]
15409 pub struct SecPkgContext_EapPrfInfo {
15410     pub dwVersion: u32,
15411     pub cbPrfData: u32,
15412     pub pbPrfData: *mut u8,
15413 }
15414 impl SecPkgContext_EapPrfInfo {}
15415 impl ::std::default::Default for SecPkgContext_EapPrfInfo {
15416     fn default() -> Self {
15417         unsafe { ::std::mem::zeroed() }
15418     }
15419 }
15420 impl ::std::fmt::Debug for SecPkgContext_EapPrfInfo {
15421     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15422         fmt.debug_struct("SecPkgContext_EapPrfInfo").field("dwVersion", &self.dwVersion).field("cbPrfData", &self.cbPrfData).field("pbPrfData", &self.pbPrfData).finish()
15423     }
15424 }
15425 impl ::std::cmp::PartialEq for SecPkgContext_EapPrfInfo {
15426     fn eq(&self, other: &Self) -> bool {
15427         self.dwVersion == other.dwVersion && self.cbPrfData == other.cbPrfData && self.pbPrfData == other.pbPrfData
15428     }
15429 }
15430 impl ::std::cmp::Eq for SecPkgContext_EapPrfInfo {}
15431 unsafe impl ::windows::runtime::Abi for SecPkgContext_EapPrfInfo {
15432     type Abi = Self;
15433     type DefaultType = Self;
15434 }
15435 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15436 #[repr(C)]
15437 pub struct SecPkgContext_EarlyStart {
15438     pub dwEarlyStartFlags: u32,
15439 }
15440 impl SecPkgContext_EarlyStart {}
15441 impl ::std::default::Default for SecPkgContext_EarlyStart {
15442     fn default() -> Self {
15443         unsafe { ::std::mem::zeroed() }
15444     }
15445 }
15446 impl ::std::fmt::Debug for SecPkgContext_EarlyStart {
15447     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15448         fmt.debug_struct("SecPkgContext_EarlyStart").field("dwEarlyStartFlags", &self.dwEarlyStartFlags).finish()
15449     }
15450 }
15451 impl ::std::cmp::PartialEq for SecPkgContext_EarlyStart {
15452     fn eq(&self, other: &Self) -> bool {
15453         self.dwEarlyStartFlags == other.dwEarlyStartFlags
15454     }
15455 }
15456 impl ::std::cmp::Eq for SecPkgContext_EarlyStart {}
15457 unsafe impl ::windows::runtime::Abi for SecPkgContext_EarlyStart {
15458     type Abi = Self;
15459     type DefaultType = Self;
15460 }
15461 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15462 #[repr(C)]
15463 pub struct SecPkgContext_Flags {
15464     pub Flags: u32,
15465 }
15466 impl SecPkgContext_Flags {}
15467 impl ::std::default::Default for SecPkgContext_Flags {
15468     fn default() -> Self {
15469         unsafe { ::std::mem::zeroed() }
15470     }
15471 }
15472 impl ::std::fmt::Debug for SecPkgContext_Flags {
15473     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15474         fmt.debug_struct("SecPkgContext_Flags").field("Flags", &self.Flags).finish()
15475     }
15476 }
15477 impl ::std::cmp::PartialEq for SecPkgContext_Flags {
15478     fn eq(&self, other: &Self) -> bool {
15479         self.Flags == other.Flags
15480     }
15481 }
15482 impl ::std::cmp::Eq for SecPkgContext_Flags {}
15483 unsafe impl ::windows::runtime::Abi for SecPkgContext_Flags {
15484     type Abi = Self;
15485     type DefaultType = Self;
15486 }
15487 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15488 #[repr(C)]
15489 #[cfg(feature = "Win32_Security_Cryptography")]
15490 pub struct SecPkgContext_IssuerListInfoEx {
15491     pub aIssuers: *mut super::super::Cryptography::CRYPTOAPI_BLOB,
15492     pub cIssuers: u32,
15493 }
15494 #[cfg(feature = "Win32_Security_Cryptography")]
15495 impl SecPkgContext_IssuerListInfoEx {}
15496 #[cfg(feature = "Win32_Security_Cryptography")]
15497 impl ::std::default::Default for SecPkgContext_IssuerListInfoEx {
15498     fn default() -> Self {
15499         unsafe { ::std::mem::zeroed() }
15500     }
15501 }
15502 #[cfg(feature = "Win32_Security_Cryptography")]
15503 impl ::std::fmt::Debug for SecPkgContext_IssuerListInfoEx {
15504     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15505         fmt.debug_struct("SecPkgContext_IssuerListInfoEx").field("aIssuers", &self.aIssuers).field("cIssuers", &self.cIssuers).finish()
15506     }
15507 }
15508 #[cfg(feature = "Win32_Security_Cryptography")]
15509 impl ::std::cmp::PartialEq for SecPkgContext_IssuerListInfoEx {
15510     fn eq(&self, other: &Self) -> bool {
15511         self.aIssuers == other.aIssuers && self.cIssuers == other.cIssuers
15512     }
15513 }
15514 #[cfg(feature = "Win32_Security_Cryptography")]
15515 impl ::std::cmp::Eq for SecPkgContext_IssuerListInfoEx {}
15516 #[cfg(feature = "Win32_Security_Cryptography")]
15517 unsafe impl ::windows::runtime::Abi for SecPkgContext_IssuerListInfoEx {
15518     type Abi = Self;
15519     type DefaultType = Self;
15520 }
15521 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15522 #[repr(C)]
15523 pub struct SecPkgContext_KeyInfoA {
15524     pub sSignatureAlgorithmName: *mut i8,
15525     pub sEncryptAlgorithmName: *mut i8,
15526     pub KeySize: u32,
15527     pub SignatureAlgorithm: u32,
15528     pub EncryptAlgorithm: u32,
15529 }
15530 impl SecPkgContext_KeyInfoA {}
15531 impl ::std::default::Default for SecPkgContext_KeyInfoA {
15532     fn default() -> Self {
15533         unsafe { ::std::mem::zeroed() }
15534     }
15535 }
15536 impl ::std::fmt::Debug for SecPkgContext_KeyInfoA {
15537     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15538         fmt.debug_struct("SecPkgContext_KeyInfoA")
15539             .field("sSignatureAlgorithmName", &self.sSignatureAlgorithmName)
15540             .field("sEncryptAlgorithmName", &self.sEncryptAlgorithmName)
15541             .field("KeySize", &self.KeySize)
15542             .field("SignatureAlgorithm", &self.SignatureAlgorithm)
15543             .field("EncryptAlgorithm", &self.EncryptAlgorithm)
15544             .finish()
15545     }
15546 }
15547 impl ::std::cmp::PartialEq for SecPkgContext_KeyInfoA {
15548     fn eq(&self, other: &Self) -> bool {
15549         self.sSignatureAlgorithmName == other.sSignatureAlgorithmName && self.sEncryptAlgorithmName == other.sEncryptAlgorithmName && self.KeySize == other.KeySize && self.SignatureAlgorithm == other.SignatureAlgorithm && self.EncryptAlgorithm == other.EncryptAlgorithm
15550     }
15551 }
15552 impl ::std::cmp::Eq for SecPkgContext_KeyInfoA {}
15553 unsafe impl ::windows::runtime::Abi for SecPkgContext_KeyInfoA {
15554     type Abi = Self;
15555     type DefaultType = Self;
15556 }
15557 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15558 #[repr(C)]
15559 pub struct SecPkgContext_KeyInfoW {
15560     pub sSignatureAlgorithmName: *mut u16,
15561     pub sEncryptAlgorithmName: *mut u16,
15562     pub KeySize: u32,
15563     pub SignatureAlgorithm: u32,
15564     pub EncryptAlgorithm: u32,
15565 }
15566 impl SecPkgContext_KeyInfoW {}
15567 impl ::std::default::Default for SecPkgContext_KeyInfoW {
15568     fn default() -> Self {
15569         unsafe { ::std::mem::zeroed() }
15570     }
15571 }
15572 impl ::std::fmt::Debug for SecPkgContext_KeyInfoW {
15573     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15574         fmt.debug_struct("SecPkgContext_KeyInfoW")
15575             .field("sSignatureAlgorithmName", &self.sSignatureAlgorithmName)
15576             .field("sEncryptAlgorithmName", &self.sEncryptAlgorithmName)
15577             .field("KeySize", &self.KeySize)
15578             .field("SignatureAlgorithm", &self.SignatureAlgorithm)
15579             .field("EncryptAlgorithm", &self.EncryptAlgorithm)
15580             .finish()
15581     }
15582 }
15583 impl ::std::cmp::PartialEq for SecPkgContext_KeyInfoW {
15584     fn eq(&self, other: &Self) -> bool {
15585         self.sSignatureAlgorithmName == other.sSignatureAlgorithmName && self.sEncryptAlgorithmName == other.sEncryptAlgorithmName && self.KeySize == other.KeySize && self.SignatureAlgorithm == other.SignatureAlgorithm && self.EncryptAlgorithm == other.EncryptAlgorithm
15586     }
15587 }
15588 impl ::std::cmp::Eq for SecPkgContext_KeyInfoW {}
15589 unsafe impl ::windows::runtime::Abi for SecPkgContext_KeyInfoW {
15590     type Abi = Self;
15591     type DefaultType = Self;
15592 }
15593 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15594 #[repr(C)]
15595 pub struct SecPkgContext_KeyingMaterial {
15596     pub cbKeyingMaterial: u32,
15597     pub pbKeyingMaterial: *mut u8,
15598 }
15599 impl SecPkgContext_KeyingMaterial {}
15600 impl ::std::default::Default for SecPkgContext_KeyingMaterial {
15601     fn default() -> Self {
15602         unsafe { ::std::mem::zeroed() }
15603     }
15604 }
15605 impl ::std::fmt::Debug for SecPkgContext_KeyingMaterial {
15606     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15607         fmt.debug_struct("SecPkgContext_KeyingMaterial").field("cbKeyingMaterial", &self.cbKeyingMaterial).field("pbKeyingMaterial", &self.pbKeyingMaterial).finish()
15608     }
15609 }
15610 impl ::std::cmp::PartialEq for SecPkgContext_KeyingMaterial {
15611     fn eq(&self, other: &Self) -> bool {
15612         self.cbKeyingMaterial == other.cbKeyingMaterial && self.pbKeyingMaterial == other.pbKeyingMaterial
15613     }
15614 }
15615 impl ::std::cmp::Eq for SecPkgContext_KeyingMaterial {}
15616 unsafe impl ::windows::runtime::Abi for SecPkgContext_KeyingMaterial {
15617     type Abi = Self;
15618     type DefaultType = Self;
15619 }
15620 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15621 #[repr(C)]
15622 #[cfg(feature = "Win32_Foundation")]
15623 pub struct SecPkgContext_KeyingMaterialInfo {
15624     pub cbLabel: u16,
15625     pub pszLabel: super::super::super::Foundation::PSTR,
15626     pub cbContextValue: u16,
15627     pub pbContextValue: *mut u8,
15628     pub cbKeyingMaterial: u32,
15629 }
15630 #[cfg(feature = "Win32_Foundation")]
15631 impl SecPkgContext_KeyingMaterialInfo {}
15632 #[cfg(feature = "Win32_Foundation")]
15633 impl ::std::default::Default for SecPkgContext_KeyingMaterialInfo {
15634     fn default() -> Self {
15635         unsafe { ::std::mem::zeroed() }
15636     }
15637 }
15638 #[cfg(feature = "Win32_Foundation")]
15639 impl ::std::fmt::Debug for SecPkgContext_KeyingMaterialInfo {
15640     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15641         fmt.debug_struct("SecPkgContext_KeyingMaterialInfo").field("cbLabel", &self.cbLabel).field("pszLabel", &self.pszLabel).field("cbContextValue", &self.cbContextValue).field("pbContextValue", &self.pbContextValue).field("cbKeyingMaterial", &self.cbKeyingMaterial).finish()
15642     }
15643 }
15644 #[cfg(feature = "Win32_Foundation")]
15645 impl ::std::cmp::PartialEq for SecPkgContext_KeyingMaterialInfo {
15646     fn eq(&self, other: &Self) -> bool {
15647         self.cbLabel == other.cbLabel && self.pszLabel == other.pszLabel && self.cbContextValue == other.cbContextValue && self.pbContextValue == other.pbContextValue && self.cbKeyingMaterial == other.cbKeyingMaterial
15648     }
15649 }
15650 #[cfg(feature = "Win32_Foundation")]
15651 impl ::std::cmp::Eq for SecPkgContext_KeyingMaterialInfo {}
15652 #[cfg(feature = "Win32_Foundation")]
15653 unsafe impl ::windows::runtime::Abi for SecPkgContext_KeyingMaterialInfo {
15654     type Abi = Self;
15655     type DefaultType = Self;
15656 }
15657 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15658 #[repr(C)]
15659 #[cfg(feature = "Win32_Foundation")]
15660 pub struct SecPkgContext_KeyingMaterial_Inproc {
15661     pub cbLabel: u16,
15662     pub pszLabel: super::super::super::Foundation::PSTR,
15663     pub cbContextValue: u16,
15664     pub pbContextValue: *mut u8,
15665     pub cbKeyingMaterial: u32,
15666     pub pbKeyingMaterial: *mut u8,
15667 }
15668 #[cfg(feature = "Win32_Foundation")]
15669 impl SecPkgContext_KeyingMaterial_Inproc {}
15670 #[cfg(feature = "Win32_Foundation")]
15671 impl ::std::default::Default for SecPkgContext_KeyingMaterial_Inproc {
15672     fn default() -> Self {
15673         unsafe { ::std::mem::zeroed() }
15674     }
15675 }
15676 #[cfg(feature = "Win32_Foundation")]
15677 impl ::std::fmt::Debug for SecPkgContext_KeyingMaterial_Inproc {
15678     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15679         fmt.debug_struct("SecPkgContext_KeyingMaterial_Inproc")
15680             .field("cbLabel", &self.cbLabel)
15681             .field("pszLabel", &self.pszLabel)
15682             .field("cbContextValue", &self.cbContextValue)
15683             .field("pbContextValue", &self.pbContextValue)
15684             .field("cbKeyingMaterial", &self.cbKeyingMaterial)
15685             .field("pbKeyingMaterial", &self.pbKeyingMaterial)
15686             .finish()
15687     }
15688 }
15689 #[cfg(feature = "Win32_Foundation")]
15690 impl ::std::cmp::PartialEq for SecPkgContext_KeyingMaterial_Inproc {
15691     fn eq(&self, other: &Self) -> bool {
15692         self.cbLabel == other.cbLabel && self.pszLabel == other.pszLabel && self.cbContextValue == other.cbContextValue && self.pbContextValue == other.pbContextValue && self.cbKeyingMaterial == other.cbKeyingMaterial && self.pbKeyingMaterial == other.pbKeyingMaterial
15693     }
15694 }
15695 #[cfg(feature = "Win32_Foundation")]
15696 impl ::std::cmp::Eq for SecPkgContext_KeyingMaterial_Inproc {}
15697 #[cfg(feature = "Win32_Foundation")]
15698 unsafe impl ::windows::runtime::Abi for SecPkgContext_KeyingMaterial_Inproc {
15699     type Abi = Self;
15700     type DefaultType = Self;
15701 }
15702 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15703 #[repr(C)]
15704 pub struct SecPkgContext_LastClientTokenStatus {
15705     pub LastClientTokenStatus: SECPKG_ATTR_LCT_STATUS,
15706 }
15707 impl SecPkgContext_LastClientTokenStatus {}
15708 impl ::std::default::Default for SecPkgContext_LastClientTokenStatus {
15709     fn default() -> Self {
15710         unsafe { ::std::mem::zeroed() }
15711     }
15712 }
15713 impl ::std::fmt::Debug for SecPkgContext_LastClientTokenStatus {
15714     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15715         fmt.debug_struct("SecPkgContext_LastClientTokenStatus").field("LastClientTokenStatus", &self.LastClientTokenStatus).finish()
15716     }
15717 }
15718 impl ::std::cmp::PartialEq for SecPkgContext_LastClientTokenStatus {
15719     fn eq(&self, other: &Self) -> bool {
15720         self.LastClientTokenStatus == other.LastClientTokenStatus
15721     }
15722 }
15723 impl ::std::cmp::Eq for SecPkgContext_LastClientTokenStatus {}
15724 unsafe impl ::windows::runtime::Abi for SecPkgContext_LastClientTokenStatus {
15725     type Abi = Self;
15726     type DefaultType = Self;
15727 }
15728 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15729 #[repr(C)]
15730 pub struct SecPkgContext_Lifespan {
15731     pub tsStart: i64,
15732     pub tsExpiry: i64,
15733 }
15734 impl SecPkgContext_Lifespan {}
15735 impl ::std::default::Default for SecPkgContext_Lifespan {
15736     fn default() -> Self {
15737         unsafe { ::std::mem::zeroed() }
15738     }
15739 }
15740 impl ::std::fmt::Debug for SecPkgContext_Lifespan {
15741     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15742         fmt.debug_struct("SecPkgContext_Lifespan").field("tsStart", &self.tsStart).field("tsExpiry", &self.tsExpiry).finish()
15743     }
15744 }
15745 impl ::std::cmp::PartialEq for SecPkgContext_Lifespan {
15746     fn eq(&self, other: &Self) -> bool {
15747         self.tsStart == other.tsStart && self.tsExpiry == other.tsExpiry
15748     }
15749 }
15750 impl ::std::cmp::Eq for SecPkgContext_Lifespan {}
15751 unsafe impl ::windows::runtime::Abi for SecPkgContext_Lifespan {
15752     type Abi = Self;
15753     type DefaultType = Self;
15754 }
15755 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15756 #[repr(C)]
15757 pub struct SecPkgContext_LocalCredentialInfo {
15758     pub cbCertificateChain: u32,
15759     pub pbCertificateChain: *mut u8,
15760     pub cCertificates: u32,
15761     pub fFlags: u32,
15762     pub dwBits: u32,
15763 }
15764 impl SecPkgContext_LocalCredentialInfo {}
15765 impl ::std::default::Default for SecPkgContext_LocalCredentialInfo {
15766     fn default() -> Self {
15767         unsafe { ::std::mem::zeroed() }
15768     }
15769 }
15770 impl ::std::fmt::Debug for SecPkgContext_LocalCredentialInfo {
15771     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15772         fmt.debug_struct("SecPkgContext_LocalCredentialInfo").field("cbCertificateChain", &self.cbCertificateChain).field("pbCertificateChain", &self.pbCertificateChain).field("cCertificates", &self.cCertificates).field("fFlags", &self.fFlags).field("dwBits", &self.dwBits).finish()
15773     }
15774 }
15775 impl ::std::cmp::PartialEq for SecPkgContext_LocalCredentialInfo {
15776     fn eq(&self, other: &Self) -> bool {
15777         self.cbCertificateChain == other.cbCertificateChain && self.pbCertificateChain == other.pbCertificateChain && self.cCertificates == other.cCertificates && self.fFlags == other.fFlags && self.dwBits == other.dwBits
15778     }
15779 }
15780 impl ::std::cmp::Eq for SecPkgContext_LocalCredentialInfo {}
15781 unsafe impl ::windows::runtime::Abi for SecPkgContext_LocalCredentialInfo {
15782     type Abi = Self;
15783     type DefaultType = Self;
15784 }
15785 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15786 #[repr(C)]
15787 pub struct SecPkgContext_LogoffTime {
15788     pub tsLogoffTime: i64,
15789 }
15790 impl SecPkgContext_LogoffTime {}
15791 impl ::std::default::Default for SecPkgContext_LogoffTime {
15792     fn default() -> Self {
15793         unsafe { ::std::mem::zeroed() }
15794     }
15795 }
15796 impl ::std::fmt::Debug for SecPkgContext_LogoffTime {
15797     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15798         fmt.debug_struct("SecPkgContext_LogoffTime").field("tsLogoffTime", &self.tsLogoffTime).finish()
15799     }
15800 }
15801 impl ::std::cmp::PartialEq for SecPkgContext_LogoffTime {
15802     fn eq(&self, other: &Self) -> bool {
15803         self.tsLogoffTime == other.tsLogoffTime
15804     }
15805 }
15806 impl ::std::cmp::Eq for SecPkgContext_LogoffTime {}
15807 unsafe impl ::windows::runtime::Abi for SecPkgContext_LogoffTime {
15808     type Abi = Self;
15809     type DefaultType = Self;
15810 }
15811 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15812 #[repr(C)]
15813 pub struct SecPkgContext_MappedCredAttr {
15814     pub dwAttribute: u32,
15815     pub pvBuffer: *mut ::std::ffi::c_void,
15816 }
15817 impl SecPkgContext_MappedCredAttr {}
15818 impl ::std::default::Default for SecPkgContext_MappedCredAttr {
15819     fn default() -> Self {
15820         unsafe { ::std::mem::zeroed() }
15821     }
15822 }
15823 impl ::std::fmt::Debug for SecPkgContext_MappedCredAttr {
15824     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15825         fmt.debug_struct("SecPkgContext_MappedCredAttr").field("dwAttribute", &self.dwAttribute).field("pvBuffer", &self.pvBuffer).finish()
15826     }
15827 }
15828 impl ::std::cmp::PartialEq for SecPkgContext_MappedCredAttr {
15829     fn eq(&self, other: &Self) -> bool {
15830         self.dwAttribute == other.dwAttribute && self.pvBuffer == other.pvBuffer
15831     }
15832 }
15833 impl ::std::cmp::Eq for SecPkgContext_MappedCredAttr {}
15834 unsafe impl ::windows::runtime::Abi for SecPkgContext_MappedCredAttr {
15835     type Abi = Self;
15836     type DefaultType = Self;
15837 }
15838 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15839 #[repr(C)]
15840 pub struct SecPkgContext_NamesA {
15841     pub sUserName: *mut i8,
15842 }
15843 impl SecPkgContext_NamesA {}
15844 impl ::std::default::Default for SecPkgContext_NamesA {
15845     fn default() -> Self {
15846         unsafe { ::std::mem::zeroed() }
15847     }
15848 }
15849 impl ::std::fmt::Debug for SecPkgContext_NamesA {
15850     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15851         fmt.debug_struct("SecPkgContext_NamesA").field("sUserName", &self.sUserName).finish()
15852     }
15853 }
15854 impl ::std::cmp::PartialEq for SecPkgContext_NamesA {
15855     fn eq(&self, other: &Self) -> bool {
15856         self.sUserName == other.sUserName
15857     }
15858 }
15859 impl ::std::cmp::Eq for SecPkgContext_NamesA {}
15860 unsafe impl ::windows::runtime::Abi for SecPkgContext_NamesA {
15861     type Abi = Self;
15862     type DefaultType = Self;
15863 }
15864 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15865 #[repr(C)]
15866 pub struct SecPkgContext_NamesW {
15867     pub sUserName: *mut u16,
15868 }
15869 impl SecPkgContext_NamesW {}
15870 impl ::std::default::Default for SecPkgContext_NamesW {
15871     fn default() -> Self {
15872         unsafe { ::std::mem::zeroed() }
15873     }
15874 }
15875 impl ::std::fmt::Debug for SecPkgContext_NamesW {
15876     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15877         fmt.debug_struct("SecPkgContext_NamesW").field("sUserName", &self.sUserName).finish()
15878     }
15879 }
15880 impl ::std::cmp::PartialEq for SecPkgContext_NamesW {
15881     fn eq(&self, other: &Self) -> bool {
15882         self.sUserName == other.sUserName
15883     }
15884 }
15885 impl ::std::cmp::Eq for SecPkgContext_NamesW {}
15886 unsafe impl ::windows::runtime::Abi for SecPkgContext_NamesW {
15887     type Abi = Self;
15888     type DefaultType = Self;
15889 }
15890 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15891 #[repr(C)]
15892 pub struct SecPkgContext_NativeNamesA {
15893     pub sClientName: *mut i8,
15894     pub sServerName: *mut i8,
15895 }
15896 impl SecPkgContext_NativeNamesA {}
15897 impl ::std::default::Default for SecPkgContext_NativeNamesA {
15898     fn default() -> Self {
15899         unsafe { ::std::mem::zeroed() }
15900     }
15901 }
15902 impl ::std::fmt::Debug for SecPkgContext_NativeNamesA {
15903     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15904         fmt.debug_struct("SecPkgContext_NativeNamesA").field("sClientName", &self.sClientName).field("sServerName", &self.sServerName).finish()
15905     }
15906 }
15907 impl ::std::cmp::PartialEq for SecPkgContext_NativeNamesA {
15908     fn eq(&self, other: &Self) -> bool {
15909         self.sClientName == other.sClientName && self.sServerName == other.sServerName
15910     }
15911 }
15912 impl ::std::cmp::Eq for SecPkgContext_NativeNamesA {}
15913 unsafe impl ::windows::runtime::Abi for SecPkgContext_NativeNamesA {
15914     type Abi = Self;
15915     type DefaultType = Self;
15916 }
15917 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15918 #[repr(C)]
15919 pub struct SecPkgContext_NativeNamesW {
15920     pub sClientName: *mut u16,
15921     pub sServerName: *mut u16,
15922 }
15923 impl SecPkgContext_NativeNamesW {}
15924 impl ::std::default::Default for SecPkgContext_NativeNamesW {
15925     fn default() -> Self {
15926         unsafe { ::std::mem::zeroed() }
15927     }
15928 }
15929 impl ::std::fmt::Debug for SecPkgContext_NativeNamesW {
15930     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15931         fmt.debug_struct("SecPkgContext_NativeNamesW").field("sClientName", &self.sClientName).field("sServerName", &self.sServerName).finish()
15932     }
15933 }
15934 impl ::std::cmp::PartialEq for SecPkgContext_NativeNamesW {
15935     fn eq(&self, other: &Self) -> bool {
15936         self.sClientName == other.sClientName && self.sServerName == other.sServerName
15937     }
15938 }
15939 impl ::std::cmp::Eq for SecPkgContext_NativeNamesW {}
15940 unsafe impl ::windows::runtime::Abi for SecPkgContext_NativeNamesW {
15941     type Abi = Self;
15942     type DefaultType = Self;
15943 }
15944 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15945 #[repr(C)]
15946 pub struct SecPkgContext_NegoKeys {
15947     pub KeyType: u32,
15948     pub KeyLength: u16,
15949     pub KeyValue: *mut u8,
15950     pub VerifyKeyType: u32,
15951     pub VerifyKeyLength: u16,
15952     pub VerifyKeyValue: *mut u8,
15953 }
15954 impl SecPkgContext_NegoKeys {}
15955 impl ::std::default::Default for SecPkgContext_NegoKeys {
15956     fn default() -> Self {
15957         unsafe { ::std::mem::zeroed() }
15958     }
15959 }
15960 impl ::std::fmt::Debug for SecPkgContext_NegoKeys {
15961     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15962         fmt.debug_struct("SecPkgContext_NegoKeys").field("KeyType", &self.KeyType).field("KeyLength", &self.KeyLength).field("KeyValue", &self.KeyValue).field("VerifyKeyType", &self.VerifyKeyType).field("VerifyKeyLength", &self.VerifyKeyLength).field("VerifyKeyValue", &self.VerifyKeyValue).finish()
15963     }
15964 }
15965 impl ::std::cmp::PartialEq for SecPkgContext_NegoKeys {
15966     fn eq(&self, other: &Self) -> bool {
15967         self.KeyType == other.KeyType && self.KeyLength == other.KeyLength && self.KeyValue == other.KeyValue && self.VerifyKeyType == other.VerifyKeyType && self.VerifyKeyLength == other.VerifyKeyLength && self.VerifyKeyValue == other.VerifyKeyValue
15968     }
15969 }
15970 impl ::std::cmp::Eq for SecPkgContext_NegoKeys {}
15971 unsafe impl ::windows::runtime::Abi for SecPkgContext_NegoKeys {
15972     type Abi = Self;
15973     type DefaultType = Self;
15974 }
15975 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
15976 #[repr(C)]
15977 pub struct SecPkgContext_NegoPackageInfo {
15978     pub PackageMask: u32,
15979 }
15980 impl SecPkgContext_NegoPackageInfo {}
15981 impl ::std::default::Default for SecPkgContext_NegoPackageInfo {
15982     fn default() -> Self {
15983         unsafe { ::std::mem::zeroed() }
15984     }
15985 }
15986 impl ::std::fmt::Debug for SecPkgContext_NegoPackageInfo {
15987     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
15988         fmt.debug_struct("SecPkgContext_NegoPackageInfo").field("PackageMask", &self.PackageMask).finish()
15989     }
15990 }
15991 impl ::std::cmp::PartialEq for SecPkgContext_NegoPackageInfo {
15992     fn eq(&self, other: &Self) -> bool {
15993         self.PackageMask == other.PackageMask
15994     }
15995 }
15996 impl ::std::cmp::Eq for SecPkgContext_NegoPackageInfo {}
15997 unsafe impl ::windows::runtime::Abi for SecPkgContext_NegoPackageInfo {
15998     type Abi = Self;
15999     type DefaultType = Self;
16000 }
16001 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16002 #[repr(C)]
16003 pub struct SecPkgContext_NegoStatus {
16004     pub LastStatus: u32,
16005 }
16006 impl SecPkgContext_NegoStatus {}
16007 impl ::std::default::Default for SecPkgContext_NegoStatus {
16008     fn default() -> Self {
16009         unsafe { ::std::mem::zeroed() }
16010     }
16011 }
16012 impl ::std::fmt::Debug for SecPkgContext_NegoStatus {
16013     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16014         fmt.debug_struct("SecPkgContext_NegoStatus").field("LastStatus", &self.LastStatus).finish()
16015     }
16016 }
16017 impl ::std::cmp::PartialEq for SecPkgContext_NegoStatus {
16018     fn eq(&self, other: &Self) -> bool {
16019         self.LastStatus == other.LastStatus
16020     }
16021 }
16022 impl ::std::cmp::Eq for SecPkgContext_NegoStatus {}
16023 unsafe impl ::windows::runtime::Abi for SecPkgContext_NegoStatus {
16024     type Abi = Self;
16025     type DefaultType = Self;
16026 }
16027 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16028 #[repr(C)]
16029 pub struct SecPkgContext_NegotiatedTlsExtensions {
16030     pub ExtensionsCount: u32,
16031     pub Extensions: *mut u16,
16032 }
16033 impl SecPkgContext_NegotiatedTlsExtensions {}
16034 impl ::std::default::Default for SecPkgContext_NegotiatedTlsExtensions {
16035     fn default() -> Self {
16036         unsafe { ::std::mem::zeroed() }
16037     }
16038 }
16039 impl ::std::fmt::Debug for SecPkgContext_NegotiatedTlsExtensions {
16040     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16041         fmt.debug_struct("SecPkgContext_NegotiatedTlsExtensions").field("ExtensionsCount", &self.ExtensionsCount).field("Extensions", &self.Extensions).finish()
16042     }
16043 }
16044 impl ::std::cmp::PartialEq for SecPkgContext_NegotiatedTlsExtensions {
16045     fn eq(&self, other: &Self) -> bool {
16046         self.ExtensionsCount == other.ExtensionsCount && self.Extensions == other.Extensions
16047     }
16048 }
16049 impl ::std::cmp::Eq for SecPkgContext_NegotiatedTlsExtensions {}
16050 unsafe impl ::windows::runtime::Abi for SecPkgContext_NegotiatedTlsExtensions {
16051     type Abi = Self;
16052     type DefaultType = Self;
16053 }
16054 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16055 #[repr(C)]
16056 pub struct SecPkgContext_NegotiationInfoA {
16057     pub PackageInfo: *mut SecPkgInfoA,
16058     pub NegotiationState: u32,
16059 }
16060 impl SecPkgContext_NegotiationInfoA {}
16061 impl ::std::default::Default for SecPkgContext_NegotiationInfoA {
16062     fn default() -> Self {
16063         unsafe { ::std::mem::zeroed() }
16064     }
16065 }
16066 impl ::std::fmt::Debug for SecPkgContext_NegotiationInfoA {
16067     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16068         fmt.debug_struct("SecPkgContext_NegotiationInfoA").field("PackageInfo", &self.PackageInfo).field("NegotiationState", &self.NegotiationState).finish()
16069     }
16070 }
16071 impl ::std::cmp::PartialEq for SecPkgContext_NegotiationInfoA {
16072     fn eq(&self, other: &Self) -> bool {
16073         self.PackageInfo == other.PackageInfo && self.NegotiationState == other.NegotiationState
16074     }
16075 }
16076 impl ::std::cmp::Eq for SecPkgContext_NegotiationInfoA {}
16077 unsafe impl ::windows::runtime::Abi for SecPkgContext_NegotiationInfoA {
16078     type Abi = Self;
16079     type DefaultType = Self;
16080 }
16081 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16082 #[repr(C)]
16083 pub struct SecPkgContext_NegotiationInfoW {
16084     pub PackageInfo: *mut SecPkgInfoW,
16085     pub NegotiationState: u32,
16086 }
16087 impl SecPkgContext_NegotiationInfoW {}
16088 impl ::std::default::Default for SecPkgContext_NegotiationInfoW {
16089     fn default() -> Self {
16090         unsafe { ::std::mem::zeroed() }
16091     }
16092 }
16093 impl ::std::fmt::Debug for SecPkgContext_NegotiationInfoW {
16094     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16095         fmt.debug_struct("SecPkgContext_NegotiationInfoW").field("PackageInfo", &self.PackageInfo).field("NegotiationState", &self.NegotiationState).finish()
16096     }
16097 }
16098 impl ::std::cmp::PartialEq for SecPkgContext_NegotiationInfoW {
16099     fn eq(&self, other: &Self) -> bool {
16100         self.PackageInfo == other.PackageInfo && self.NegotiationState == other.NegotiationState
16101     }
16102 }
16103 impl ::std::cmp::Eq for SecPkgContext_NegotiationInfoW {}
16104 unsafe impl ::windows::runtime::Abi for SecPkgContext_NegotiationInfoW {
16105     type Abi = Self;
16106     type DefaultType = Self;
16107 }
16108 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16109 #[repr(C)]
16110 pub struct SecPkgContext_PackageInfoA {
16111     pub PackageInfo: *mut SecPkgInfoA,
16112 }
16113 impl SecPkgContext_PackageInfoA {}
16114 impl ::std::default::Default for SecPkgContext_PackageInfoA {
16115     fn default() -> Self {
16116         unsafe { ::std::mem::zeroed() }
16117     }
16118 }
16119 impl ::std::fmt::Debug for SecPkgContext_PackageInfoA {
16120     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16121         fmt.debug_struct("SecPkgContext_PackageInfoA").field("PackageInfo", &self.PackageInfo).finish()
16122     }
16123 }
16124 impl ::std::cmp::PartialEq for SecPkgContext_PackageInfoA {
16125     fn eq(&self, other: &Self) -> bool {
16126         self.PackageInfo == other.PackageInfo
16127     }
16128 }
16129 impl ::std::cmp::Eq for SecPkgContext_PackageInfoA {}
16130 unsafe impl ::windows::runtime::Abi for SecPkgContext_PackageInfoA {
16131     type Abi = Self;
16132     type DefaultType = Self;
16133 }
16134 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16135 #[repr(C)]
16136 pub struct SecPkgContext_PackageInfoW {
16137     pub PackageInfo: *mut SecPkgInfoW,
16138 }
16139 impl SecPkgContext_PackageInfoW {}
16140 impl ::std::default::Default for SecPkgContext_PackageInfoW {
16141     fn default() -> Self {
16142         unsafe { ::std::mem::zeroed() }
16143     }
16144 }
16145 impl ::std::fmt::Debug for SecPkgContext_PackageInfoW {
16146     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16147         fmt.debug_struct("SecPkgContext_PackageInfoW").field("PackageInfo", &self.PackageInfo).finish()
16148     }
16149 }
16150 impl ::std::cmp::PartialEq for SecPkgContext_PackageInfoW {
16151     fn eq(&self, other: &Self) -> bool {
16152         self.PackageInfo == other.PackageInfo
16153     }
16154 }
16155 impl ::std::cmp::Eq for SecPkgContext_PackageInfoW {}
16156 unsafe impl ::windows::runtime::Abi for SecPkgContext_PackageInfoW {
16157     type Abi = Self;
16158     type DefaultType = Self;
16159 }
16160 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16161 #[repr(C)]
16162 pub struct SecPkgContext_PasswordExpiry {
16163     pub tsPasswordExpires: i64,
16164 }
16165 impl SecPkgContext_PasswordExpiry {}
16166 impl ::std::default::Default for SecPkgContext_PasswordExpiry {
16167     fn default() -> Self {
16168         unsafe { ::std::mem::zeroed() }
16169     }
16170 }
16171 impl ::std::fmt::Debug for SecPkgContext_PasswordExpiry {
16172     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16173         fmt.debug_struct("SecPkgContext_PasswordExpiry").field("tsPasswordExpires", &self.tsPasswordExpires).finish()
16174     }
16175 }
16176 impl ::std::cmp::PartialEq for SecPkgContext_PasswordExpiry {
16177     fn eq(&self, other: &Self) -> bool {
16178         self.tsPasswordExpires == other.tsPasswordExpires
16179     }
16180 }
16181 impl ::std::cmp::Eq for SecPkgContext_PasswordExpiry {}
16182 unsafe impl ::windows::runtime::Abi for SecPkgContext_PasswordExpiry {
16183     type Abi = Self;
16184     type DefaultType = Self;
16185 }
16186 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16187 #[repr(C)]
16188 pub struct SecPkgContext_ProtoInfoA {
16189     pub sProtocolName: *mut i8,
16190     pub majorVersion: u32,
16191     pub minorVersion: u32,
16192 }
16193 impl SecPkgContext_ProtoInfoA {}
16194 impl ::std::default::Default for SecPkgContext_ProtoInfoA {
16195     fn default() -> Self {
16196         unsafe { ::std::mem::zeroed() }
16197     }
16198 }
16199 impl ::std::fmt::Debug for SecPkgContext_ProtoInfoA {
16200     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16201         fmt.debug_struct("SecPkgContext_ProtoInfoA").field("sProtocolName", &self.sProtocolName).field("majorVersion", &self.majorVersion).field("minorVersion", &self.minorVersion).finish()
16202     }
16203 }
16204 impl ::std::cmp::PartialEq for SecPkgContext_ProtoInfoA {
16205     fn eq(&self, other: &Self) -> bool {
16206         self.sProtocolName == other.sProtocolName && self.majorVersion == other.majorVersion && self.minorVersion == other.minorVersion
16207     }
16208 }
16209 impl ::std::cmp::Eq for SecPkgContext_ProtoInfoA {}
16210 unsafe impl ::windows::runtime::Abi for SecPkgContext_ProtoInfoA {
16211     type Abi = Self;
16212     type DefaultType = Self;
16213 }
16214 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16215 #[repr(C)]
16216 pub struct SecPkgContext_ProtoInfoW {
16217     pub sProtocolName: *mut u16,
16218     pub majorVersion: u32,
16219     pub minorVersion: u32,
16220 }
16221 impl SecPkgContext_ProtoInfoW {}
16222 impl ::std::default::Default for SecPkgContext_ProtoInfoW {
16223     fn default() -> Self {
16224         unsafe { ::std::mem::zeroed() }
16225     }
16226 }
16227 impl ::std::fmt::Debug for SecPkgContext_ProtoInfoW {
16228     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16229         fmt.debug_struct("SecPkgContext_ProtoInfoW").field("sProtocolName", &self.sProtocolName).field("majorVersion", &self.majorVersion).field("minorVersion", &self.minorVersion).finish()
16230     }
16231 }
16232 impl ::std::cmp::PartialEq for SecPkgContext_ProtoInfoW {
16233     fn eq(&self, other: &Self) -> bool {
16234         self.sProtocolName == other.sProtocolName && self.majorVersion == other.majorVersion && self.minorVersion == other.minorVersion
16235     }
16236 }
16237 impl ::std::cmp::Eq for SecPkgContext_ProtoInfoW {}
16238 unsafe impl ::windows::runtime::Abi for SecPkgContext_ProtoInfoW {
16239     type Abi = Self;
16240     type DefaultType = Self;
16241 }
16242 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16243 #[repr(C)]
16244 pub struct SecPkgContext_RemoteCredentialInfo {
16245     pub cbCertificateChain: u32,
16246     pub pbCertificateChain: *mut u8,
16247     pub cCertificates: u32,
16248     pub fFlags: u32,
16249     pub dwBits: u32,
16250 }
16251 impl SecPkgContext_RemoteCredentialInfo {}
16252 impl ::std::default::Default for SecPkgContext_RemoteCredentialInfo {
16253     fn default() -> Self {
16254         unsafe { ::std::mem::zeroed() }
16255     }
16256 }
16257 impl ::std::fmt::Debug for SecPkgContext_RemoteCredentialInfo {
16258     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16259         fmt.debug_struct("SecPkgContext_RemoteCredentialInfo").field("cbCertificateChain", &self.cbCertificateChain).field("pbCertificateChain", &self.pbCertificateChain).field("cCertificates", &self.cCertificates).field("fFlags", &self.fFlags).field("dwBits", &self.dwBits).finish()
16260     }
16261 }
16262 impl ::std::cmp::PartialEq for SecPkgContext_RemoteCredentialInfo {
16263     fn eq(&self, other: &Self) -> bool {
16264         self.cbCertificateChain == other.cbCertificateChain && self.pbCertificateChain == other.pbCertificateChain && self.cCertificates == other.cCertificates && self.fFlags == other.fFlags && self.dwBits == other.dwBits
16265     }
16266 }
16267 impl ::std::cmp::Eq for SecPkgContext_RemoteCredentialInfo {}
16268 unsafe impl ::windows::runtime::Abi for SecPkgContext_RemoteCredentialInfo {
16269     type Abi = Self;
16270     type DefaultType = Self;
16271 }
16272 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16273 #[repr(C)]
16274 pub struct SecPkgContext_SaslContext {
16275     pub SaslContext: *mut ::std::ffi::c_void,
16276 }
16277 impl SecPkgContext_SaslContext {}
16278 impl ::std::default::Default for SecPkgContext_SaslContext {
16279     fn default() -> Self {
16280         unsafe { ::std::mem::zeroed() }
16281     }
16282 }
16283 impl ::std::fmt::Debug for SecPkgContext_SaslContext {
16284     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16285         fmt.debug_struct("SecPkgContext_SaslContext").field("SaslContext", &self.SaslContext).finish()
16286     }
16287 }
16288 impl ::std::cmp::PartialEq for SecPkgContext_SaslContext {
16289     fn eq(&self, other: &Self) -> bool {
16290         self.SaslContext == other.SaslContext
16291     }
16292 }
16293 impl ::std::cmp::Eq for SecPkgContext_SaslContext {}
16294 unsafe impl ::windows::runtime::Abi for SecPkgContext_SaslContext {
16295     type Abi = Self;
16296     type DefaultType = Self;
16297 }
16298 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16299 #[repr(C)]
16300 pub struct SecPkgContext_SessionAppData {
16301     pub dwFlags: u32,
16302     pub cbAppData: u32,
16303     pub pbAppData: *mut u8,
16304 }
16305 impl SecPkgContext_SessionAppData {}
16306 impl ::std::default::Default for SecPkgContext_SessionAppData {
16307     fn default() -> Self {
16308         unsafe { ::std::mem::zeroed() }
16309     }
16310 }
16311 impl ::std::fmt::Debug for SecPkgContext_SessionAppData {
16312     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16313         fmt.debug_struct("SecPkgContext_SessionAppData").field("dwFlags", &self.dwFlags).field("cbAppData", &self.cbAppData).field("pbAppData", &self.pbAppData).finish()
16314     }
16315 }
16316 impl ::std::cmp::PartialEq for SecPkgContext_SessionAppData {
16317     fn eq(&self, other: &Self) -> bool {
16318         self.dwFlags == other.dwFlags && self.cbAppData == other.cbAppData && self.pbAppData == other.pbAppData
16319     }
16320 }
16321 impl ::std::cmp::Eq for SecPkgContext_SessionAppData {}
16322 unsafe impl ::windows::runtime::Abi for SecPkgContext_SessionAppData {
16323     type Abi = Self;
16324     type DefaultType = Self;
16325 }
16326 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16327 #[repr(C)]
16328 pub struct SecPkgContext_SessionInfo {
16329     pub dwFlags: u32,
16330     pub cbSessionId: u32,
16331     pub rgbSessionId: [u8; 32],
16332 }
16333 impl SecPkgContext_SessionInfo {}
16334 impl ::std::default::Default for SecPkgContext_SessionInfo {
16335     fn default() -> Self {
16336         unsafe { ::std::mem::zeroed() }
16337     }
16338 }
16339 impl ::std::fmt::Debug for SecPkgContext_SessionInfo {
16340     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16341         fmt.debug_struct("SecPkgContext_SessionInfo").field("dwFlags", &self.dwFlags).field("cbSessionId", &self.cbSessionId).field("rgbSessionId", &self.rgbSessionId).finish()
16342     }
16343 }
16344 impl ::std::cmp::PartialEq for SecPkgContext_SessionInfo {
16345     fn eq(&self, other: &Self) -> bool {
16346         self.dwFlags == other.dwFlags && self.cbSessionId == other.cbSessionId && self.rgbSessionId == other.rgbSessionId
16347     }
16348 }
16349 impl ::std::cmp::Eq for SecPkgContext_SessionInfo {}
16350 unsafe impl ::windows::runtime::Abi for SecPkgContext_SessionInfo {
16351     type Abi = Self;
16352     type DefaultType = Self;
16353 }
16354 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16355 #[repr(C)]
16356 pub struct SecPkgContext_SessionKey {
16357     pub SessionKeyLength: u32,
16358     pub SessionKey: *mut u8,
16359 }
16360 impl SecPkgContext_SessionKey {}
16361 impl ::std::default::Default for SecPkgContext_SessionKey {
16362     fn default() -> Self {
16363         unsafe { ::std::mem::zeroed() }
16364     }
16365 }
16366 impl ::std::fmt::Debug for SecPkgContext_SessionKey {
16367     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16368         fmt.debug_struct("SecPkgContext_SessionKey").field("SessionKeyLength", &self.SessionKeyLength).field("SessionKey", &self.SessionKey).finish()
16369     }
16370 }
16371 impl ::std::cmp::PartialEq for SecPkgContext_SessionKey {
16372     fn eq(&self, other: &Self) -> bool {
16373         self.SessionKeyLength == other.SessionKeyLength && self.SessionKey == other.SessionKey
16374     }
16375 }
16376 impl ::std::cmp::Eq for SecPkgContext_SessionKey {}
16377 unsafe impl ::windows::runtime::Abi for SecPkgContext_SessionKey {
16378     type Abi = Self;
16379     type DefaultType = Self;
16380 }
16381 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16382 #[repr(C)]
16383 pub struct SecPkgContext_Sizes {
16384     pub cbMaxToken: u32,
16385     pub cbMaxSignature: u32,
16386     pub cbBlockSize: u32,
16387     pub cbSecurityTrailer: u32,
16388 }
16389 impl SecPkgContext_Sizes {}
16390 impl ::std::default::Default for SecPkgContext_Sizes {
16391     fn default() -> Self {
16392         unsafe { ::std::mem::zeroed() }
16393     }
16394 }
16395 impl ::std::fmt::Debug for SecPkgContext_Sizes {
16396     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16397         fmt.debug_struct("SecPkgContext_Sizes").field("cbMaxToken", &self.cbMaxToken).field("cbMaxSignature", &self.cbMaxSignature).field("cbBlockSize", &self.cbBlockSize).field("cbSecurityTrailer", &self.cbSecurityTrailer).finish()
16398     }
16399 }
16400 impl ::std::cmp::PartialEq for SecPkgContext_Sizes {
16401     fn eq(&self, other: &Self) -> bool {
16402         self.cbMaxToken == other.cbMaxToken && self.cbMaxSignature == other.cbMaxSignature && self.cbBlockSize == other.cbBlockSize && self.cbSecurityTrailer == other.cbSecurityTrailer
16403     }
16404 }
16405 impl ::std::cmp::Eq for SecPkgContext_Sizes {}
16406 unsafe impl ::windows::runtime::Abi for SecPkgContext_Sizes {
16407     type Abi = Self;
16408     type DefaultType = Self;
16409 }
16410 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16411 #[repr(C)]
16412 pub struct SecPkgContext_SrtpParameters {
16413     pub ProtectionProfile: u16,
16414     pub MasterKeyIdentifierSize: u8,
16415     pub MasterKeyIdentifier: *mut u8,
16416 }
16417 impl SecPkgContext_SrtpParameters {}
16418 impl ::std::default::Default for SecPkgContext_SrtpParameters {
16419     fn default() -> Self {
16420         unsafe { ::std::mem::zeroed() }
16421     }
16422 }
16423 impl ::std::fmt::Debug for SecPkgContext_SrtpParameters {
16424     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16425         fmt.debug_struct("SecPkgContext_SrtpParameters").field("ProtectionProfile", &self.ProtectionProfile).field("MasterKeyIdentifierSize", &self.MasterKeyIdentifierSize).field("MasterKeyIdentifier", &self.MasterKeyIdentifier).finish()
16426     }
16427 }
16428 impl ::std::cmp::PartialEq for SecPkgContext_SrtpParameters {
16429     fn eq(&self, other: &Self) -> bool {
16430         self.ProtectionProfile == other.ProtectionProfile && self.MasterKeyIdentifierSize == other.MasterKeyIdentifierSize && self.MasterKeyIdentifier == other.MasterKeyIdentifier
16431     }
16432 }
16433 impl ::std::cmp::Eq for SecPkgContext_SrtpParameters {}
16434 unsafe impl ::windows::runtime::Abi for SecPkgContext_SrtpParameters {
16435     type Abi = Self;
16436     type DefaultType = Self;
16437 }
16438 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16439 #[repr(C)]
16440 pub struct SecPkgContext_StreamSizes {
16441     pub cbHeader: u32,
16442     pub cbTrailer: u32,
16443     pub cbMaximumMessage: u32,
16444     pub cBuffers: u32,
16445     pub cbBlockSize: u32,
16446 }
16447 impl SecPkgContext_StreamSizes {}
16448 impl ::std::default::Default for SecPkgContext_StreamSizes {
16449     fn default() -> Self {
16450         unsafe { ::std::mem::zeroed() }
16451     }
16452 }
16453 impl ::std::fmt::Debug for SecPkgContext_StreamSizes {
16454     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16455         fmt.debug_struct("SecPkgContext_StreamSizes").field("cbHeader", &self.cbHeader).field("cbTrailer", &self.cbTrailer).field("cbMaximumMessage", &self.cbMaximumMessage).field("cBuffers", &self.cBuffers).field("cbBlockSize", &self.cbBlockSize).finish()
16456     }
16457 }
16458 impl ::std::cmp::PartialEq for SecPkgContext_StreamSizes {
16459     fn eq(&self, other: &Self) -> bool {
16460         self.cbHeader == other.cbHeader && self.cbTrailer == other.cbTrailer && self.cbMaximumMessage == other.cbMaximumMessage && self.cBuffers == other.cBuffers && self.cbBlockSize == other.cbBlockSize
16461     }
16462 }
16463 impl ::std::cmp::Eq for SecPkgContext_StreamSizes {}
16464 unsafe impl ::windows::runtime::Abi for SecPkgContext_StreamSizes {
16465     type Abi = Self;
16466     type DefaultType = Self;
16467 }
16468 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16469 #[repr(C)]
16470 pub struct SecPkgContext_SubjectAttributes {
16471     pub AttributeInfo: *mut ::std::ffi::c_void,
16472 }
16473 impl SecPkgContext_SubjectAttributes {}
16474 impl ::std::default::Default for SecPkgContext_SubjectAttributes {
16475     fn default() -> Self {
16476         unsafe { ::std::mem::zeroed() }
16477     }
16478 }
16479 impl ::std::fmt::Debug for SecPkgContext_SubjectAttributes {
16480     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16481         fmt.debug_struct("SecPkgContext_SubjectAttributes").field("AttributeInfo", &self.AttributeInfo).finish()
16482     }
16483 }
16484 impl ::std::cmp::PartialEq for SecPkgContext_SubjectAttributes {
16485     fn eq(&self, other: &Self) -> bool {
16486         self.AttributeInfo == other.AttributeInfo
16487     }
16488 }
16489 impl ::std::cmp::Eq for SecPkgContext_SubjectAttributes {}
16490 unsafe impl ::windows::runtime::Abi for SecPkgContext_SubjectAttributes {
16491     type Abi = Self;
16492     type DefaultType = Self;
16493 }
16494 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16495 #[repr(C)]
16496 pub struct SecPkgContext_SupportedSignatures {
16497     pub cSignatureAndHashAlgorithms: u16,
16498     pub pSignatureAndHashAlgorithms: *mut u16,
16499 }
16500 impl SecPkgContext_SupportedSignatures {}
16501 impl ::std::default::Default for SecPkgContext_SupportedSignatures {
16502     fn default() -> Self {
16503         unsafe { ::std::mem::zeroed() }
16504     }
16505 }
16506 impl ::std::fmt::Debug for SecPkgContext_SupportedSignatures {
16507     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16508         fmt.debug_struct("SecPkgContext_SupportedSignatures").field("cSignatureAndHashAlgorithms", &self.cSignatureAndHashAlgorithms).field("pSignatureAndHashAlgorithms", &self.pSignatureAndHashAlgorithms).finish()
16509     }
16510 }
16511 impl ::std::cmp::PartialEq for SecPkgContext_SupportedSignatures {
16512     fn eq(&self, other: &Self) -> bool {
16513         self.cSignatureAndHashAlgorithms == other.cSignatureAndHashAlgorithms && self.pSignatureAndHashAlgorithms == other.pSignatureAndHashAlgorithms
16514     }
16515 }
16516 impl ::std::cmp::Eq for SecPkgContext_SupportedSignatures {}
16517 unsafe impl ::windows::runtime::Abi for SecPkgContext_SupportedSignatures {
16518     type Abi = Self;
16519     type DefaultType = Self;
16520 }
16521 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16522 #[repr(C)]
16523 #[cfg(feature = "Win32_Foundation")]
16524 pub struct SecPkgContext_Target {
16525     pub TargetLength: u32,
16526     pub Target: super::super::super::Foundation::PSTR,
16527 }
16528 #[cfg(feature = "Win32_Foundation")]
16529 impl SecPkgContext_Target {}
16530 #[cfg(feature = "Win32_Foundation")]
16531 impl ::std::default::Default for SecPkgContext_Target {
16532     fn default() -> Self {
16533         unsafe { ::std::mem::zeroed() }
16534     }
16535 }
16536 #[cfg(feature = "Win32_Foundation")]
16537 impl ::std::fmt::Debug for SecPkgContext_Target {
16538     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16539         fmt.debug_struct("SecPkgContext_Target").field("TargetLength", &self.TargetLength).field("Target", &self.Target).finish()
16540     }
16541 }
16542 #[cfg(feature = "Win32_Foundation")]
16543 impl ::std::cmp::PartialEq for SecPkgContext_Target {
16544     fn eq(&self, other: &Self) -> bool {
16545         self.TargetLength == other.TargetLength && self.Target == other.Target
16546     }
16547 }
16548 #[cfg(feature = "Win32_Foundation")]
16549 impl ::std::cmp::Eq for SecPkgContext_Target {}
16550 #[cfg(feature = "Win32_Foundation")]
16551 unsafe impl ::windows::runtime::Abi for SecPkgContext_Target {
16552     type Abi = Self;
16553     type DefaultType = Self;
16554 }
16555 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16556 #[repr(C)]
16557 pub struct SecPkgContext_TargetInformation {
16558     pub MarshalledTargetInfoLength: u32,
16559     pub MarshalledTargetInfo: *mut u8,
16560 }
16561 impl SecPkgContext_TargetInformation {}
16562 impl ::std::default::Default for SecPkgContext_TargetInformation {
16563     fn default() -> Self {
16564         unsafe { ::std::mem::zeroed() }
16565     }
16566 }
16567 impl ::std::fmt::Debug for SecPkgContext_TargetInformation {
16568     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16569         fmt.debug_struct("SecPkgContext_TargetInformation").field("MarshalledTargetInfoLength", &self.MarshalledTargetInfoLength).field("MarshalledTargetInfo", &self.MarshalledTargetInfo).finish()
16570     }
16571 }
16572 impl ::std::cmp::PartialEq for SecPkgContext_TargetInformation {
16573     fn eq(&self, other: &Self) -> bool {
16574         self.MarshalledTargetInfoLength == other.MarshalledTargetInfoLength && self.MarshalledTargetInfo == other.MarshalledTargetInfo
16575     }
16576 }
16577 impl ::std::cmp::Eq for SecPkgContext_TargetInformation {}
16578 unsafe impl ::windows::runtime::Abi for SecPkgContext_TargetInformation {
16579     type Abi = Self;
16580     type DefaultType = Self;
16581 }
16582 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16583 #[repr(C)]
16584 pub struct SecPkgContext_TokenBinding {
16585     pub MajorVersion: u8,
16586     pub MinorVersion: u8,
16587     pub KeyParametersSize: u16,
16588     pub KeyParameters: *mut u8,
16589 }
16590 impl SecPkgContext_TokenBinding {}
16591 impl ::std::default::Default for SecPkgContext_TokenBinding {
16592     fn default() -> Self {
16593         unsafe { ::std::mem::zeroed() }
16594     }
16595 }
16596 impl ::std::fmt::Debug for SecPkgContext_TokenBinding {
16597     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16598         fmt.debug_struct("SecPkgContext_TokenBinding").field("MajorVersion", &self.MajorVersion).field("MinorVersion", &self.MinorVersion).field("KeyParametersSize", &self.KeyParametersSize).field("KeyParameters", &self.KeyParameters).finish()
16599     }
16600 }
16601 impl ::std::cmp::PartialEq for SecPkgContext_TokenBinding {
16602     fn eq(&self, other: &Self) -> bool {
16603         self.MajorVersion == other.MajorVersion && self.MinorVersion == other.MinorVersion && self.KeyParametersSize == other.KeyParametersSize && self.KeyParameters == other.KeyParameters
16604     }
16605 }
16606 impl ::std::cmp::Eq for SecPkgContext_TokenBinding {}
16607 unsafe impl ::windows::runtime::Abi for SecPkgContext_TokenBinding {
16608     type Abi = Self;
16609     type DefaultType = Self;
16610 }
16611 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16612 #[repr(C)]
16613 #[cfg(feature = "Win32_Foundation")]
16614 pub struct SecPkgContext_UiInfo {
16615     pub hParentWindow: super::super::super::Foundation::HWND,
16616 }
16617 #[cfg(feature = "Win32_Foundation")]
16618 impl SecPkgContext_UiInfo {}
16619 #[cfg(feature = "Win32_Foundation")]
16620 impl ::std::default::Default for SecPkgContext_UiInfo {
16621     fn default() -> Self {
16622         unsafe { ::std::mem::zeroed() }
16623     }
16624 }
16625 #[cfg(feature = "Win32_Foundation")]
16626 impl ::std::fmt::Debug for SecPkgContext_UiInfo {
16627     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16628         fmt.debug_struct("SecPkgContext_UiInfo").field("hParentWindow", &self.hParentWindow).finish()
16629     }
16630 }
16631 #[cfg(feature = "Win32_Foundation")]
16632 impl ::std::cmp::PartialEq for SecPkgContext_UiInfo {
16633     fn eq(&self, other: &Self) -> bool {
16634         self.hParentWindow == other.hParentWindow
16635     }
16636 }
16637 #[cfg(feature = "Win32_Foundation")]
16638 impl ::std::cmp::Eq for SecPkgContext_UiInfo {}
16639 #[cfg(feature = "Win32_Foundation")]
16640 unsafe impl ::windows::runtime::Abi for SecPkgContext_UiInfo {
16641     type Abi = Self;
16642     type DefaultType = Self;
16643 }
16644 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16645 #[repr(C)]
16646 pub struct SecPkgContext_UserFlags {
16647     pub UserFlags: u32,
16648 }
16649 impl SecPkgContext_UserFlags {}
16650 impl ::std::default::Default for SecPkgContext_UserFlags {
16651     fn default() -> Self {
16652         unsafe { ::std::mem::zeroed() }
16653     }
16654 }
16655 impl ::std::fmt::Debug for SecPkgContext_UserFlags {
16656     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16657         fmt.debug_struct("SecPkgContext_UserFlags").field("UserFlags", &self.UserFlags).finish()
16658     }
16659 }
16660 impl ::std::cmp::PartialEq for SecPkgContext_UserFlags {
16661     fn eq(&self, other: &Self) -> bool {
16662         self.UserFlags == other.UserFlags
16663     }
16664 }
16665 impl ::std::cmp::Eq for SecPkgContext_UserFlags {}
16666 unsafe impl ::windows::runtime::Abi for SecPkgContext_UserFlags {
16667     type Abi = Self;
16668     type DefaultType = Self;
16669 }
16670 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16671 #[repr(C)]
16672 pub struct SecPkgCred_CipherStrengths {
16673     pub dwMinimumCipherStrength: u32,
16674     pub dwMaximumCipherStrength: u32,
16675 }
16676 impl SecPkgCred_CipherStrengths {}
16677 impl ::std::default::Default for SecPkgCred_CipherStrengths {
16678     fn default() -> Self {
16679         unsafe { ::std::mem::zeroed() }
16680     }
16681 }
16682 impl ::std::fmt::Debug for SecPkgCred_CipherStrengths {
16683     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16684         fmt.debug_struct("SecPkgCred_CipherStrengths").field("dwMinimumCipherStrength", &self.dwMinimumCipherStrength).field("dwMaximumCipherStrength", &self.dwMaximumCipherStrength).finish()
16685     }
16686 }
16687 impl ::std::cmp::PartialEq for SecPkgCred_CipherStrengths {
16688     fn eq(&self, other: &Self) -> bool {
16689         self.dwMinimumCipherStrength == other.dwMinimumCipherStrength && self.dwMaximumCipherStrength == other.dwMaximumCipherStrength
16690     }
16691 }
16692 impl ::std::cmp::Eq for SecPkgCred_CipherStrengths {}
16693 unsafe impl ::windows::runtime::Abi for SecPkgCred_CipherStrengths {
16694     type Abi = Self;
16695     type DefaultType = Self;
16696 }
16697 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16698 #[repr(C)]
16699 #[cfg(feature = "Win32_Foundation")]
16700 pub struct SecPkgCred_ClientCertPolicy {
16701     pub dwFlags: u32,
16702     pub guidPolicyId: ::windows::runtime::GUID,
16703     pub dwCertFlags: u32,
16704     pub dwUrlRetrievalTimeout: u32,
16705     pub fCheckRevocationFreshnessTime: super::super::super::Foundation::BOOL,
16706     pub dwRevocationFreshnessTime: u32,
16707     pub fOmitUsageCheck: super::super::super::Foundation::BOOL,
16708     pub pwszSslCtlStoreName: super::super::super::Foundation::PWSTR,
16709     pub pwszSslCtlIdentifier: super::super::super::Foundation::PWSTR,
16710 }
16711 #[cfg(feature = "Win32_Foundation")]
16712 impl SecPkgCred_ClientCertPolicy {}
16713 #[cfg(feature = "Win32_Foundation")]
16714 impl ::std::default::Default for SecPkgCred_ClientCertPolicy {
16715     fn default() -> Self {
16716         unsafe { ::std::mem::zeroed() }
16717     }
16718 }
16719 #[cfg(feature = "Win32_Foundation")]
16720 impl ::std::fmt::Debug for SecPkgCred_ClientCertPolicy {
16721     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16722         fmt.debug_struct("SecPkgCred_ClientCertPolicy")
16723             .field("dwFlags", &self.dwFlags)
16724             .field("guidPolicyId", &self.guidPolicyId)
16725             .field("dwCertFlags", &self.dwCertFlags)
16726             .field("dwUrlRetrievalTimeout", &self.dwUrlRetrievalTimeout)
16727             .field("fCheckRevocationFreshnessTime", &self.fCheckRevocationFreshnessTime)
16728             .field("dwRevocationFreshnessTime", &self.dwRevocationFreshnessTime)
16729             .field("fOmitUsageCheck", &self.fOmitUsageCheck)
16730             .field("pwszSslCtlStoreName", &self.pwszSslCtlStoreName)
16731             .field("pwszSslCtlIdentifier", &self.pwszSslCtlIdentifier)
16732             .finish()
16733     }
16734 }
16735 #[cfg(feature = "Win32_Foundation")]
16736 impl ::std::cmp::PartialEq for SecPkgCred_ClientCertPolicy {
16737     fn eq(&self, other: &Self) -> bool {
16738         self.dwFlags == other.dwFlags && self.guidPolicyId == other.guidPolicyId && self.dwCertFlags == other.dwCertFlags && self.dwUrlRetrievalTimeout == other.dwUrlRetrievalTimeout && self.fCheckRevocationFreshnessTime == other.fCheckRevocationFreshnessTime && self.dwRevocationFreshnessTime == other.dwRevocationFreshnessTime && self.fOmitUsageCheck == other.fOmitUsageCheck && self.pwszSslCtlStoreName == other.pwszSslCtlStoreName && self.pwszSslCtlIdentifier == other.pwszSslCtlIdentifier
16739     }
16740 }
16741 #[cfg(feature = "Win32_Foundation")]
16742 impl ::std::cmp::Eq for SecPkgCred_ClientCertPolicy {}
16743 #[cfg(feature = "Win32_Foundation")]
16744 unsafe impl ::windows::runtime::Abi for SecPkgCred_ClientCertPolicy {
16745     type Abi = Self;
16746     type DefaultType = Self;
16747 }
16748 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16749 #[repr(C)]
16750 pub struct SecPkgCred_SessionTicketKey {
16751     pub TicketInfoVersion: u32,
16752     pub KeyId: [u8; 16],
16753     pub KeyingMaterial: [u8; 64],
16754     pub KeyingMaterialSize: u8,
16755 }
16756 impl SecPkgCred_SessionTicketKey {}
16757 impl ::std::default::Default for SecPkgCred_SessionTicketKey {
16758     fn default() -> Self {
16759         unsafe { ::std::mem::zeroed() }
16760     }
16761 }
16762 impl ::std::fmt::Debug for SecPkgCred_SessionTicketKey {
16763     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16764         fmt.debug_struct("SecPkgCred_SessionTicketKey").field("TicketInfoVersion", &self.TicketInfoVersion).field("KeyId", &self.KeyId).field("KeyingMaterial", &self.KeyingMaterial).field("KeyingMaterialSize", &self.KeyingMaterialSize).finish()
16765     }
16766 }
16767 impl ::std::cmp::PartialEq for SecPkgCred_SessionTicketKey {
16768     fn eq(&self, other: &Self) -> bool {
16769         self.TicketInfoVersion == other.TicketInfoVersion && self.KeyId == other.KeyId && self.KeyingMaterial == other.KeyingMaterial && self.KeyingMaterialSize == other.KeyingMaterialSize
16770     }
16771 }
16772 impl ::std::cmp::Eq for SecPkgCred_SessionTicketKey {}
16773 unsafe impl ::windows::runtime::Abi for SecPkgCred_SessionTicketKey {
16774     type Abi = Self;
16775     type DefaultType = Self;
16776 }
16777 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16778 #[repr(C)]
16779 pub struct SecPkgCred_SessionTicketKeys {
16780     pub cSessionTicketKeys: u32,
16781     pub pSessionTicketKeys: *mut SecPkgCred_SessionTicketKey,
16782 }
16783 impl SecPkgCred_SessionTicketKeys {}
16784 impl ::std::default::Default for SecPkgCred_SessionTicketKeys {
16785     fn default() -> Self {
16786         unsafe { ::std::mem::zeroed() }
16787     }
16788 }
16789 impl ::std::fmt::Debug for SecPkgCred_SessionTicketKeys {
16790     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16791         fmt.debug_struct("SecPkgCred_SessionTicketKeys").field("cSessionTicketKeys", &self.cSessionTicketKeys).field("pSessionTicketKeys", &self.pSessionTicketKeys).finish()
16792     }
16793 }
16794 impl ::std::cmp::PartialEq for SecPkgCred_SessionTicketKeys {
16795     fn eq(&self, other: &Self) -> bool {
16796         self.cSessionTicketKeys == other.cSessionTicketKeys && self.pSessionTicketKeys == other.pSessionTicketKeys
16797     }
16798 }
16799 impl ::std::cmp::Eq for SecPkgCred_SessionTicketKeys {}
16800 unsafe impl ::windows::runtime::Abi for SecPkgCred_SessionTicketKeys {
16801     type Abi = Self;
16802     type DefaultType = Self;
16803 }
16804 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16805 #[repr(C)]
16806 pub struct SecPkgCred_SupportedAlgs {
16807     pub cSupportedAlgs: u32,
16808     pub palgSupportedAlgs: *mut u32,
16809 }
16810 impl SecPkgCred_SupportedAlgs {}
16811 impl ::std::default::Default for SecPkgCred_SupportedAlgs {
16812     fn default() -> Self {
16813         unsafe { ::std::mem::zeroed() }
16814     }
16815 }
16816 impl ::std::fmt::Debug for SecPkgCred_SupportedAlgs {
16817     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16818         fmt.debug_struct("SecPkgCred_SupportedAlgs").field("cSupportedAlgs", &self.cSupportedAlgs).field("palgSupportedAlgs", &self.palgSupportedAlgs).finish()
16819     }
16820 }
16821 impl ::std::cmp::PartialEq for SecPkgCred_SupportedAlgs {
16822     fn eq(&self, other: &Self) -> bool {
16823         self.cSupportedAlgs == other.cSupportedAlgs && self.palgSupportedAlgs == other.palgSupportedAlgs
16824     }
16825 }
16826 impl ::std::cmp::Eq for SecPkgCred_SupportedAlgs {}
16827 unsafe impl ::windows::runtime::Abi for SecPkgCred_SupportedAlgs {
16828     type Abi = Self;
16829     type DefaultType = Self;
16830 }
16831 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16832 #[repr(C)]
16833 pub struct SecPkgCred_SupportedProtocols {
16834     pub grbitProtocol: u32,
16835 }
16836 impl SecPkgCred_SupportedProtocols {}
16837 impl ::std::default::Default for SecPkgCred_SupportedProtocols {
16838     fn default() -> Self {
16839         unsafe { ::std::mem::zeroed() }
16840     }
16841 }
16842 impl ::std::fmt::Debug for SecPkgCred_SupportedProtocols {
16843     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16844         fmt.debug_struct("SecPkgCred_SupportedProtocols").field("grbitProtocol", &self.grbitProtocol).finish()
16845     }
16846 }
16847 impl ::std::cmp::PartialEq for SecPkgCred_SupportedProtocols {
16848     fn eq(&self, other: &Self) -> bool {
16849         self.grbitProtocol == other.grbitProtocol
16850     }
16851 }
16852 impl ::std::cmp::Eq for SecPkgCred_SupportedProtocols {}
16853 unsafe impl ::windows::runtime::Abi for SecPkgCred_SupportedProtocols {
16854     type Abi = Self;
16855     type DefaultType = Self;
16856 }
16857 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16858 #[repr(C)]
16859 pub struct SecPkgCredentials_Cert {
16860     pub EncodedCertSize: u32,
16861     pub EncodedCert: *mut u8,
16862 }
16863 impl SecPkgCredentials_Cert {}
16864 impl ::std::default::Default for SecPkgCredentials_Cert {
16865     fn default() -> Self {
16866         unsafe { ::std::mem::zeroed() }
16867     }
16868 }
16869 impl ::std::fmt::Debug for SecPkgCredentials_Cert {
16870     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16871         fmt.debug_struct("SecPkgCredentials_Cert").field("EncodedCertSize", &self.EncodedCertSize).field("EncodedCert", &self.EncodedCert).finish()
16872     }
16873 }
16874 impl ::std::cmp::PartialEq for SecPkgCredentials_Cert {
16875     fn eq(&self, other: &Self) -> bool {
16876         self.EncodedCertSize == other.EncodedCertSize && self.EncodedCert == other.EncodedCert
16877     }
16878 }
16879 impl ::std::cmp::Eq for SecPkgCredentials_Cert {}
16880 unsafe impl ::windows::runtime::Abi for SecPkgCredentials_Cert {
16881     type Abi = Self;
16882     type DefaultType = Self;
16883 }
16884 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16885 #[repr(C)]
16886 pub struct SecPkgCredentials_KdcProxySettingsW {
16887     pub Version: u32,
16888     pub Flags: u32,
16889     pub ProxyServerOffset: u16,
16890     pub ProxyServerLength: u16,
16891     pub ClientTlsCredOffset: u16,
16892     pub ClientTlsCredLength: u16,
16893 }
16894 impl SecPkgCredentials_KdcProxySettingsW {}
16895 impl ::std::default::Default for SecPkgCredentials_KdcProxySettingsW {
16896     fn default() -> Self {
16897         unsafe { ::std::mem::zeroed() }
16898     }
16899 }
16900 impl ::std::fmt::Debug for SecPkgCredentials_KdcProxySettingsW {
16901     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16902         fmt.debug_struct("SecPkgCredentials_KdcProxySettingsW")
16903             .field("Version", &self.Version)
16904             .field("Flags", &self.Flags)
16905             .field("ProxyServerOffset", &self.ProxyServerOffset)
16906             .field("ProxyServerLength", &self.ProxyServerLength)
16907             .field("ClientTlsCredOffset", &self.ClientTlsCredOffset)
16908             .field("ClientTlsCredLength", &self.ClientTlsCredLength)
16909             .finish()
16910     }
16911 }
16912 impl ::std::cmp::PartialEq for SecPkgCredentials_KdcProxySettingsW {
16913     fn eq(&self, other: &Self) -> bool {
16914         self.Version == other.Version && self.Flags == other.Flags && self.ProxyServerOffset == other.ProxyServerOffset && self.ProxyServerLength == other.ProxyServerLength && self.ClientTlsCredOffset == other.ClientTlsCredOffset && self.ClientTlsCredLength == other.ClientTlsCredLength
16915     }
16916 }
16917 impl ::std::cmp::Eq for SecPkgCredentials_KdcProxySettingsW {}
16918 unsafe impl ::windows::runtime::Abi for SecPkgCredentials_KdcProxySettingsW {
16919     type Abi = Self;
16920     type DefaultType = Self;
16921 }
16922 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16923 #[repr(C)]
16924 pub struct SecPkgCredentials_NamesA {
16925     pub sUserName: *mut i8,
16926 }
16927 impl SecPkgCredentials_NamesA {}
16928 impl ::std::default::Default for SecPkgCredentials_NamesA {
16929     fn default() -> Self {
16930         unsafe { ::std::mem::zeroed() }
16931     }
16932 }
16933 impl ::std::fmt::Debug for SecPkgCredentials_NamesA {
16934     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16935         fmt.debug_struct("SecPkgCredentials_NamesA").field("sUserName", &self.sUserName).finish()
16936     }
16937 }
16938 impl ::std::cmp::PartialEq for SecPkgCredentials_NamesA {
16939     fn eq(&self, other: &Self) -> bool {
16940         self.sUserName == other.sUserName
16941     }
16942 }
16943 impl ::std::cmp::Eq for SecPkgCredentials_NamesA {}
16944 unsafe impl ::windows::runtime::Abi for SecPkgCredentials_NamesA {
16945     type Abi = Self;
16946     type DefaultType = Self;
16947 }
16948 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16949 #[repr(C)]
16950 pub struct SecPkgCredentials_NamesW {
16951     pub sUserName: *mut u16,
16952 }
16953 impl SecPkgCredentials_NamesW {}
16954 impl ::std::default::Default for SecPkgCredentials_NamesW {
16955     fn default() -> Self {
16956         unsafe { ::std::mem::zeroed() }
16957     }
16958 }
16959 impl ::std::fmt::Debug for SecPkgCredentials_NamesW {
16960     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16961         fmt.debug_struct("SecPkgCredentials_NamesW").field("sUserName", &self.sUserName).finish()
16962     }
16963 }
16964 impl ::std::cmp::PartialEq for SecPkgCredentials_NamesW {
16965     fn eq(&self, other: &Self) -> bool {
16966         self.sUserName == other.sUserName
16967     }
16968 }
16969 impl ::std::cmp::Eq for SecPkgCredentials_NamesW {}
16970 unsafe impl ::windows::runtime::Abi for SecPkgCredentials_NamesW {
16971     type Abi = Self;
16972     type DefaultType = Self;
16973 }
16974 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
16975 #[repr(C)]
16976 #[cfg(feature = "Win32_Foundation")]
16977 pub struct SecPkgCredentials_SSIProviderA {
16978     pub sProviderName: *mut i8,
16979     pub ProviderInfoLength: u32,
16980     pub ProviderInfo: super::super::super::Foundation::PSTR,
16981 }
16982 #[cfg(feature = "Win32_Foundation")]
16983 impl SecPkgCredentials_SSIProviderA {}
16984 #[cfg(feature = "Win32_Foundation")]
16985 impl ::std::default::Default for SecPkgCredentials_SSIProviderA {
16986     fn default() -> Self {
16987         unsafe { ::std::mem::zeroed() }
16988     }
16989 }
16990 #[cfg(feature = "Win32_Foundation")]
16991 impl ::std::fmt::Debug for SecPkgCredentials_SSIProviderA {
16992     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
16993         fmt.debug_struct("SecPkgCredentials_SSIProviderA").field("sProviderName", &self.sProviderName).field("ProviderInfoLength", &self.ProviderInfoLength).field("ProviderInfo", &self.ProviderInfo).finish()
16994     }
16995 }
16996 #[cfg(feature = "Win32_Foundation")]
16997 impl ::std::cmp::PartialEq for SecPkgCredentials_SSIProviderA {
16998     fn eq(&self, other: &Self) -> bool {
16999         self.sProviderName == other.sProviderName && self.ProviderInfoLength == other.ProviderInfoLength && self.ProviderInfo == other.ProviderInfo
17000     }
17001 }
17002 #[cfg(feature = "Win32_Foundation")]
17003 impl ::std::cmp::Eq for SecPkgCredentials_SSIProviderA {}
17004 #[cfg(feature = "Win32_Foundation")]
17005 unsafe impl ::windows::runtime::Abi for SecPkgCredentials_SSIProviderA {
17006     type Abi = Self;
17007     type DefaultType = Self;
17008 }
17009 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17010 #[repr(C)]
17011 #[cfg(feature = "Win32_Foundation")]
17012 pub struct SecPkgCredentials_SSIProviderW {
17013     pub sProviderName: *mut u16,
17014     pub ProviderInfoLength: u32,
17015     pub ProviderInfo: super::super::super::Foundation::PSTR,
17016 }
17017 #[cfg(feature = "Win32_Foundation")]
17018 impl SecPkgCredentials_SSIProviderW {}
17019 #[cfg(feature = "Win32_Foundation")]
17020 impl ::std::default::Default for SecPkgCredentials_SSIProviderW {
17021     fn default() -> Self {
17022         unsafe { ::std::mem::zeroed() }
17023     }
17024 }
17025 #[cfg(feature = "Win32_Foundation")]
17026 impl ::std::fmt::Debug for SecPkgCredentials_SSIProviderW {
17027     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17028         fmt.debug_struct("SecPkgCredentials_SSIProviderW").field("sProviderName", &self.sProviderName).field("ProviderInfoLength", &self.ProviderInfoLength).field("ProviderInfo", &self.ProviderInfo).finish()
17029     }
17030 }
17031 #[cfg(feature = "Win32_Foundation")]
17032 impl ::std::cmp::PartialEq for SecPkgCredentials_SSIProviderW {
17033     fn eq(&self, other: &Self) -> bool {
17034         self.sProviderName == other.sProviderName && self.ProviderInfoLength == other.ProviderInfoLength && self.ProviderInfo == other.ProviderInfo
17035     }
17036 }
17037 #[cfg(feature = "Win32_Foundation")]
17038 impl ::std::cmp::Eq for SecPkgCredentials_SSIProviderW {}
17039 #[cfg(feature = "Win32_Foundation")]
17040 unsafe impl ::windows::runtime::Abi for SecPkgCredentials_SSIProviderW {
17041     type Abi = Self;
17042     type DefaultType = Self;
17043 }
17044 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17045 #[repr(C)]
17046 pub struct SecPkgInfoA {
17047     pub fCapabilities: u32,
17048     pub wVersion: u16,
17049     pub wRPCID: u16,
17050     pub cbMaxToken: u32,
17051     pub Name: *mut i8,
17052     pub Comment: *mut i8,
17053 }
17054 impl SecPkgInfoA {}
17055 impl ::std::default::Default for SecPkgInfoA {
17056     fn default() -> Self {
17057         unsafe { ::std::mem::zeroed() }
17058     }
17059 }
17060 impl ::std::fmt::Debug for SecPkgInfoA {
17061     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17062         fmt.debug_struct("SecPkgInfoA").field("fCapabilities", &self.fCapabilities).field("wVersion", &self.wVersion).field("wRPCID", &self.wRPCID).field("cbMaxToken", &self.cbMaxToken).field("Name", &self.Name).field("Comment", &self.Comment).finish()
17063     }
17064 }
17065 impl ::std::cmp::PartialEq for SecPkgInfoA {
17066     fn eq(&self, other: &Self) -> bool {
17067         self.fCapabilities == other.fCapabilities && self.wVersion == other.wVersion && self.wRPCID == other.wRPCID && self.cbMaxToken == other.cbMaxToken && self.Name == other.Name && self.Comment == other.Comment
17068     }
17069 }
17070 impl ::std::cmp::Eq for SecPkgInfoA {}
17071 unsafe impl ::windows::runtime::Abi for SecPkgInfoA {
17072     type Abi = Self;
17073     type DefaultType = Self;
17074 }
17075 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17076 #[repr(C)]
17077 pub struct SecPkgInfoW {
17078     pub fCapabilities: u32,
17079     pub wVersion: u16,
17080     pub wRPCID: u16,
17081     pub cbMaxToken: u32,
17082     pub Name: *mut u16,
17083     pub Comment: *mut u16,
17084 }
17085 impl SecPkgInfoW {}
17086 impl ::std::default::Default for SecPkgInfoW {
17087     fn default() -> Self {
17088         unsafe { ::std::mem::zeroed() }
17089     }
17090 }
17091 impl ::std::fmt::Debug for SecPkgInfoW {
17092     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17093         fmt.debug_struct("SecPkgInfoW").field("fCapabilities", &self.fCapabilities).field("wVersion", &self.wVersion).field("wRPCID", &self.wRPCID).field("cbMaxToken", &self.cbMaxToken).field("Name", &self.Name).field("Comment", &self.Comment).finish()
17094     }
17095 }
17096 impl ::std::cmp::PartialEq for SecPkgInfoW {
17097     fn eq(&self, other: &Self) -> bool {
17098         self.fCapabilities == other.fCapabilities && self.wVersion == other.wVersion && self.wRPCID == other.wRPCID && self.cbMaxToken == other.cbMaxToken && self.Name == other.Name && self.Comment == other.Comment
17099     }
17100 }
17101 impl ::std::cmp::Eq for SecPkgInfoW {}
17102 unsafe impl ::windows::runtime::Abi for SecPkgInfoW {
17103     type Abi = Self;
17104     type DefaultType = Self;
17105 }
17106 #[derive(:: std :: clone :: Clone)]
17107 #[repr(C)]
17108 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
17109 pub struct SecurityFunctionTableA {
17110     pub dwVersion: u32,
17111     pub EnumerateSecurityPackagesA: ::std::option::Option<ENUMERATE_SECURITY_PACKAGES_FN_A>,
17112     pub QueryCredentialsAttributesA: ::std::option::Option<QUERY_CREDENTIALS_ATTRIBUTES_FN_A>,
17113     pub AcquireCredentialsHandleA: ::std::option::Option<ACQUIRE_CREDENTIALS_HANDLE_FN_A>,
17114     pub FreeCredentialsHandle: ::std::option::Option<FREE_CREDENTIALS_HANDLE_FN>,
17115     pub Reserved2: *mut ::std::ffi::c_void,
17116     pub InitializeSecurityContextA: ::std::option::Option<INITIALIZE_SECURITY_CONTEXT_FN_A>,
17117     pub AcceptSecurityContext: ::std::option::Option<ACCEPT_SECURITY_CONTEXT_FN>,
17118     pub CompleteAuthToken: ::std::option::Option<COMPLETE_AUTH_TOKEN_FN>,
17119     pub DeleteSecurityContext: ::std::option::Option<DELETE_SECURITY_CONTEXT_FN>,
17120     pub ApplyControlToken: ::std::option::Option<APPLY_CONTROL_TOKEN_FN>,
17121     pub QueryContextAttributesA: ::std::option::Option<QUERY_CONTEXT_ATTRIBUTES_FN_A>,
17122     pub ImpersonateSecurityContext: ::std::option::Option<IMPERSONATE_SECURITY_CONTEXT_FN>,
17123     pub RevertSecurityContext: ::std::option::Option<REVERT_SECURITY_CONTEXT_FN>,
17124     pub MakeSignature: ::std::option::Option<MAKE_SIGNATURE_FN>,
17125     pub VerifySignature: ::std::option::Option<VERIFY_SIGNATURE_FN>,
17126     pub FreeContextBuffer: ::std::option::Option<FREE_CONTEXT_BUFFER_FN>,
17127     pub QuerySecurityPackageInfoA: ::std::option::Option<QUERY_SECURITY_PACKAGE_INFO_FN_A>,
17128     pub Reserved3: *mut ::std::ffi::c_void,
17129     pub Reserved4: *mut ::std::ffi::c_void,
17130     pub ExportSecurityContext: ::std::option::Option<EXPORT_SECURITY_CONTEXT_FN>,
17131     pub ImportSecurityContextA: ::std::option::Option<IMPORT_SECURITY_CONTEXT_FN_A>,
17132     pub AddCredentialsA: ::std::option::Option<ADD_CREDENTIALS_FN_A>,
17133     pub Reserved8: *mut ::std::ffi::c_void,
17134     pub QuerySecurityContextToken: ::std::option::Option<QUERY_SECURITY_CONTEXT_TOKEN_FN>,
17135     pub EncryptMessage: ::std::option::Option<ENCRYPT_MESSAGE_FN>,
17136     pub DecryptMessage: ::std::option::Option<DECRYPT_MESSAGE_FN>,
17137     pub SetContextAttributesA: ::std::option::Option<SET_CONTEXT_ATTRIBUTES_FN_A>,
17138     pub SetCredentialsAttributesA: ::std::option::Option<SET_CREDENTIALS_ATTRIBUTES_FN_A>,
17139     pub ChangeAccountPasswordA: ::std::option::Option<CHANGE_PASSWORD_FN_A>,
17140     pub QueryContextAttributesExA: ::std::option::Option<QUERY_CONTEXT_ATTRIBUTES_EX_FN_A>,
17141     pub QueryCredentialsAttributesExA: ::std::option::Option<QUERY_CREDENTIALS_ATTRIBUTES_EX_FN_A>,
17142 }
17143 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
17144 impl SecurityFunctionTableA {}
17145 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
17146 impl ::std::default::Default for SecurityFunctionTableA {
17147     fn default() -> Self {
17148         unsafe { ::std::mem::zeroed() }
17149     }
17150 }
17151 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
17152 impl ::std::fmt::Debug for SecurityFunctionTableA {
17153     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17154         fmt.debug_struct("SecurityFunctionTableA").field("dwVersion", &self.dwVersion).field("Reserved2", &self.Reserved2).field("Reserved3", &self.Reserved3).field("Reserved4", &self.Reserved4).field("Reserved8", &self.Reserved8).finish()
17155     }
17156 }
17157 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
17158 impl ::std::cmp::PartialEq for SecurityFunctionTableA {
17159     fn eq(&self, other: &Self) -> bool {
17160         self.dwVersion == other.dwVersion
17161             && self.EnumerateSecurityPackagesA.map(|f| f as usize) == other.EnumerateSecurityPackagesA.map(|f| f as usize)
17162             && self.QueryCredentialsAttributesA.map(|f| f as usize) == other.QueryCredentialsAttributesA.map(|f| f as usize)
17163             && self.AcquireCredentialsHandleA.map(|f| f as usize) == other.AcquireCredentialsHandleA.map(|f| f as usize)
17164             && self.FreeCredentialsHandle.map(|f| f as usize) == other.FreeCredentialsHandle.map(|f| f as usize)
17165             && self.Reserved2 == other.Reserved2
17166             && self.InitializeSecurityContextA.map(|f| f as usize) == other.InitializeSecurityContextA.map(|f| f as usize)
17167             && self.AcceptSecurityContext.map(|f| f as usize) == other.AcceptSecurityContext.map(|f| f as usize)
17168             && self.CompleteAuthToken.map(|f| f as usize) == other.CompleteAuthToken.map(|f| f as usize)
17169             && self.DeleteSecurityContext.map(|f| f as usize) == other.DeleteSecurityContext.map(|f| f as usize)
17170             && self.ApplyControlToken.map(|f| f as usize) == other.ApplyControlToken.map(|f| f as usize)
17171             && self.QueryContextAttributesA.map(|f| f as usize) == other.QueryContextAttributesA.map(|f| f as usize)
17172             && self.ImpersonateSecurityContext.map(|f| f as usize) == other.ImpersonateSecurityContext.map(|f| f as usize)
17173             && self.RevertSecurityContext.map(|f| f as usize) == other.RevertSecurityContext.map(|f| f as usize)
17174             && self.MakeSignature.map(|f| f as usize) == other.MakeSignature.map(|f| f as usize)
17175             && self.VerifySignature.map(|f| f as usize) == other.VerifySignature.map(|f| f as usize)
17176             && self.FreeContextBuffer.map(|f| f as usize) == other.FreeContextBuffer.map(|f| f as usize)
17177             && self.QuerySecurityPackageInfoA.map(|f| f as usize) == other.QuerySecurityPackageInfoA.map(|f| f as usize)
17178             && self.Reserved3 == other.Reserved3
17179             && self.Reserved4 == other.Reserved4
17180             && self.ExportSecurityContext.map(|f| f as usize) == other.ExportSecurityContext.map(|f| f as usize)
17181             && self.ImportSecurityContextA.map(|f| f as usize) == other.ImportSecurityContextA.map(|f| f as usize)
17182             && self.AddCredentialsA.map(|f| f as usize) == other.AddCredentialsA.map(|f| f as usize)
17183             && self.Reserved8 == other.Reserved8
17184             && self.QuerySecurityContextToken.map(|f| f as usize) == other.QuerySecurityContextToken.map(|f| f as usize)
17185             && self.EncryptMessage.map(|f| f as usize) == other.EncryptMessage.map(|f| f as usize)
17186             && self.DecryptMessage.map(|f| f as usize) == other.DecryptMessage.map(|f| f as usize)
17187             && self.SetContextAttributesA.map(|f| f as usize) == other.SetContextAttributesA.map(|f| f as usize)
17188             && self.SetCredentialsAttributesA.map(|f| f as usize) == other.SetCredentialsAttributesA.map(|f| f as usize)
17189             && self.ChangeAccountPasswordA.map(|f| f as usize) == other.ChangeAccountPasswordA.map(|f| f as usize)
17190             && self.QueryContextAttributesExA.map(|f| f as usize) == other.QueryContextAttributesExA.map(|f| f as usize)
17191             && self.QueryCredentialsAttributesExA.map(|f| f as usize) == other.QueryCredentialsAttributesExA.map(|f| f as usize)
17192     }
17193 }
17194 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
17195 impl ::std::cmp::Eq for SecurityFunctionTableA {}
17196 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
17197 unsafe impl ::windows::runtime::Abi for SecurityFunctionTableA {
17198     type Abi = ::std::mem::ManuallyDrop<Self>;
17199     type DefaultType = Self;
17200 }
17201 #[derive(:: std :: clone :: Clone)]
17202 #[repr(C)]
17203 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
17204 pub struct SecurityFunctionTableW {
17205     pub dwVersion: u32,
17206     pub EnumerateSecurityPackagesW: ::std::option::Option<ENUMERATE_SECURITY_PACKAGES_FN_W>,
17207     pub QueryCredentialsAttributesW: ::std::option::Option<QUERY_CREDENTIALS_ATTRIBUTES_FN_W>,
17208     pub AcquireCredentialsHandleW: ::std::option::Option<ACQUIRE_CREDENTIALS_HANDLE_FN_W>,
17209     pub FreeCredentialsHandle: ::std::option::Option<FREE_CREDENTIALS_HANDLE_FN>,
17210     pub Reserved2: *mut ::std::ffi::c_void,
17211     pub InitializeSecurityContextW: ::std::option::Option<INITIALIZE_SECURITY_CONTEXT_FN_W>,
17212     pub AcceptSecurityContext: ::std::option::Option<ACCEPT_SECURITY_CONTEXT_FN>,
17213     pub CompleteAuthToken: ::std::option::Option<COMPLETE_AUTH_TOKEN_FN>,
17214     pub DeleteSecurityContext: ::std::option::Option<DELETE_SECURITY_CONTEXT_FN>,
17215     pub ApplyControlToken: ::std::option::Option<APPLY_CONTROL_TOKEN_FN>,
17216     pub QueryContextAttributesW: ::std::option::Option<QUERY_CONTEXT_ATTRIBUTES_FN_W>,
17217     pub ImpersonateSecurityContext: ::std::option::Option<IMPERSONATE_SECURITY_CONTEXT_FN>,
17218     pub RevertSecurityContext: ::std::option::Option<REVERT_SECURITY_CONTEXT_FN>,
17219     pub MakeSignature: ::std::option::Option<MAKE_SIGNATURE_FN>,
17220     pub VerifySignature: ::std::option::Option<VERIFY_SIGNATURE_FN>,
17221     pub FreeContextBuffer: ::std::option::Option<FREE_CONTEXT_BUFFER_FN>,
17222     pub QuerySecurityPackageInfoW: ::std::option::Option<QUERY_SECURITY_PACKAGE_INFO_FN_W>,
17223     pub Reserved3: *mut ::std::ffi::c_void,
17224     pub Reserved4: *mut ::std::ffi::c_void,
17225     pub ExportSecurityContext: ::std::option::Option<EXPORT_SECURITY_CONTEXT_FN>,
17226     pub ImportSecurityContextW: ::std::option::Option<IMPORT_SECURITY_CONTEXT_FN_W>,
17227     pub AddCredentialsW: ::std::option::Option<ADD_CREDENTIALS_FN_W>,
17228     pub Reserved8: *mut ::std::ffi::c_void,
17229     pub QuerySecurityContextToken: ::std::option::Option<QUERY_SECURITY_CONTEXT_TOKEN_FN>,
17230     pub EncryptMessage: ::std::option::Option<ENCRYPT_MESSAGE_FN>,
17231     pub DecryptMessage: ::std::option::Option<DECRYPT_MESSAGE_FN>,
17232     pub SetContextAttributesW: ::std::option::Option<SET_CONTEXT_ATTRIBUTES_FN_W>,
17233     pub SetCredentialsAttributesW: ::std::option::Option<SET_CREDENTIALS_ATTRIBUTES_FN_W>,
17234     pub ChangeAccountPasswordW: ::std::option::Option<CHANGE_PASSWORD_FN_W>,
17235     pub QueryContextAttributesExW: ::std::option::Option<QUERY_CONTEXT_ATTRIBUTES_EX_FN_W>,
17236     pub QueryCredentialsAttributesExW: ::std::option::Option<QUERY_CREDENTIALS_ATTRIBUTES_EX_FN_W>,
17237 }
17238 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
17239 impl SecurityFunctionTableW {}
17240 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
17241 impl ::std::default::Default for SecurityFunctionTableW {
17242     fn default() -> Self {
17243         unsafe { ::std::mem::zeroed() }
17244     }
17245 }
17246 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
17247 impl ::std::fmt::Debug for SecurityFunctionTableW {
17248     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17249         fmt.debug_struct("SecurityFunctionTableW").field("dwVersion", &self.dwVersion).field("Reserved2", &self.Reserved2).field("Reserved3", &self.Reserved3).field("Reserved4", &self.Reserved4).field("Reserved8", &self.Reserved8).finish()
17250     }
17251 }
17252 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
17253 impl ::std::cmp::PartialEq for SecurityFunctionTableW {
17254     fn eq(&self, other: &Self) -> bool {
17255         self.dwVersion == other.dwVersion
17256             && self.EnumerateSecurityPackagesW.map(|f| f as usize) == other.EnumerateSecurityPackagesW.map(|f| f as usize)
17257             && self.QueryCredentialsAttributesW.map(|f| f as usize) == other.QueryCredentialsAttributesW.map(|f| f as usize)
17258             && self.AcquireCredentialsHandleW.map(|f| f as usize) == other.AcquireCredentialsHandleW.map(|f| f as usize)
17259             && self.FreeCredentialsHandle.map(|f| f as usize) == other.FreeCredentialsHandle.map(|f| f as usize)
17260             && self.Reserved2 == other.Reserved2
17261             && self.InitializeSecurityContextW.map(|f| f as usize) == other.InitializeSecurityContextW.map(|f| f as usize)
17262             && self.AcceptSecurityContext.map(|f| f as usize) == other.AcceptSecurityContext.map(|f| f as usize)
17263             && self.CompleteAuthToken.map(|f| f as usize) == other.CompleteAuthToken.map(|f| f as usize)
17264             && self.DeleteSecurityContext.map(|f| f as usize) == other.DeleteSecurityContext.map(|f| f as usize)
17265             && self.ApplyControlToken.map(|f| f as usize) == other.ApplyControlToken.map(|f| f as usize)
17266             && self.QueryContextAttributesW.map(|f| f as usize) == other.QueryContextAttributesW.map(|f| f as usize)
17267             && self.ImpersonateSecurityContext.map(|f| f as usize) == other.ImpersonateSecurityContext.map(|f| f as usize)
17268             && self.RevertSecurityContext.map(|f| f as usize) == other.RevertSecurityContext.map(|f| f as usize)
17269             && self.MakeSignature.map(|f| f as usize) == other.MakeSignature.map(|f| f as usize)
17270             && self.VerifySignature.map(|f| f as usize) == other.VerifySignature.map(|f| f as usize)
17271             && self.FreeContextBuffer.map(|f| f as usize) == other.FreeContextBuffer.map(|f| f as usize)
17272             && self.QuerySecurityPackageInfoW.map(|f| f as usize) == other.QuerySecurityPackageInfoW.map(|f| f as usize)
17273             && self.Reserved3 == other.Reserved3
17274             && self.Reserved4 == other.Reserved4
17275             && self.ExportSecurityContext.map(|f| f as usize) == other.ExportSecurityContext.map(|f| f as usize)
17276             && self.ImportSecurityContextW.map(|f| f as usize) == other.ImportSecurityContextW.map(|f| f as usize)
17277             && self.AddCredentialsW.map(|f| f as usize) == other.AddCredentialsW.map(|f| f as usize)
17278             && self.Reserved8 == other.Reserved8
17279             && self.QuerySecurityContextToken.map(|f| f as usize) == other.QuerySecurityContextToken.map(|f| f as usize)
17280             && self.EncryptMessage.map(|f| f as usize) == other.EncryptMessage.map(|f| f as usize)
17281             && self.DecryptMessage.map(|f| f as usize) == other.DecryptMessage.map(|f| f as usize)
17282             && self.SetContextAttributesW.map(|f| f as usize) == other.SetContextAttributesW.map(|f| f as usize)
17283             && self.SetCredentialsAttributesW.map(|f| f as usize) == other.SetCredentialsAttributesW.map(|f| f as usize)
17284             && self.ChangeAccountPasswordW.map(|f| f as usize) == other.ChangeAccountPasswordW.map(|f| f as usize)
17285             && self.QueryContextAttributesExW.map(|f| f as usize) == other.QueryContextAttributesExW.map(|f| f as usize)
17286             && self.QueryCredentialsAttributesExW.map(|f| f as usize) == other.QueryCredentialsAttributesExW.map(|f| f as usize)
17287     }
17288 }
17289 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
17290 impl ::std::cmp::Eq for SecurityFunctionTableW {}
17291 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials"))]
17292 unsafe impl ::windows::runtime::Abi for SecurityFunctionTableW {
17293     type Abi = ::std::mem::ManuallyDrop<Self>;
17294     type DefaultType = Self;
17295 }
17296 #[cfg(feature = "Win32_Security_Credentials")]
17297 #[inline]
17298 pub unsafe fn SetContextAttributesA(phcontext: *const super::super::Credentials::SecHandle, ulattribute: SECPKG_ATTR, pbuffer: *const ::std::ffi::c_void, cbbuffer: u32) -> i32 {
17299     #[cfg(windows)]
17300     {
17301         #[link(name = "windows")]
17302         extern "system" {
17303             fn SetContextAttributesA(phcontext: *const super::super::Credentials::SecHandle, ulattribute: SECPKG_ATTR, pbuffer: *const ::std::ffi::c_void, cbbuffer: u32) -> i32;
17304         }
17305         ::std::mem::transmute(SetContextAttributesA(::std::mem::transmute(phcontext), ::std::mem::transmute(ulattribute), ::std::mem::transmute(pbuffer), ::std::mem::transmute(cbbuffer)))
17306     }
17307     #[cfg(not(windows))]
17308     unimplemented!("Unsupported target OS");
17309 }
17310 #[cfg(feature = "Win32_Security_Credentials")]
17311 #[inline]
17312 pub unsafe fn SetContextAttributesW(phcontext: *const super::super::Credentials::SecHandle, ulattribute: SECPKG_ATTR, pbuffer: *const ::std::ffi::c_void, cbbuffer: u32) -> i32 {
17313     #[cfg(windows)]
17314     {
17315         #[link(name = "windows")]
17316         extern "system" {
17317             fn SetContextAttributesW(phcontext: *const super::super::Credentials::SecHandle, ulattribute: SECPKG_ATTR, pbuffer: *const ::std::ffi::c_void, cbbuffer: u32) -> i32;
17318         }
17319         ::std::mem::transmute(SetContextAttributesW(::std::mem::transmute(phcontext), ::std::mem::transmute(ulattribute), ::std::mem::transmute(pbuffer), ::std::mem::transmute(cbbuffer)))
17320     }
17321     #[cfg(not(windows))]
17322     unimplemented!("Unsupported target OS");
17323 }
17324 #[cfg(feature = "Win32_Security_Credentials")]
17325 #[inline]
17326 pub unsafe fn SetCredentialsAttributesA(phcredential: *const super::super::Credentials::SecHandle, ulattribute: u32, pbuffer: *const ::std::ffi::c_void, cbbuffer: u32) -> i32 {
17327     #[cfg(windows)]
17328     {
17329         #[link(name = "windows")]
17330         extern "system" {
17331             fn SetCredentialsAttributesA(phcredential: *const super::super::Credentials::SecHandle, ulattribute: u32, pbuffer: *const ::std::ffi::c_void, cbbuffer: u32) -> i32;
17332         }
17333         ::std::mem::transmute(SetCredentialsAttributesA(::std::mem::transmute(phcredential), ::std::mem::transmute(ulattribute), ::std::mem::transmute(pbuffer), ::std::mem::transmute(cbbuffer)))
17334     }
17335     #[cfg(not(windows))]
17336     unimplemented!("Unsupported target OS");
17337 }
17338 #[cfg(feature = "Win32_Security_Credentials")]
17339 #[inline]
17340 pub unsafe fn SetCredentialsAttributesW(phcredential: *const super::super::Credentials::SecHandle, ulattribute: u32, pbuffer: *const ::std::ffi::c_void, cbbuffer: u32) -> i32 {
17341     #[cfg(windows)]
17342     {
17343         #[link(name = "windows")]
17344         extern "system" {
17345             fn SetCredentialsAttributesW(phcredential: *const super::super::Credentials::SecHandle, ulattribute: u32, pbuffer: *const ::std::ffi::c_void, cbbuffer: u32) -> i32;
17346         }
17347         ::std::mem::transmute(SetCredentialsAttributesW(::std::mem::transmute(phcredential), ::std::mem::transmute(ulattribute), ::std::mem::transmute(pbuffer), ::std::mem::transmute(cbbuffer)))
17348     }
17349     #[cfg(not(windows))]
17350     unimplemented!("Unsupported target OS");
17351 }
17352 #[cfg(feature = "Win32_Foundation")]
17353 pub type SpAcceptCredentialsFn = unsafe extern "system" fn(logontype: SECURITY_LOGON_TYPE, accountname: *const super::super::super::Foundation::UNICODE_STRING, primarycredentials: *const SECPKG_PRIMARY_CRED, supplementalcredentials: *const SECPKG_SUPPLEMENTAL_CRED) -> super::super::super::Foundation::NTSTATUS;
17354 #[cfg(feature = "Win32_Foundation")]
17355 pub type SpAcceptLsaModeContextFn = unsafe extern "system" fn(credentialhandle: usize, contexthandle: usize, inputbuffer: *const SecBufferDesc, contextrequirements: u32, targetdatarep: u32, newcontexthandle: *mut usize, outputbuffer: *mut SecBufferDesc, contextattributes: *mut u32, expirationtime: *mut i64, mappedcontext: *mut super::super::super::Foundation::BOOLEAN, contextdata: *mut SecBuffer) -> super::super::super::Foundation::NTSTATUS;
17356 #[cfg(feature = "Win32_Foundation")]
17357 pub type SpAcquireCredentialsHandleFn = unsafe extern "system" fn(principalname: *const super::super::super::Foundation::UNICODE_STRING, credentialuseflags: u32, logonid: *const super::super::super::Foundation::LUID, authorizationdata: *const ::std::ffi::c_void, getkeyfunciton: *const ::std::ffi::c_void, getkeyargument: *const ::std::ffi::c_void, credentialhandle: *mut usize, expirationtime: *mut i64) -> super::super::super::Foundation::NTSTATUS;
17358 #[cfg(feature = "Win32_Foundation")]
17359 pub type SpAddCredentialsFn = unsafe extern "system" fn(credentialhandle: usize, principalname: *const super::super::super::Foundation::UNICODE_STRING, package: *const super::super::super::Foundation::UNICODE_STRING, credentialuseflags: u32, authorizationdata: *const ::std::ffi::c_void, getkeyfunciton: *const ::std::ffi::c_void, getkeyargument: *const ::std::ffi::c_void, expirationtime: *mut i64) -> super::super::super::Foundation::NTSTATUS;
17360 #[cfg(feature = "Win32_Foundation")]
17361 pub type SpApplyControlTokenFn = unsafe extern "system" fn(contexthandle: usize, controltoken: *const SecBufferDesc) -> super::super::super::Foundation::NTSTATUS;
17362 #[cfg(feature = "Win32_Foundation")]
17363 pub type SpChangeAccountPasswordFn = unsafe extern "system" fn(pdomainname: *const super::super::super::Foundation::UNICODE_STRING, paccountname: *const super::super::super::Foundation::UNICODE_STRING, poldpassword: *const super::super::super::Foundation::UNICODE_STRING, pnewpassword: *const super::super::super::Foundation::UNICODE_STRING, impersonating: super::super::super::Foundation::BOOLEAN, poutput: *mut SecBufferDesc) -> super::super::super::Foundation::NTSTATUS;
17364 #[cfg(feature = "Win32_Foundation")]
17365 pub type SpCompleteAuthTokenFn = unsafe extern "system" fn(contexthandle: usize, inputbuffer: *const SecBufferDesc) -> super::super::super::Foundation::NTSTATUS;
17366 #[cfg(feature = "Win32_Foundation")]
17367 pub type SpDeleteContextFn = unsafe extern "system" fn(contexthandle: usize) -> super::super::super::Foundation::NTSTATUS;
17368 #[cfg(feature = "Win32_Foundation")]
17369 pub type SpDeleteCredentialsFn = unsafe extern "system" fn(credentialhandle: usize, key: *const SecBuffer) -> super::super::super::Foundation::NTSTATUS;
17370 #[cfg(feature = "Win32_Foundation")]
17371 pub type SpExchangeMetaDataFn = unsafe extern "system" fn(credentialhandle: usize, targetname: *const super::super::super::Foundation::UNICODE_STRING, contextrequirements: u32, metadatalength: u32, metadata: *const u8, contexthandle: *mut usize) -> super::super::super::Foundation::NTSTATUS;
17372 #[cfg(feature = "Win32_Foundation")]
17373 pub type SpExportSecurityContextFn = unsafe extern "system" fn(phcontext: usize, fflags: u32, ppackedcontext: *mut SecBuffer, ptoken: *mut super::super::super::Foundation::HANDLE) -> super::super::super::Foundation::NTSTATUS;
17374 #[cfg(feature = "Win32_Foundation")]
17375 pub type SpFormatCredentialsFn = unsafe extern "system" fn(credentials: *const SecBuffer, formattedcredentials: *mut SecBuffer) -> super::super::super::Foundation::NTSTATUS;
17376 #[cfg(feature = "Win32_Foundation")]
17377 pub type SpFreeCredentialsHandleFn = unsafe extern "system" fn(credentialhandle: usize) -> super::super::super::Foundation::NTSTATUS;
17378 #[cfg(feature = "Win32_Foundation")]
17379 pub type SpGetContextTokenFn = unsafe extern "system" fn(contexthandle: usize, impersonationtoken: *mut super::super::super::Foundation::HANDLE) -> super::super::super::Foundation::NTSTATUS;
17380 #[cfg(feature = "Win32_Foundation")]
17381 pub type SpGetCredUIContextFn = unsafe extern "system" fn(contexthandle: usize, credtype: *const ::windows::runtime::GUID, flatcreduicontextlength: *mut u32, flatcreduicontext: *mut *mut u8) -> super::super::super::Foundation::NTSTATUS;
17382 #[cfg(feature = "Win32_Foundation")]
17383 pub type SpGetCredentialsFn = unsafe extern "system" fn(credentialhandle: usize, credentials: *mut SecBuffer) -> super::super::super::Foundation::NTSTATUS;
17384 #[cfg(feature = "Win32_Foundation")]
17385 pub type SpGetExtendedInformationFn = unsafe extern "system" fn(class: SECPKG_EXTENDED_INFORMATION_CLASS, ppinformation: *mut *mut SECPKG_EXTENDED_INFORMATION) -> super::super::super::Foundation::NTSTATUS;
17386 #[cfg(feature = "Win32_Foundation")]
17387 pub type SpGetInfoFn = unsafe extern "system" fn(packageinfo: *mut SecPkgInfoA) -> super::super::super::Foundation::NTSTATUS;
17388 #[cfg(feature = "Win32_Foundation")]
17389 pub type SpGetRemoteCredGuardLogonBufferFn = unsafe extern "system" fn(credhandle: usize, contexthandle: usize, targetname: *const super::super::super::Foundation::UNICODE_STRING, redirectedlogonhandle: *mut super::super::super::Foundation::HANDLE, callback: *mut ::windows::runtime::RawPtr, cleanupcallback: *mut ::windows::runtime::RawPtr, logonbuffersize: *mut u32, logonbuffer: *mut *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
17390 #[cfg(feature = "Win32_Foundation")]
17391 pub type SpGetRemoteCredGuardSupplementalCredsFn = unsafe extern "system" fn(credhandle: usize, targetname: *const super::super::super::Foundation::UNICODE_STRING, redirectedlogonhandle: *mut super::super::super::Foundation::HANDLE, callback: *mut ::windows::runtime::RawPtr, cleanupcallback: *mut ::windows::runtime::RawPtr, supplementalcredssize: *mut u32, supplementalcreds: *mut *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
17392 #[cfg(feature = "Win32_Foundation")]
17393 pub type SpGetTbalSupplementalCredsFn = unsafe extern "system" fn(logonid: super::super::super::Foundation::LUID, supplementalcredssize: *mut u32, supplementalcreds: *mut *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
17394 #[cfg(feature = "Win32_Foundation")]
17395 pub type SpGetUserInfoFn = unsafe extern "system" fn(logonid: *const super::super::super::Foundation::LUID, flags: u32, userdata: *mut *mut SECURITY_USER_DATA) -> super::super::super::Foundation::NTSTATUS;
17396 #[cfg(feature = "Win32_Foundation")]
17397 pub type SpImportSecurityContextFn = unsafe extern "system" fn(ppackedcontext: *const SecBuffer, token: super::super::super::Foundation::HANDLE, phcontext: *mut usize) -> super::super::super::Foundation::NTSTATUS;
17398 #[cfg(feature = "Win32_Foundation")]
17399 pub type SpInitLsaModeContextFn =
17400     unsafe extern "system" fn(credentialhandle: usize, contexthandle: usize, targetname: *const super::super::super::Foundation::UNICODE_STRING, contextrequirements: u32, targetdatarep: u32, inputbuffers: *const SecBufferDesc, newcontexthandle: *mut usize, outputbuffers: *mut SecBufferDesc, contextattributes: *mut u32, expirationtime: *mut i64, mappedcontext: *mut super::super::super::Foundation::BOOLEAN, contextdata: *mut SecBuffer) -> super::super::super::Foundation::NTSTATUS;
17401 #[cfg(feature = "Win32_Foundation")]
17402 pub type SpInitUserModeContextFn = unsafe extern "system" fn(contexthandle: usize, packedcontext: *const SecBuffer) -> super::super::super::Foundation::NTSTATUS;
17403 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials", feature = "Win32_System_Kernel", feature = "Win32_System_SystemServices"))]
17404 pub type SpInitializeFn = unsafe extern "system" fn(packageid: usize, parameters: *const SECPKG_PARAMETERS, functiontable: *const ::std::mem::ManuallyDrop<LSA_SECPKG_FUNCTION_TABLE>) -> super::super::super::Foundation::NTSTATUS;
17405 #[cfg(feature = "Win32_Foundation")]
17406 pub type SpInstanceInitFn = unsafe extern "system" fn(version: u32, functiontable: *const ::std::mem::ManuallyDrop<SECPKG_DLL_FUNCTIONS>, userfunctions: *mut *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
17407 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Credentials", feature = "Win32_System_Kernel", feature = "Win32_System_SystemServices"))]
17408 pub type SpLsaModeInitializeFn = unsafe extern "system" fn(lsaversion: u32, packageversion: *mut u32, pptables: *mut *mut SECPKG_FUNCTION_TABLE, pctables: *mut u32) -> super::super::super::Foundation::NTSTATUS;
17409 #[cfg(feature = "Win32_Foundation")]
17410 pub type SpMakeSignatureFn = unsafe extern "system" fn(contexthandle: usize, qualityofprotection: u32, messagebuffers: *const SecBufferDesc, messagesequencenumber: u32) -> super::super::super::Foundation::NTSTATUS;
17411 #[cfg(feature = "Win32_Foundation")]
17412 pub type SpMarshalAttributeDataFn = unsafe extern "system" fn(attributeinfo: u32, attribute: u32, attributedatasize: u32, attributedata: *const u8, marshaledattributedatasize: *mut u32, marshaledattributedata: *mut *mut u8) -> super::super::super::Foundation::NTSTATUS;
17413 #[cfg(feature = "Win32_Foundation")]
17414 pub type SpMarshallSupplementalCredsFn = unsafe extern "system" fn(credentialsize: u32, credentials: *const u8, marshalledcredsize: *mut u32, marshalledcreds: *mut *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
17415 #[cfg(feature = "Win32_Foundation")]
17416 pub type SpQueryContextAttributesFn = unsafe extern "system" fn(contexthandle: usize, contextattribute: u32, buffer: *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
17417 #[cfg(feature = "Win32_Foundation")]
17418 pub type SpQueryCredentialsAttributesFn = unsafe extern "system" fn(credentialhandle: usize, credentialattribute: u32, buffer: *mut ::std::ffi::c_void) -> super::super::super::Foundation::NTSTATUS;
17419 #[cfg(feature = "Win32_Foundation")]
17420 pub type SpQueryMetaDataFn = unsafe extern "system" fn(credentialhandle: usize, targetname: *const super::super::super::Foundation::UNICODE_STRING, contextrequirements: u32, metadatalength: *mut u32, metadata: *mut *mut u8, contexthandle: *mut usize) -> super::super::super::Foundation::NTSTATUS;
17421 #[cfg(feature = "Win32_Foundation")]
17422 pub type SpSaveCredentialsFn = unsafe extern "system" fn(credentialhandle: usize, credentials: *const SecBuffer) -> super::super::super::Foundation::NTSTATUS;
17423 #[cfg(feature = "Win32_Foundation")]
17424 pub type SpSealMessageFn = unsafe extern "system" fn(contexthandle: usize, qualityofprotection: u32, messagebuffers: *const SecBufferDesc, messagesequencenumber: u32) -> super::super::super::Foundation::NTSTATUS;
17425 #[cfg(feature = "Win32_Foundation")]
17426 pub type SpSetContextAttributesFn = unsafe extern "system" fn(contexthandle: usize, contextattribute: u32, buffer: *const ::std::ffi::c_void, buffersize: u32) -> super::super::super::Foundation::NTSTATUS;
17427 #[cfg(feature = "Win32_Foundation")]
17428 pub type SpSetCredentialsAttributesFn = unsafe extern "system" fn(credentialhandle: usize, credentialattribute: u32, buffer: *const ::std::ffi::c_void, buffersize: u32) -> super::super::super::Foundation::NTSTATUS;
17429 #[cfg(feature = "Win32_Foundation")]
17430 pub type SpSetExtendedInformationFn = unsafe extern "system" fn(class: SECPKG_EXTENDED_INFORMATION_CLASS, info: *const SECPKG_EXTENDED_INFORMATION) -> super::super::super::Foundation::NTSTATUS;
17431 #[cfg(feature = "Win32_Foundation")]
17432 pub type SpShutdownFn = unsafe extern "system" fn() -> super::super::super::Foundation::NTSTATUS;
17433 #[cfg(feature = "Win32_Foundation")]
17434 pub type SpUnsealMessageFn = unsafe extern "system" fn(contexthandle: usize, messagebuffers: *const SecBufferDesc, messagesequencenumber: u32, qualityofprotection: *mut u32) -> super::super::super::Foundation::NTSTATUS;
17435 #[cfg(feature = "Win32_Foundation")]
17436 pub type SpUpdateCredentialsFn = unsafe extern "system" fn(contexthandle: usize, credtype: *const ::windows::runtime::GUID, flatcreduicontextlength: u32, flatcreduicontext: *const u8) -> super::super::super::Foundation::NTSTATUS;
17437 #[cfg(feature = "Win32_Foundation")]
17438 pub type SpUserModeInitializeFn = unsafe extern "system" fn(lsaversion: u32, packageversion: *mut u32, pptables: *mut *mut SECPKG_USER_FUNCTION_TABLE, pctables: *mut u32) -> super::super::super::Foundation::NTSTATUS;
17439 #[cfg(feature = "Win32_Foundation")]
17440 pub type SpValidateTargetInfoFn = unsafe extern "system" fn(clientrequest: *const *const ::std::ffi::c_void, protocolsubmitbuffer: *const ::std::ffi::c_void, clientbufferbase: *const ::std::ffi::c_void, submitbufferlength: u32, targetinfo: *const SECPKG_TARGETINFO) -> super::super::super::Foundation::NTSTATUS;
17441 #[cfg(feature = "Win32_Foundation")]
17442 pub type SpVerifySignatureFn = unsafe extern "system" fn(contexthandle: usize, messagebuffers: *const SecBufferDesc, messagesequencenumber: u32, qualityofprotection: *mut u32) -> super::super::super::Foundation::NTSTATUS;
17443 #[cfg(feature = "Win32_Foundation")]
17444 #[inline]
17445 pub unsafe fn SslCrackCertificate(pbcertificate: *mut u8, cbcertificate: u32, dwflags: u32, ppcertificate: *mut *mut X509Certificate) -> super::super::super::Foundation::BOOL {
17446     #[cfg(windows)]
17447     {
17448         #[link(name = "windows")]
17449         extern "system" {
17450             fn SslCrackCertificate(pbcertificate: *mut u8, cbcertificate: u32, dwflags: u32, ppcertificate: *mut *mut X509Certificate) -> super::super::super::Foundation::BOOL;
17451         }
17452         ::std::mem::transmute(SslCrackCertificate(::std::mem::transmute(pbcertificate), ::std::mem::transmute(cbcertificate), ::std::mem::transmute(dwflags), ::std::mem::transmute(ppcertificate)))
17453     }
17454     #[cfg(not(windows))]
17455     unimplemented!("Unsupported target OS");
17456 }
17457 #[cfg(feature = "Win32_Foundation")]
17458 #[inline]
17459 pub unsafe fn SslEmptyCacheA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSTR>>(psztargetname: Param0, dwflags: u32) -> super::super::super::Foundation::BOOL {
17460     #[cfg(windows)]
17461     {
17462         #[link(name = "windows")]
17463         extern "system" {
17464             fn SslEmptyCacheA(psztargetname: super::super::super::Foundation::PSTR, dwflags: u32) -> super::super::super::Foundation::BOOL;
17465         }
17466         ::std::mem::transmute(SslEmptyCacheA(psztargetname.into_param().abi(), ::std::mem::transmute(dwflags)))
17467     }
17468     #[cfg(not(windows))]
17469     unimplemented!("Unsupported target OS");
17470 }
17471 #[cfg(feature = "Win32_Foundation")]
17472 #[inline]
17473 pub unsafe fn SslEmptyCacheW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(psztargetname: Param0, dwflags: u32) -> super::super::super::Foundation::BOOL {
17474     #[cfg(windows)]
17475     {
17476         #[link(name = "windows")]
17477         extern "system" {
17478             fn SslEmptyCacheW(psztargetname: super::super::super::Foundation::PWSTR, dwflags: u32) -> super::super::super::Foundation::BOOL;
17479         }
17480         ::std::mem::transmute(SslEmptyCacheW(psztargetname.into_param().abi(), ::std::mem::transmute(dwflags)))
17481     }
17482     #[cfg(not(windows))]
17483     unimplemented!("Unsupported target OS");
17484 }
17485 #[cfg(feature = "Win32_Foundation")]
17486 #[inline]
17487 pub unsafe fn SslFreeCertificate(pcertificate: *mut X509Certificate) {
17488     #[cfg(windows)]
17489     {
17490         #[link(name = "windows")]
17491         extern "system" {
17492             fn SslFreeCertificate(pcertificate: *mut X509Certificate);
17493         }
17494         ::std::mem::transmute(SslFreeCertificate(::std::mem::transmute(pcertificate)))
17495     }
17496     #[cfg(not(windows))]
17497     unimplemented!("Unsupported target OS");
17498 }
17499 #[inline]
17500 pub unsafe fn SslGenerateRandomBits(prandomdata: *mut u8, crandomdata: i32) {
17501     #[cfg(windows)]
17502     {
17503         #[link(name = "windows")]
17504         extern "system" {
17505             fn SslGenerateRandomBits(prandomdata: *mut u8, crandomdata: i32);
17506         }
17507         ::std::mem::transmute(SslGenerateRandomBits(::std::mem::transmute(prandomdata), ::std::mem::transmute(crandomdata)))
17508     }
17509     #[cfg(not(windows))]
17510     unimplemented!("Unsupported target OS");
17511 }
17512 #[inline]
17513 pub unsafe fn SslGetExtensions(clienthello: *const u8, clienthellobytesize: u32, genericextensions: *mut SCH_EXTENSION_DATA, genericextensionscount: u8, bytestoread: *mut u32, flags: SchGetExtensionsOptions) -> i32 {
17514     #[cfg(windows)]
17515     {
17516         #[link(name = "windows")]
17517         extern "system" {
17518             fn SslGetExtensions(clienthello: *const u8, clienthellobytesize: u32, genericextensions: *mut SCH_EXTENSION_DATA, genericextensionscount: u8, bytestoread: *mut u32, flags: SchGetExtensionsOptions) -> i32;
17519         }
17520         ::std::mem::transmute(SslGetExtensions(::std::mem::transmute(clienthello), ::std::mem::transmute(clienthellobytesize), ::std::mem::transmute(genericextensions), ::std::mem::transmute(genericextensionscount), ::std::mem::transmute(bytestoread), ::std::mem::transmute(flags)))
17521     }
17522     #[cfg(not(windows))]
17523     unimplemented!("Unsupported target OS");
17524 }
17525 pub type SslGetExtensionsFn = unsafe extern "system" fn(clienthello: *const u8, clienthellobytesize: u32, genericextensions: *mut SCH_EXTENSION_DATA, genericextensionscount: u8, bytestoread: *mut u32, flags: SchGetExtensionsOptions) -> i32;
17526 #[inline]
17527 pub unsafe fn SslGetMaximumKeySize(reserved: u32) -> u32 {
17528     #[cfg(windows)]
17529     {
17530         #[link(name = "windows")]
17531         extern "system" {
17532             fn SslGetMaximumKeySize(reserved: u32) -> u32;
17533         }
17534         ::std::mem::transmute(SslGetMaximumKeySize(::std::mem::transmute(reserved)))
17535     }
17536     #[cfg(not(windows))]
17537     unimplemented!("Unsupported target OS");
17538 }
17539 #[inline]
17540 pub unsafe fn SslGetServerIdentity(clienthello: *const u8, clienthellosize: u32, serveridentity: *mut *mut u8, serveridentitysize: *mut u32, flags: u32) -> i32 {
17541     #[cfg(windows)]
17542     {
17543         #[link(name = "windows")]
17544         extern "system" {
17545             fn SslGetServerIdentity(clienthello: *const u8, clienthellosize: u32, serveridentity: *mut *mut u8, serveridentitysize: *mut u32, flags: u32) -> i32;
17546         }
17547         ::std::mem::transmute(SslGetServerIdentity(::std::mem::transmute(clienthello), ::std::mem::transmute(clienthellosize), ::std::mem::transmute(serveridentity), ::std::mem::transmute(serveridentitysize), ::std::mem::transmute(flags)))
17548     }
17549     #[cfg(not(windows))]
17550     unimplemented!("Unsupported target OS");
17551 }
17552 pub type SslGetServerIdentityFn = unsafe extern "system" fn(clienthello: *const u8, clienthellosize: u32, serveridentity: *mut *mut u8, serveridentitysize: *mut u32, flags: u32) -> i32;
17553 #[cfg(feature = "Win32_Foundation")]
17554 #[inline]
17555 pub unsafe fn SspiCompareAuthIdentities(authidentity1: *const ::std::ffi::c_void, authidentity2: *const ::std::ffi::c_void, samesupplieduser: *mut super::super::super::Foundation::BOOLEAN, samesuppliedidentity: *mut super::super::super::Foundation::BOOLEAN) -> i32 {
17556     #[cfg(windows)]
17557     {
17558         #[link(name = "windows")]
17559         extern "system" {
17560             fn SspiCompareAuthIdentities(authidentity1: *const ::std::ffi::c_void, authidentity2: *const ::std::ffi::c_void, samesupplieduser: *mut super::super::super::Foundation::BOOLEAN, samesuppliedidentity: *mut super::super::super::Foundation::BOOLEAN) -> i32;
17561         }
17562         ::std::mem::transmute(SspiCompareAuthIdentities(::std::mem::transmute(authidentity1), ::std::mem::transmute(authidentity2), ::std::mem::transmute(samesupplieduser), ::std::mem::transmute(samesuppliedidentity)))
17563     }
17564     #[cfg(not(windows))]
17565     unimplemented!("Unsupported target OS");
17566 }
17567 #[inline]
17568 pub unsafe fn SspiCopyAuthIdentity(authdata: *const ::std::ffi::c_void, authdatacopy: *mut *mut ::std::ffi::c_void) -> i32 {
17569     #[cfg(windows)]
17570     {
17571         #[link(name = "windows")]
17572         extern "system" {
17573             fn SspiCopyAuthIdentity(authdata: *const ::std::ffi::c_void, authdatacopy: *mut *mut ::std::ffi::c_void) -> i32;
17574         }
17575         ::std::mem::transmute(SspiCopyAuthIdentity(::std::mem::transmute(authdata), ::std::mem::transmute(authdatacopy)))
17576     }
17577     #[cfg(not(windows))]
17578     unimplemented!("Unsupported target OS");
17579 }
17580 #[inline]
17581 pub unsafe fn SspiDecryptAuthIdentity(encryptedauthdata: *mut ::std::ffi::c_void) -> i32 {
17582     #[cfg(windows)]
17583     {
17584         #[link(name = "windows")]
17585         extern "system" {
17586             fn SspiDecryptAuthIdentity(encryptedauthdata: *mut ::std::ffi::c_void) -> i32;
17587         }
17588         ::std::mem::transmute(SspiDecryptAuthIdentity(::std::mem::transmute(encryptedauthdata)))
17589     }
17590     #[cfg(not(windows))]
17591     unimplemented!("Unsupported target OS");
17592 }
17593 #[inline]
17594 pub unsafe fn SspiDecryptAuthIdentityEx(options: u32, encryptedauthdata: *mut ::std::ffi::c_void) -> i32 {
17595     #[cfg(windows)]
17596     {
17597         #[link(name = "windows")]
17598         extern "system" {
17599             fn SspiDecryptAuthIdentityEx(options: u32, encryptedauthdata: *mut ::std::ffi::c_void) -> i32;
17600         }
17601         ::std::mem::transmute(SspiDecryptAuthIdentityEx(::std::mem::transmute(options), ::std::mem::transmute(encryptedauthdata)))
17602     }
17603     #[cfg(not(windows))]
17604     unimplemented!("Unsupported target OS");
17605 }
17606 #[cfg(feature = "Win32_Foundation")]
17607 #[inline]
17608 pub unsafe fn SspiEncodeAuthIdentityAsStrings(pauthidentity: *const ::std::ffi::c_void, ppszusername: *mut super::super::super::Foundation::PWSTR, ppszdomainname: *mut super::super::super::Foundation::PWSTR, ppszpackedcredentialsstring: *mut super::super::super::Foundation::PWSTR) -> i32 {
17609     #[cfg(windows)]
17610     {
17611         #[link(name = "windows")]
17612         extern "system" {
17613             fn SspiEncodeAuthIdentityAsStrings(pauthidentity: *const ::std::ffi::c_void, ppszusername: *mut super::super::super::Foundation::PWSTR, ppszdomainname: *mut super::super::super::Foundation::PWSTR, ppszpackedcredentialsstring: *mut super::super::super::Foundation::PWSTR) -> i32;
17614         }
17615         ::std::mem::transmute(SspiEncodeAuthIdentityAsStrings(::std::mem::transmute(pauthidentity), ::std::mem::transmute(ppszusername), ::std::mem::transmute(ppszdomainname), ::std::mem::transmute(ppszpackedcredentialsstring)))
17616     }
17617     #[cfg(not(windows))]
17618     unimplemented!("Unsupported target OS");
17619 }
17620 #[cfg(feature = "Win32_Foundation")]
17621 #[inline]
17622 pub unsafe fn SspiEncodeStringsAsAuthIdentity<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(pszusername: Param0, pszdomainname: Param1, pszpackedcredentialsstring: Param2, ppauthidentity: *mut *mut ::std::ffi::c_void) -> i32 {
17623     #[cfg(windows)]
17624     {
17625         #[link(name = "windows")]
17626         extern "system" {
17627             fn SspiEncodeStringsAsAuthIdentity(pszusername: super::super::super::Foundation::PWSTR, pszdomainname: super::super::super::Foundation::PWSTR, pszpackedcredentialsstring: super::super::super::Foundation::PWSTR, ppauthidentity: *mut *mut ::std::ffi::c_void) -> i32;
17628         }
17629         ::std::mem::transmute(SspiEncodeStringsAsAuthIdentity(pszusername.into_param().abi(), pszdomainname.into_param().abi(), pszpackedcredentialsstring.into_param().abi(), ::std::mem::transmute(ppauthidentity)))
17630     }
17631     #[cfg(not(windows))]
17632     unimplemented!("Unsupported target OS");
17633 }
17634 #[inline]
17635 pub unsafe fn SspiEncryptAuthIdentity(authdata: *mut ::std::ffi::c_void) -> i32 {
17636     #[cfg(windows)]
17637     {
17638         #[link(name = "windows")]
17639         extern "system" {
17640             fn SspiEncryptAuthIdentity(authdata: *mut ::std::ffi::c_void) -> i32;
17641         }
17642         ::std::mem::transmute(SspiEncryptAuthIdentity(::std::mem::transmute(authdata)))
17643     }
17644     #[cfg(not(windows))]
17645     unimplemented!("Unsupported target OS");
17646 }
17647 #[inline]
17648 pub unsafe fn SspiEncryptAuthIdentityEx(options: u32, authdata: *mut ::std::ffi::c_void) -> i32 {
17649     #[cfg(windows)]
17650     {
17651         #[link(name = "windows")]
17652         extern "system" {
17653             fn SspiEncryptAuthIdentityEx(options: u32, authdata: *mut ::std::ffi::c_void) -> i32;
17654         }
17655         ::std::mem::transmute(SspiEncryptAuthIdentityEx(::std::mem::transmute(options), ::std::mem::transmute(authdata)))
17656     }
17657     #[cfg(not(windows))]
17658     unimplemented!("Unsupported target OS");
17659 }
17660 #[cfg(feature = "Win32_Foundation")]
17661 #[inline]
17662 pub unsafe fn SspiExcludePackage<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(authidentity: *const ::std::ffi::c_void, pszpackagename: Param1, ppnewauthidentity: *mut *mut ::std::ffi::c_void) -> i32 {
17663     #[cfg(windows)]
17664     {
17665         #[link(name = "windows")]
17666         extern "system" {
17667             fn SspiExcludePackage(authidentity: *const ::std::ffi::c_void, pszpackagename: super::super::super::Foundation::PWSTR, ppnewauthidentity: *mut *mut ::std::ffi::c_void) -> i32;
17668         }
17669         ::std::mem::transmute(SspiExcludePackage(::std::mem::transmute(authidentity), pszpackagename.into_param().abi(), ::std::mem::transmute(ppnewauthidentity)))
17670     }
17671     #[cfg(not(windows))]
17672     unimplemented!("Unsupported target OS");
17673 }
17674 #[inline]
17675 pub unsafe fn SspiFreeAuthIdentity(authdata: *const ::std::ffi::c_void) {
17676     #[cfg(windows)]
17677     {
17678         #[link(name = "windows")]
17679         extern "system" {
17680             fn SspiFreeAuthIdentity(authdata: *const ::std::ffi::c_void);
17681         }
17682         ::std::mem::transmute(SspiFreeAuthIdentity(::std::mem::transmute(authdata)))
17683     }
17684     #[cfg(not(windows))]
17685     unimplemented!("Unsupported target OS");
17686 }
17687 #[cfg(feature = "Win32_Foundation")]
17688 #[inline]
17689 pub unsafe fn SspiGetTargetHostName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(psztargetname: Param0, pszhostname: *mut super::super::super::Foundation::PWSTR) -> i32 {
17690     #[cfg(windows)]
17691     {
17692         #[link(name = "windows")]
17693         extern "system" {
17694             fn SspiGetTargetHostName(psztargetname: super::super::super::Foundation::PWSTR, pszhostname: *mut super::super::super::Foundation::PWSTR) -> i32;
17695         }
17696         ::std::mem::transmute(SspiGetTargetHostName(psztargetname.into_param().abi(), ::std::mem::transmute(pszhostname)))
17697     }
17698     #[cfg(not(windows))]
17699     unimplemented!("Unsupported target OS");
17700 }
17701 #[cfg(feature = "Win32_Foundation")]
17702 #[inline]
17703 pub unsafe fn SspiIsAuthIdentityEncrypted(encryptedauthdata: *const ::std::ffi::c_void) -> super::super::super::Foundation::BOOLEAN {
17704     #[cfg(windows)]
17705     {
17706         #[link(name = "windows")]
17707         extern "system" {
17708             fn SspiIsAuthIdentityEncrypted(encryptedauthdata: *const ::std::ffi::c_void) -> super::super::super::Foundation::BOOLEAN;
17709         }
17710         ::std::mem::transmute(SspiIsAuthIdentityEncrypted(::std::mem::transmute(encryptedauthdata)))
17711     }
17712     #[cfg(not(windows))]
17713     unimplemented!("Unsupported target OS");
17714 }
17715 #[cfg(feature = "Win32_Foundation")]
17716 #[inline]
17717 pub unsafe fn SspiIsPromptingNeeded(errororntstatus: u32) -> super::super::super::Foundation::BOOLEAN {
17718     #[cfg(windows)]
17719     {
17720         #[link(name = "windows")]
17721         extern "system" {
17722             fn SspiIsPromptingNeeded(errororntstatus: u32) -> super::super::super::Foundation::BOOLEAN;
17723         }
17724         ::std::mem::transmute(SspiIsPromptingNeeded(::std::mem::transmute(errororntstatus)))
17725     }
17726     #[cfg(not(windows))]
17727     unimplemented!("Unsupported target OS");
17728 }
17729 #[inline]
17730 pub unsafe fn SspiLocalFree(databuffer: *const ::std::ffi::c_void) {
17731     #[cfg(windows)]
17732     {
17733         #[link(name = "windows")]
17734         extern "system" {
17735             fn SspiLocalFree(databuffer: *const ::std::ffi::c_void);
17736         }
17737         ::std::mem::transmute(SspiLocalFree(::std::mem::transmute(databuffer)))
17738     }
17739     #[cfg(not(windows))]
17740     unimplemented!("Unsupported target OS");
17741 }
17742 #[inline]
17743 pub unsafe fn SspiMarshalAuthIdentity(authidentity: *const ::std::ffi::c_void, authidentitylength: *mut u32, authidentitybytearray: *mut *mut i8) -> i32 {
17744     #[cfg(windows)]
17745     {
17746         #[link(name = "windows")]
17747         extern "system" {
17748             fn SspiMarshalAuthIdentity(authidentity: *const ::std::ffi::c_void, authidentitylength: *mut u32, authidentitybytearray: *mut *mut i8) -> i32;
17749         }
17750         ::std::mem::transmute(SspiMarshalAuthIdentity(::std::mem::transmute(authidentity), ::std::mem::transmute(authidentitylength), ::std::mem::transmute(authidentitybytearray)))
17751     }
17752     #[cfg(not(windows))]
17753     unimplemented!("Unsupported target OS");
17754 }
17755 #[cfg(feature = "Win32_Foundation")]
17756 #[inline]
17757 pub unsafe fn SspiPrepareForCredRead<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(authidentity: *const ::std::ffi::c_void, psztargetname: Param1, pcredmancredentialtype: *mut u32, ppszcredmantargetname: *mut super::super::super::Foundation::PWSTR) -> i32 {
17758     #[cfg(windows)]
17759     {
17760         #[link(name = "windows")]
17761         extern "system" {
17762             fn SspiPrepareForCredRead(authidentity: *const ::std::ffi::c_void, psztargetname: super::super::super::Foundation::PWSTR, pcredmancredentialtype: *mut u32, ppszcredmantargetname: *mut super::super::super::Foundation::PWSTR) -> i32;
17763         }
17764         ::std::mem::transmute(SspiPrepareForCredRead(::std::mem::transmute(authidentity), psztargetname.into_param().abi(), ::std::mem::transmute(pcredmancredentialtype), ::std::mem::transmute(ppszcredmantargetname)))
17765     }
17766     #[cfg(not(windows))]
17767     unimplemented!("Unsupported target OS");
17768 }
17769 #[cfg(feature = "Win32_Foundation")]
17770 #[inline]
17771 pub unsafe fn SspiPrepareForCredWrite<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(authidentity: *const ::std::ffi::c_void, psztargetname: Param1, pcredmancredentialtype: *mut u32, ppszcredmantargetname: *mut super::super::super::Foundation::PWSTR, ppszcredmanusername: *mut super::super::super::Foundation::PWSTR, ppcredentialblob: *mut *mut u8, pcredentialblobsize: *mut u32) -> i32 {
17772     #[cfg(windows)]
17773     {
17774         #[link(name = "windows")]
17775         extern "system" {
17776             fn SspiPrepareForCredWrite(authidentity: *const ::std::ffi::c_void, psztargetname: super::super::super::Foundation::PWSTR, pcredmancredentialtype: *mut u32, ppszcredmantargetname: *mut super::super::super::Foundation::PWSTR, ppszcredmanusername: *mut super::super::super::Foundation::PWSTR, ppcredentialblob: *mut *mut u8, pcredentialblobsize: *mut u32) -> i32;
17777         }
17778         ::std::mem::transmute(SspiPrepareForCredWrite(
17779             ::std::mem::transmute(authidentity),
17780             psztargetname.into_param().abi(),
17781             ::std::mem::transmute(pcredmancredentialtype),
17782             ::std::mem::transmute(ppszcredmantargetname),
17783             ::std::mem::transmute(ppszcredmanusername),
17784             ::std::mem::transmute(ppcredentialblob),
17785             ::std::mem::transmute(pcredentialblobsize),
17786         ))
17787     }
17788     #[cfg(not(windows))]
17789     unimplemented!("Unsupported target OS");
17790 }
17791 #[cfg(feature = "Win32_Foundation")]
17792 #[inline]
17793 pub unsafe fn SspiPromptForCredentialsA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSTR>>(psztargetname: Param0, puiinfo: *const ::std::ffi::c_void, dwautherror: u32, pszpackage: Param3, pinputauthidentity: *const ::std::ffi::c_void, ppauthidentity: *mut *mut ::std::ffi::c_void, pfsave: *mut i32, dwflags: u32) -> u32 {
17794     #[cfg(windows)]
17795     {
17796         #[link(name = "windows")]
17797         extern "system" {
17798             fn SspiPromptForCredentialsA(psztargetname: super::super::super::Foundation::PSTR, puiinfo: *const ::std::ffi::c_void, dwautherror: u32, pszpackage: super::super::super::Foundation::PSTR, pinputauthidentity: *const ::std::ffi::c_void, ppauthidentity: *mut *mut ::std::ffi::c_void, pfsave: *mut i32, dwflags: u32) -> u32;
17799         }
17800         ::std::mem::transmute(SspiPromptForCredentialsA(
17801             psztargetname.into_param().abi(),
17802             ::std::mem::transmute(puiinfo),
17803             ::std::mem::transmute(dwautherror),
17804             pszpackage.into_param().abi(),
17805             ::std::mem::transmute(pinputauthidentity),
17806             ::std::mem::transmute(ppauthidentity),
17807             ::std::mem::transmute(pfsave),
17808             ::std::mem::transmute(dwflags),
17809         ))
17810     }
17811     #[cfg(not(windows))]
17812     unimplemented!("Unsupported target OS");
17813 }
17814 #[cfg(feature = "Win32_Foundation")]
17815 #[inline]
17816 pub unsafe fn SspiPromptForCredentialsW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(psztargetname: Param0, puiinfo: *const ::std::ffi::c_void, dwautherror: u32, pszpackage: Param3, pinputauthidentity: *const ::std::ffi::c_void, ppauthidentity: *mut *mut ::std::ffi::c_void, pfsave: *mut i32, dwflags: u32) -> u32 {
17817     #[cfg(windows)]
17818     {
17819         #[link(name = "windows")]
17820         extern "system" {
17821             fn SspiPromptForCredentialsW(psztargetname: super::super::super::Foundation::PWSTR, puiinfo: *const ::std::ffi::c_void, dwautherror: u32, pszpackage: super::super::super::Foundation::PWSTR, pinputauthidentity: *const ::std::ffi::c_void, ppauthidentity: *mut *mut ::std::ffi::c_void, pfsave: *mut i32, dwflags: u32) -> u32;
17822         }
17823         ::std::mem::transmute(SspiPromptForCredentialsW(
17824             psztargetname.into_param().abi(),
17825             ::std::mem::transmute(puiinfo),
17826             ::std::mem::transmute(dwautherror),
17827             pszpackage.into_param().abi(),
17828             ::std::mem::transmute(pinputauthidentity),
17829             ::std::mem::transmute(ppauthidentity),
17830             ::std::mem::transmute(pfsave),
17831             ::std::mem::transmute(dwflags),
17832         ))
17833     }
17834     #[cfg(not(windows))]
17835     unimplemented!("Unsupported target OS");
17836 }
17837 #[cfg(feature = "Win32_Foundation")]
17838 #[inline]
17839 pub unsafe fn SspiUnmarshalAuthIdentity<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSTR>>(authidentitylength: u32, authidentitybytearray: Param1, ppauthidentity: *mut *mut ::std::ffi::c_void) -> i32 {
17840     #[cfg(windows)]
17841     {
17842         #[link(name = "windows")]
17843         extern "system" {
17844             fn SspiUnmarshalAuthIdentity(authidentitylength: u32, authidentitybytearray: super::super::super::Foundation::PSTR, ppauthidentity: *mut *mut ::std::ffi::c_void) -> i32;
17845         }
17846         ::std::mem::transmute(SspiUnmarshalAuthIdentity(::std::mem::transmute(authidentitylength), authidentitybytearray.into_param().abi(), ::std::mem::transmute(ppauthidentity)))
17847     }
17848     #[cfg(not(windows))]
17849     unimplemented!("Unsupported target OS");
17850 }
17851 #[inline]
17852 pub unsafe fn SspiValidateAuthIdentity(authdata: *const ::std::ffi::c_void) -> i32 {
17853     #[cfg(windows)]
17854     {
17855         #[link(name = "windows")]
17856         extern "system" {
17857             fn SspiValidateAuthIdentity(authdata: *const ::std::ffi::c_void) -> i32;
17858         }
17859         ::std::mem::transmute(SspiValidateAuthIdentity(::std::mem::transmute(authdata)))
17860     }
17861     #[cfg(not(windows))]
17862     unimplemented!("Unsupported target OS");
17863 }
17864 #[inline]
17865 pub unsafe fn SspiZeroAuthIdentity(authdata: *const ::std::ffi::c_void) {
17866     #[cfg(windows)]
17867     {
17868         #[link(name = "windows")]
17869         extern "system" {
17870             fn SspiZeroAuthIdentity(authdata: *const ::std::ffi::c_void);
17871         }
17872         ::std::mem::transmute(SspiZeroAuthIdentity(::std::mem::transmute(authdata)))
17873     }
17874     #[cfg(not(windows))]
17875     unimplemented!("Unsupported target OS");
17876 }
17877 #[cfg(feature = "Win32_Foundation")]
17878 #[inline]
17879 pub unsafe fn SystemFunction036(randombuffer: *mut ::std::ffi::c_void, randombufferlength: u32) -> super::super::super::Foundation::BOOLEAN {
17880     #[cfg(windows)]
17881     {
17882         #[link(name = "windows")]
17883         extern "system" {
17884             fn SystemFunction036(randombuffer: *mut ::std::ffi::c_void, randombufferlength: u32) -> super::super::super::Foundation::BOOLEAN;
17885         }
17886         ::std::mem::transmute(SystemFunction036(::std::mem::transmute(randombuffer), ::std::mem::transmute(randombufferlength)))
17887     }
17888     #[cfg(not(windows))]
17889     unimplemented!("Unsupported target OS");
17890 }
17891 #[cfg(feature = "Win32_Foundation")]
17892 #[inline]
17893 pub unsafe fn SystemFunction040(memory: *mut ::std::ffi::c_void, memorysize: u32, optionflags: u32) -> ::windows::runtime::Result<()> {
17894     #[cfg(windows)]
17895     {
17896         #[link(name = "windows")]
17897         extern "system" {
17898             fn SystemFunction040(memory: *mut ::std::ffi::c_void, memorysize: u32, optionflags: u32) -> super::super::super::Foundation::NTSTATUS;
17899         }
17900         SystemFunction040(::std::mem::transmute(memory), ::std::mem::transmute(memorysize), ::std::mem::transmute(optionflags)).ok()
17901     }
17902     #[cfg(not(windows))]
17903     unimplemented!("Unsupported target OS");
17904 }
17905 #[cfg(feature = "Win32_Foundation")]
17906 #[inline]
17907 pub unsafe fn SystemFunction041(memory: *mut ::std::ffi::c_void, memorysize: u32, optionflags: u32) -> ::windows::runtime::Result<()> {
17908     #[cfg(windows)]
17909     {
17910         #[link(name = "windows")]
17911         extern "system" {
17912             fn SystemFunction041(memory: *mut ::std::ffi::c_void, memorysize: u32, optionflags: u32) -> super::super::super::Foundation::NTSTATUS;
17913         }
17914         SystemFunction041(::std::mem::transmute(memory), ::std::mem::transmute(memorysize), ::std::mem::transmute(optionflags)).ok()
17915     }
17916     #[cfg(not(windows))]
17917     unimplemented!("Unsupported target OS");
17918 }
17919 pub const TLS1_ALERT_ACCESS_DENIED: u32 = 49u32;
17920 pub const TLS1_ALERT_BAD_CERTIFICATE: u32 = 42u32;
17921 pub const TLS1_ALERT_BAD_RECORD_MAC: u32 = 20u32;
17922 pub const TLS1_ALERT_CERTIFICATE_EXPIRED: u32 = 45u32;
17923 pub const TLS1_ALERT_CERTIFICATE_REVOKED: u32 = 44u32;
17924 pub const TLS1_ALERT_CERTIFICATE_UNKNOWN: u32 = 46u32;
17925 pub const TLS1_ALERT_CLOSE_NOTIFY: u32 = 0u32;
17926 pub const TLS1_ALERT_DECODE_ERROR: u32 = 50u32;
17927 pub const TLS1_ALERT_DECOMPRESSION_FAIL: u32 = 30u32;
17928 pub const TLS1_ALERT_DECRYPTION_FAILED: u32 = 21u32;
17929 pub const TLS1_ALERT_DECRYPT_ERROR: u32 = 51u32;
17930 pub const TLS1_ALERT_EXPORT_RESTRICTION: u32 = 60u32;
17931 pub const TLS1_ALERT_HANDSHAKE_FAILURE: u32 = 40u32;
17932 pub const TLS1_ALERT_ILLEGAL_PARAMETER: u32 = 47u32;
17933 pub const TLS1_ALERT_INSUFFIENT_SECURITY: u32 = 71u32;
17934 pub const TLS1_ALERT_INTERNAL_ERROR: u32 = 80u32;
17935 pub const TLS1_ALERT_NO_APP_PROTOCOL: u32 = 120u32;
17936 pub const TLS1_ALERT_NO_RENEGOTIATION: u32 = 100u32;
17937 pub const TLS1_ALERT_PROTOCOL_VERSION: u32 = 70u32;
17938 pub const TLS1_ALERT_RECORD_OVERFLOW: u32 = 22u32;
17939 pub const TLS1_ALERT_UNEXPECTED_MESSAGE: u32 = 10u32;
17940 pub const TLS1_ALERT_UNKNOWN_CA: u32 = 48u32;
17941 pub const TLS1_ALERT_UNKNOWN_PSK_IDENTITY: u32 = 115u32;
17942 pub const TLS1_ALERT_UNSUPPORTED_CERT: u32 = 43u32;
17943 pub const TLS1_ALERT_UNSUPPORTED_EXT: u32 = 110u32;
17944 pub const TLS1_ALERT_USER_CANCELED: u32 = 90u32;
17945 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17946 #[repr(C)]
17947 pub struct TLS_EXTENSION_SUBSCRIPTION {
17948     pub ExtensionType: u16,
17949     pub HandshakeType: u16,
17950 }
17951 impl TLS_EXTENSION_SUBSCRIPTION {}
17952 impl ::std::default::Default for TLS_EXTENSION_SUBSCRIPTION {
17953     fn default() -> Self {
17954         unsafe { ::std::mem::zeroed() }
17955     }
17956 }
17957 impl ::std::fmt::Debug for TLS_EXTENSION_SUBSCRIPTION {
17958     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17959         fmt.debug_struct("TLS_EXTENSION_SUBSCRIPTION").field("ExtensionType", &self.ExtensionType).field("HandshakeType", &self.HandshakeType).finish()
17960     }
17961 }
17962 impl ::std::cmp::PartialEq for TLS_EXTENSION_SUBSCRIPTION {
17963     fn eq(&self, other: &Self) -> bool {
17964         self.ExtensionType == other.ExtensionType && self.HandshakeType == other.HandshakeType
17965     }
17966 }
17967 impl ::std::cmp::Eq for TLS_EXTENSION_SUBSCRIPTION {}
17968 unsafe impl ::windows::runtime::Abi for TLS_EXTENSION_SUBSCRIPTION {
17969     type Abi = Self;
17970     type DefaultType = Self;
17971 }
17972 pub const TLS_PARAMS_OPTIONAL: u32 = 1u32;
17973 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
17974 #[repr(transparent)]
17975 pub struct TOKENBINDING_EXTENSION_FORMAT(pub i32);
17976 pub const TOKENBINDING_EXTENSION_FORMAT_UNDEFINED: TOKENBINDING_EXTENSION_FORMAT = TOKENBINDING_EXTENSION_FORMAT(0i32);
17977 impl ::std::convert::From<i32> for TOKENBINDING_EXTENSION_FORMAT {
17978     fn from(value: i32) -> Self {
17979         Self(value)
17980     }
17981 }
17982 unsafe impl ::windows::runtime::Abi for TOKENBINDING_EXTENSION_FORMAT {
17983     type Abi = Self;
17984     type DefaultType = Self;
17985 }
17986 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
17987 #[repr(C)]
17988 pub struct TOKENBINDING_IDENTIFIER {
17989     pub keyType: u8,
17990 }
17991 impl TOKENBINDING_IDENTIFIER {}
17992 impl ::std::default::Default for TOKENBINDING_IDENTIFIER {
17993     fn default() -> Self {
17994         unsafe { ::std::mem::zeroed() }
17995     }
17996 }
17997 impl ::std::fmt::Debug for TOKENBINDING_IDENTIFIER {
17998     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
17999         fmt.debug_struct("TOKENBINDING_IDENTIFIER").field("keyType", &self.keyType).finish()
18000     }
18001 }
18002 impl ::std::cmp::PartialEq for TOKENBINDING_IDENTIFIER {
18003     fn eq(&self, other: &Self) -> bool {
18004         self.keyType == other.keyType
18005     }
18006 }
18007 impl ::std::cmp::Eq for TOKENBINDING_IDENTIFIER {}
18008 unsafe impl ::windows::runtime::Abi for TOKENBINDING_IDENTIFIER {
18009     type Abi = Self;
18010     type DefaultType = Self;
18011 }
18012 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
18013 #[repr(transparent)]
18014 pub struct TOKENBINDING_KEY_PARAMETERS_TYPE(pub i32);
18015 pub const TOKENBINDING_KEY_PARAMETERS_TYPE_RSA2048_PKCS: TOKENBINDING_KEY_PARAMETERS_TYPE = TOKENBINDING_KEY_PARAMETERS_TYPE(0i32);
18016 pub const TOKENBINDING_KEY_PARAMETERS_TYPE_RSA2048_PSS: TOKENBINDING_KEY_PARAMETERS_TYPE = TOKENBINDING_KEY_PARAMETERS_TYPE(1i32);
18017 pub const TOKENBINDING_KEY_PARAMETERS_TYPE_ECDSAP256: TOKENBINDING_KEY_PARAMETERS_TYPE = TOKENBINDING_KEY_PARAMETERS_TYPE(2i32);
18018 pub const TOKENBINDING_KEY_PARAMETERS_TYPE_ANYEXISTING: TOKENBINDING_KEY_PARAMETERS_TYPE = TOKENBINDING_KEY_PARAMETERS_TYPE(255i32);
18019 impl ::std::convert::From<i32> for TOKENBINDING_KEY_PARAMETERS_TYPE {
18020     fn from(value: i32) -> Self {
18021         Self(value)
18022     }
18023 }
18024 unsafe impl ::windows::runtime::Abi for TOKENBINDING_KEY_PARAMETERS_TYPE {
18025     type Abi = Self;
18026     type DefaultType = Self;
18027 }
18028 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18029 #[repr(C)]
18030 pub struct TOKENBINDING_KEY_TYPES {
18031     pub keyCount: u32,
18032     pub keyType: *mut TOKENBINDING_KEY_PARAMETERS_TYPE,
18033 }
18034 impl TOKENBINDING_KEY_TYPES {}
18035 impl ::std::default::Default for TOKENBINDING_KEY_TYPES {
18036     fn default() -> Self {
18037         unsafe { ::std::mem::zeroed() }
18038     }
18039 }
18040 impl ::std::fmt::Debug for TOKENBINDING_KEY_TYPES {
18041     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18042         fmt.debug_struct("TOKENBINDING_KEY_TYPES").field("keyCount", &self.keyCount).field("keyType", &self.keyType).finish()
18043     }
18044 }
18045 impl ::std::cmp::PartialEq for TOKENBINDING_KEY_TYPES {
18046     fn eq(&self, other: &Self) -> bool {
18047         self.keyCount == other.keyCount && self.keyType == other.keyType
18048     }
18049 }
18050 impl ::std::cmp::Eq for TOKENBINDING_KEY_TYPES {}
18051 unsafe impl ::windows::runtime::Abi for TOKENBINDING_KEY_TYPES {
18052     type Abi = Self;
18053     type DefaultType = Self;
18054 }
18055 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18056 #[repr(C)]
18057 pub struct TOKENBINDING_RESULT_DATA {
18058     pub bindingType: TOKENBINDING_TYPE,
18059     pub identifierSize: u32,
18060     pub identifierData: *mut TOKENBINDING_IDENTIFIER,
18061     pub extensionFormat: TOKENBINDING_EXTENSION_FORMAT,
18062     pub extensionSize: u32,
18063     pub extensionData: *mut ::std::ffi::c_void,
18064 }
18065 impl TOKENBINDING_RESULT_DATA {}
18066 impl ::std::default::Default for TOKENBINDING_RESULT_DATA {
18067     fn default() -> Self {
18068         unsafe { ::std::mem::zeroed() }
18069     }
18070 }
18071 impl ::std::fmt::Debug for TOKENBINDING_RESULT_DATA {
18072     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18073         fmt.debug_struct("TOKENBINDING_RESULT_DATA")
18074             .field("bindingType", &self.bindingType)
18075             .field("identifierSize", &self.identifierSize)
18076             .field("identifierData", &self.identifierData)
18077             .field("extensionFormat", &self.extensionFormat)
18078             .field("extensionSize", &self.extensionSize)
18079             .field("extensionData", &self.extensionData)
18080             .finish()
18081     }
18082 }
18083 impl ::std::cmp::PartialEq for TOKENBINDING_RESULT_DATA {
18084     fn eq(&self, other: &Self) -> bool {
18085         self.bindingType == other.bindingType && self.identifierSize == other.identifierSize && self.identifierData == other.identifierData && self.extensionFormat == other.extensionFormat && self.extensionSize == other.extensionSize && self.extensionData == other.extensionData
18086     }
18087 }
18088 impl ::std::cmp::Eq for TOKENBINDING_RESULT_DATA {}
18089 unsafe impl ::windows::runtime::Abi for TOKENBINDING_RESULT_DATA {
18090     type Abi = Self;
18091     type DefaultType = Self;
18092 }
18093 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18094 #[repr(C)]
18095 pub struct TOKENBINDING_RESULT_LIST {
18096     pub resultCount: u32,
18097     pub resultData: *mut TOKENBINDING_RESULT_DATA,
18098 }
18099 impl TOKENBINDING_RESULT_LIST {}
18100 impl ::std::default::Default for TOKENBINDING_RESULT_LIST {
18101     fn default() -> Self {
18102         unsafe { ::std::mem::zeroed() }
18103     }
18104 }
18105 impl ::std::fmt::Debug for TOKENBINDING_RESULT_LIST {
18106     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18107         fmt.debug_struct("TOKENBINDING_RESULT_LIST").field("resultCount", &self.resultCount).field("resultData", &self.resultData).finish()
18108     }
18109 }
18110 impl ::std::cmp::PartialEq for TOKENBINDING_RESULT_LIST {
18111     fn eq(&self, other: &Self) -> bool {
18112         self.resultCount == other.resultCount && self.resultData == other.resultData
18113     }
18114 }
18115 impl ::std::cmp::Eq for TOKENBINDING_RESULT_LIST {}
18116 unsafe impl ::windows::runtime::Abi for TOKENBINDING_RESULT_LIST {
18117     type Abi = Self;
18118     type DefaultType = Self;
18119 }
18120 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
18121 #[repr(transparent)]
18122 pub struct TOKENBINDING_TYPE(pub i32);
18123 pub const TOKENBINDING_TYPE_PROVIDED: TOKENBINDING_TYPE = TOKENBINDING_TYPE(0i32);
18124 pub const TOKENBINDING_TYPE_REFERRED: TOKENBINDING_TYPE = TOKENBINDING_TYPE(1i32);
18125 impl ::std::convert::From<i32> for TOKENBINDING_TYPE {
18126     fn from(value: i32) -> Self {
18127         Self(value)
18128     }
18129 }
18130 unsafe impl ::windows::runtime::Abi for TOKENBINDING_TYPE {
18131     type Abi = Self;
18132     type DefaultType = Self;
18133 }
18134 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18135 #[repr(C)]
18136 #[cfg(feature = "Win32_Foundation")]
18137 pub struct TRUSTED_CONTROLLERS_INFO {
18138     pub Entries: u32,
18139     pub Names: *mut super::super::super::Foundation::UNICODE_STRING,
18140 }
18141 #[cfg(feature = "Win32_Foundation")]
18142 impl TRUSTED_CONTROLLERS_INFO {}
18143 #[cfg(feature = "Win32_Foundation")]
18144 impl ::std::default::Default for TRUSTED_CONTROLLERS_INFO {
18145     fn default() -> Self {
18146         unsafe { ::std::mem::zeroed() }
18147     }
18148 }
18149 #[cfg(feature = "Win32_Foundation")]
18150 impl ::std::fmt::Debug for TRUSTED_CONTROLLERS_INFO {
18151     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18152         fmt.debug_struct("TRUSTED_CONTROLLERS_INFO").field("Entries", &self.Entries).field("Names", &self.Names).finish()
18153     }
18154 }
18155 #[cfg(feature = "Win32_Foundation")]
18156 impl ::std::cmp::PartialEq for TRUSTED_CONTROLLERS_INFO {
18157     fn eq(&self, other: &Self) -> bool {
18158         self.Entries == other.Entries && self.Names == other.Names
18159     }
18160 }
18161 #[cfg(feature = "Win32_Foundation")]
18162 impl ::std::cmp::Eq for TRUSTED_CONTROLLERS_INFO {}
18163 #[cfg(feature = "Win32_Foundation")]
18164 unsafe impl ::windows::runtime::Abi for TRUSTED_CONTROLLERS_INFO {
18165     type Abi = Self;
18166     type DefaultType = Self;
18167 }
18168 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18169 #[repr(C)]
18170 pub struct TRUSTED_DOMAIN_AUTH_INFORMATION {
18171     pub IncomingAuthInfos: u32,
18172     pub IncomingAuthenticationInformation: *mut LSA_AUTH_INFORMATION,
18173     pub IncomingPreviousAuthenticationInformation: *mut LSA_AUTH_INFORMATION,
18174     pub OutgoingAuthInfos: u32,
18175     pub OutgoingAuthenticationInformation: *mut LSA_AUTH_INFORMATION,
18176     pub OutgoingPreviousAuthenticationInformation: *mut LSA_AUTH_INFORMATION,
18177 }
18178 impl TRUSTED_DOMAIN_AUTH_INFORMATION {}
18179 impl ::std::default::Default for TRUSTED_DOMAIN_AUTH_INFORMATION {
18180     fn default() -> Self {
18181         unsafe { ::std::mem::zeroed() }
18182     }
18183 }
18184 impl ::std::fmt::Debug for TRUSTED_DOMAIN_AUTH_INFORMATION {
18185     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18186         fmt.debug_struct("TRUSTED_DOMAIN_AUTH_INFORMATION")
18187             .field("IncomingAuthInfos", &self.IncomingAuthInfos)
18188             .field("IncomingAuthenticationInformation", &self.IncomingAuthenticationInformation)
18189             .field("IncomingPreviousAuthenticationInformation", &self.IncomingPreviousAuthenticationInformation)
18190             .field("OutgoingAuthInfos", &self.OutgoingAuthInfos)
18191             .field("OutgoingAuthenticationInformation", &self.OutgoingAuthenticationInformation)
18192             .field("OutgoingPreviousAuthenticationInformation", &self.OutgoingPreviousAuthenticationInformation)
18193             .finish()
18194     }
18195 }
18196 impl ::std::cmp::PartialEq for TRUSTED_DOMAIN_AUTH_INFORMATION {
18197     fn eq(&self, other: &Self) -> bool {
18198         self.IncomingAuthInfos == other.IncomingAuthInfos && self.IncomingAuthenticationInformation == other.IncomingAuthenticationInformation && self.IncomingPreviousAuthenticationInformation == other.IncomingPreviousAuthenticationInformation && self.OutgoingAuthInfos == other.OutgoingAuthInfos && self.OutgoingAuthenticationInformation == other.OutgoingAuthenticationInformation && self.OutgoingPreviousAuthenticationInformation == other.OutgoingPreviousAuthenticationInformation
18199     }
18200 }
18201 impl ::std::cmp::Eq for TRUSTED_DOMAIN_AUTH_INFORMATION {}
18202 unsafe impl ::windows::runtime::Abi for TRUSTED_DOMAIN_AUTH_INFORMATION {
18203     type Abi = Self;
18204     type DefaultType = Self;
18205 }
18206 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18207 #[repr(C)]
18208 #[cfg(feature = "Win32_Foundation")]
18209 pub struct TRUSTED_DOMAIN_FULL_INFORMATION {
18210     pub Information: TRUSTED_DOMAIN_INFORMATION_EX,
18211     pub PosixOffset: TRUSTED_POSIX_OFFSET_INFO,
18212     pub AuthInformation: TRUSTED_DOMAIN_AUTH_INFORMATION,
18213 }
18214 #[cfg(feature = "Win32_Foundation")]
18215 impl TRUSTED_DOMAIN_FULL_INFORMATION {}
18216 #[cfg(feature = "Win32_Foundation")]
18217 impl ::std::default::Default for TRUSTED_DOMAIN_FULL_INFORMATION {
18218     fn default() -> Self {
18219         unsafe { ::std::mem::zeroed() }
18220     }
18221 }
18222 #[cfg(feature = "Win32_Foundation")]
18223 impl ::std::fmt::Debug for TRUSTED_DOMAIN_FULL_INFORMATION {
18224     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18225         fmt.debug_struct("TRUSTED_DOMAIN_FULL_INFORMATION").field("Information", &self.Information).field("PosixOffset", &self.PosixOffset).field("AuthInformation", &self.AuthInformation).finish()
18226     }
18227 }
18228 #[cfg(feature = "Win32_Foundation")]
18229 impl ::std::cmp::PartialEq for TRUSTED_DOMAIN_FULL_INFORMATION {
18230     fn eq(&self, other: &Self) -> bool {
18231         self.Information == other.Information && self.PosixOffset == other.PosixOffset && self.AuthInformation == other.AuthInformation
18232     }
18233 }
18234 #[cfg(feature = "Win32_Foundation")]
18235 impl ::std::cmp::Eq for TRUSTED_DOMAIN_FULL_INFORMATION {}
18236 #[cfg(feature = "Win32_Foundation")]
18237 unsafe impl ::windows::runtime::Abi for TRUSTED_DOMAIN_FULL_INFORMATION {
18238     type Abi = Self;
18239     type DefaultType = Self;
18240 }
18241 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18242 #[repr(C)]
18243 #[cfg(feature = "Win32_Foundation")]
18244 pub struct TRUSTED_DOMAIN_FULL_INFORMATION2 {
18245     pub Information: TRUSTED_DOMAIN_INFORMATION_EX2,
18246     pub PosixOffset: TRUSTED_POSIX_OFFSET_INFO,
18247     pub AuthInformation: TRUSTED_DOMAIN_AUTH_INFORMATION,
18248 }
18249 #[cfg(feature = "Win32_Foundation")]
18250 impl TRUSTED_DOMAIN_FULL_INFORMATION2 {}
18251 #[cfg(feature = "Win32_Foundation")]
18252 impl ::std::default::Default for TRUSTED_DOMAIN_FULL_INFORMATION2 {
18253     fn default() -> Self {
18254         unsafe { ::std::mem::zeroed() }
18255     }
18256 }
18257 #[cfg(feature = "Win32_Foundation")]
18258 impl ::std::fmt::Debug for TRUSTED_DOMAIN_FULL_INFORMATION2 {
18259     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18260         fmt.debug_struct("TRUSTED_DOMAIN_FULL_INFORMATION2").field("Information", &self.Information).field("PosixOffset", &self.PosixOffset).field("AuthInformation", &self.AuthInformation).finish()
18261     }
18262 }
18263 #[cfg(feature = "Win32_Foundation")]
18264 impl ::std::cmp::PartialEq for TRUSTED_DOMAIN_FULL_INFORMATION2 {
18265     fn eq(&self, other: &Self) -> bool {
18266         self.Information == other.Information && self.PosixOffset == other.PosixOffset && self.AuthInformation == other.AuthInformation
18267     }
18268 }
18269 #[cfg(feature = "Win32_Foundation")]
18270 impl ::std::cmp::Eq for TRUSTED_DOMAIN_FULL_INFORMATION2 {}
18271 #[cfg(feature = "Win32_Foundation")]
18272 unsafe impl ::windows::runtime::Abi for TRUSTED_DOMAIN_FULL_INFORMATION2 {
18273     type Abi = Self;
18274     type DefaultType = Self;
18275 }
18276 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18277 #[repr(C)]
18278 #[cfg(feature = "Win32_Foundation")]
18279 pub struct TRUSTED_DOMAIN_INFORMATION_EX {
18280     pub Name: super::super::super::Foundation::UNICODE_STRING,
18281     pub FlatName: super::super::super::Foundation::UNICODE_STRING,
18282     pub Sid: super::super::super::Foundation::PSID,
18283     pub TrustDirection: TRUSTED_DOMAIN_TRUST_DIRECTION,
18284     pub TrustType: TRUSTED_DOMAIN_TRUST_TYPE,
18285     pub TrustAttributes: TRUSTED_DOMAIN_TRUST_ATTRIBUTES,
18286 }
18287 #[cfg(feature = "Win32_Foundation")]
18288 impl TRUSTED_DOMAIN_INFORMATION_EX {}
18289 #[cfg(feature = "Win32_Foundation")]
18290 impl ::std::default::Default for TRUSTED_DOMAIN_INFORMATION_EX {
18291     fn default() -> Self {
18292         unsafe { ::std::mem::zeroed() }
18293     }
18294 }
18295 #[cfg(feature = "Win32_Foundation")]
18296 impl ::std::fmt::Debug for TRUSTED_DOMAIN_INFORMATION_EX {
18297     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18298         fmt.debug_struct("TRUSTED_DOMAIN_INFORMATION_EX").field("Name", &self.Name).field("FlatName", &self.FlatName).field("Sid", &self.Sid).field("TrustDirection", &self.TrustDirection).field("TrustType", &self.TrustType).field("TrustAttributes", &self.TrustAttributes).finish()
18299     }
18300 }
18301 #[cfg(feature = "Win32_Foundation")]
18302 impl ::std::cmp::PartialEq for TRUSTED_DOMAIN_INFORMATION_EX {
18303     fn eq(&self, other: &Self) -> bool {
18304         self.Name == other.Name && self.FlatName == other.FlatName && self.Sid == other.Sid && self.TrustDirection == other.TrustDirection && self.TrustType == other.TrustType && self.TrustAttributes == other.TrustAttributes
18305     }
18306 }
18307 #[cfg(feature = "Win32_Foundation")]
18308 impl ::std::cmp::Eq for TRUSTED_DOMAIN_INFORMATION_EX {}
18309 #[cfg(feature = "Win32_Foundation")]
18310 unsafe impl ::windows::runtime::Abi for TRUSTED_DOMAIN_INFORMATION_EX {
18311     type Abi = Self;
18312     type DefaultType = Self;
18313 }
18314 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18315 #[repr(C)]
18316 #[cfg(feature = "Win32_Foundation")]
18317 pub struct TRUSTED_DOMAIN_INFORMATION_EX2 {
18318     pub Name: super::super::super::Foundation::UNICODE_STRING,
18319     pub FlatName: super::super::super::Foundation::UNICODE_STRING,
18320     pub Sid: super::super::super::Foundation::PSID,
18321     pub TrustDirection: u32,
18322     pub TrustType: u32,
18323     pub TrustAttributes: u32,
18324     pub ForestTrustLength: u32,
18325     pub ForestTrustInfo: *mut u8,
18326 }
18327 #[cfg(feature = "Win32_Foundation")]
18328 impl TRUSTED_DOMAIN_INFORMATION_EX2 {}
18329 #[cfg(feature = "Win32_Foundation")]
18330 impl ::std::default::Default for TRUSTED_DOMAIN_INFORMATION_EX2 {
18331     fn default() -> Self {
18332         unsafe { ::std::mem::zeroed() }
18333     }
18334 }
18335 #[cfg(feature = "Win32_Foundation")]
18336 impl ::std::fmt::Debug for TRUSTED_DOMAIN_INFORMATION_EX2 {
18337     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18338         fmt.debug_struct("TRUSTED_DOMAIN_INFORMATION_EX2")
18339             .field("Name", &self.Name)
18340             .field("FlatName", &self.FlatName)
18341             .field("Sid", &self.Sid)
18342             .field("TrustDirection", &self.TrustDirection)
18343             .field("TrustType", &self.TrustType)
18344             .field("TrustAttributes", &self.TrustAttributes)
18345             .field("ForestTrustLength", &self.ForestTrustLength)
18346             .field("ForestTrustInfo", &self.ForestTrustInfo)
18347             .finish()
18348     }
18349 }
18350 #[cfg(feature = "Win32_Foundation")]
18351 impl ::std::cmp::PartialEq for TRUSTED_DOMAIN_INFORMATION_EX2 {
18352     fn eq(&self, other: &Self) -> bool {
18353         self.Name == other.Name && self.FlatName == other.FlatName && self.Sid == other.Sid && self.TrustDirection == other.TrustDirection && self.TrustType == other.TrustType && self.TrustAttributes == other.TrustAttributes && self.ForestTrustLength == other.ForestTrustLength && self.ForestTrustInfo == other.ForestTrustInfo
18354     }
18355 }
18356 #[cfg(feature = "Win32_Foundation")]
18357 impl ::std::cmp::Eq for TRUSTED_DOMAIN_INFORMATION_EX2 {}
18358 #[cfg(feature = "Win32_Foundation")]
18359 unsafe impl ::windows::runtime::Abi for TRUSTED_DOMAIN_INFORMATION_EX2 {
18360     type Abi = Self;
18361     type DefaultType = Self;
18362 }
18363 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18364 #[repr(C)]
18365 #[cfg(feature = "Win32_Foundation")]
18366 pub struct TRUSTED_DOMAIN_NAME_INFO {
18367     pub Name: super::super::super::Foundation::UNICODE_STRING,
18368 }
18369 #[cfg(feature = "Win32_Foundation")]
18370 impl TRUSTED_DOMAIN_NAME_INFO {}
18371 #[cfg(feature = "Win32_Foundation")]
18372 impl ::std::default::Default for TRUSTED_DOMAIN_NAME_INFO {
18373     fn default() -> Self {
18374         unsafe { ::std::mem::zeroed() }
18375     }
18376 }
18377 #[cfg(feature = "Win32_Foundation")]
18378 impl ::std::fmt::Debug for TRUSTED_DOMAIN_NAME_INFO {
18379     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18380         fmt.debug_struct("TRUSTED_DOMAIN_NAME_INFO").field("Name", &self.Name).finish()
18381     }
18382 }
18383 #[cfg(feature = "Win32_Foundation")]
18384 impl ::std::cmp::PartialEq for TRUSTED_DOMAIN_NAME_INFO {
18385     fn eq(&self, other: &Self) -> bool {
18386         self.Name == other.Name
18387     }
18388 }
18389 #[cfg(feature = "Win32_Foundation")]
18390 impl ::std::cmp::Eq for TRUSTED_DOMAIN_NAME_INFO {}
18391 #[cfg(feature = "Win32_Foundation")]
18392 unsafe impl ::windows::runtime::Abi for TRUSTED_DOMAIN_NAME_INFO {
18393     type Abi = Self;
18394     type DefaultType = Self;
18395 }
18396 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18397 #[repr(C)]
18398 pub struct TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES {
18399     pub SupportedEncryptionTypes: u32,
18400 }
18401 impl TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES {}
18402 impl ::std::default::Default for TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES {
18403     fn default() -> Self {
18404         unsafe { ::std::mem::zeroed() }
18405     }
18406 }
18407 impl ::std::fmt::Debug for TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES {
18408     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18409         fmt.debug_struct("TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES").field("SupportedEncryptionTypes", &self.SupportedEncryptionTypes).finish()
18410     }
18411 }
18412 impl ::std::cmp::PartialEq for TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES {
18413     fn eq(&self, other: &Self) -> bool {
18414         self.SupportedEncryptionTypes == other.SupportedEncryptionTypes
18415     }
18416 }
18417 impl ::std::cmp::Eq for TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES {}
18418 unsafe impl ::windows::runtime::Abi for TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES {
18419     type Abi = Self;
18420     type DefaultType = Self;
18421 }
18422 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
18423 #[repr(transparent)]
18424 pub struct TRUSTED_DOMAIN_TRUST_ATTRIBUTES(pub u32);
18425 pub const TRUST_ATTRIBUTE_NON_TRANSITIVE: TRUSTED_DOMAIN_TRUST_ATTRIBUTES = TRUSTED_DOMAIN_TRUST_ATTRIBUTES(1u32);
18426 pub const TRUST_ATTRIBUTE_UPLEVEL_ONLY: TRUSTED_DOMAIN_TRUST_ATTRIBUTES = TRUSTED_DOMAIN_TRUST_ATTRIBUTES(2u32);
18427 pub const TRUST_ATTRIBUTE_FILTER_SIDS: TRUSTED_DOMAIN_TRUST_ATTRIBUTES = TRUSTED_DOMAIN_TRUST_ATTRIBUTES(4u32);
18428 pub const TRUST_ATTRIBUTE_FOREST_TRANSITIVE: TRUSTED_DOMAIN_TRUST_ATTRIBUTES = TRUSTED_DOMAIN_TRUST_ATTRIBUTES(8u32);
18429 pub const TRUST_ATTRIBUTE_CROSS_ORGANIZATION: TRUSTED_DOMAIN_TRUST_ATTRIBUTES = TRUSTED_DOMAIN_TRUST_ATTRIBUTES(16u32);
18430 pub const TRUST_ATTRIBUTE_TREAT_AS_EXTERNAL: TRUSTED_DOMAIN_TRUST_ATTRIBUTES = TRUSTED_DOMAIN_TRUST_ATTRIBUTES(64u32);
18431 pub const TRUST_ATTRIBUTE_WITHIN_FOREST: TRUSTED_DOMAIN_TRUST_ATTRIBUTES = TRUSTED_DOMAIN_TRUST_ATTRIBUTES(32u32);
18432 impl ::std::convert::From<u32> for TRUSTED_DOMAIN_TRUST_ATTRIBUTES {
18433     fn from(value: u32) -> Self {
18434         Self(value)
18435     }
18436 }
18437 unsafe impl ::windows::runtime::Abi for TRUSTED_DOMAIN_TRUST_ATTRIBUTES {
18438     type Abi = Self;
18439     type DefaultType = Self;
18440 }
18441 impl ::std::ops::BitOr for TRUSTED_DOMAIN_TRUST_ATTRIBUTES {
18442     type Output = Self;
18443     fn bitor(self, rhs: Self) -> Self {
18444         Self(self.0 | rhs.0)
18445     }
18446 }
18447 impl ::std::ops::BitAnd for TRUSTED_DOMAIN_TRUST_ATTRIBUTES {
18448     type Output = Self;
18449     fn bitand(self, rhs: Self) -> Self {
18450         Self(self.0 & rhs.0)
18451     }
18452 }
18453 impl ::std::ops::BitOrAssign for TRUSTED_DOMAIN_TRUST_ATTRIBUTES {
18454     fn bitor_assign(&mut self, rhs: Self) {
18455         self.0.bitor_assign(rhs.0)
18456     }
18457 }
18458 impl ::std::ops::BitAndAssign for TRUSTED_DOMAIN_TRUST_ATTRIBUTES {
18459     fn bitand_assign(&mut self, rhs: Self) {
18460         self.0.bitand_assign(rhs.0)
18461     }
18462 }
18463 impl ::std::ops::Not for TRUSTED_DOMAIN_TRUST_ATTRIBUTES {
18464     type Output = Self;
18465     fn not(self) -> Self {
18466         Self(self.0.not())
18467     }
18468 }
18469 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
18470 #[repr(transparent)]
18471 pub struct TRUSTED_DOMAIN_TRUST_DIRECTION(pub u32);
18472 pub const TRUST_DIRECTION_DISABLED: TRUSTED_DOMAIN_TRUST_DIRECTION = TRUSTED_DOMAIN_TRUST_DIRECTION(0u32);
18473 pub const TRUST_DIRECTION_INBOUND: TRUSTED_DOMAIN_TRUST_DIRECTION = TRUSTED_DOMAIN_TRUST_DIRECTION(1u32);
18474 pub const TRUST_DIRECTION_OUTBOUND: TRUSTED_DOMAIN_TRUST_DIRECTION = TRUSTED_DOMAIN_TRUST_DIRECTION(2u32);
18475 pub const TRUST_DIRECTION_BIDIRECTIONAL: TRUSTED_DOMAIN_TRUST_DIRECTION = TRUSTED_DOMAIN_TRUST_DIRECTION(3u32);
18476 impl ::std::convert::From<u32> for TRUSTED_DOMAIN_TRUST_DIRECTION {
18477     fn from(value: u32) -> Self {
18478         Self(value)
18479     }
18480 }
18481 unsafe impl ::windows::runtime::Abi for TRUSTED_DOMAIN_TRUST_DIRECTION {
18482     type Abi = Self;
18483     type DefaultType = Self;
18484 }
18485 impl ::std::ops::BitOr for TRUSTED_DOMAIN_TRUST_DIRECTION {
18486     type Output = Self;
18487     fn bitor(self, rhs: Self) -> Self {
18488         Self(self.0 | rhs.0)
18489     }
18490 }
18491 impl ::std::ops::BitAnd for TRUSTED_DOMAIN_TRUST_DIRECTION {
18492     type Output = Self;
18493     fn bitand(self, rhs: Self) -> Self {
18494         Self(self.0 & rhs.0)
18495     }
18496 }
18497 impl ::std::ops::BitOrAssign for TRUSTED_DOMAIN_TRUST_DIRECTION {
18498     fn bitor_assign(&mut self, rhs: Self) {
18499         self.0.bitor_assign(rhs.0)
18500     }
18501 }
18502 impl ::std::ops::BitAndAssign for TRUSTED_DOMAIN_TRUST_DIRECTION {
18503     fn bitand_assign(&mut self, rhs: Self) {
18504         self.0.bitand_assign(rhs.0)
18505     }
18506 }
18507 impl ::std::ops::Not for TRUSTED_DOMAIN_TRUST_DIRECTION {
18508     type Output = Self;
18509     fn not(self) -> Self {
18510         Self(self.0.not())
18511     }
18512 }
18513 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
18514 #[repr(transparent)]
18515 pub struct TRUSTED_DOMAIN_TRUST_TYPE(pub u32);
18516 pub const TRUST_TYPE_DOWNLEVEL: TRUSTED_DOMAIN_TRUST_TYPE = TRUSTED_DOMAIN_TRUST_TYPE(1u32);
18517 pub const TRUST_TYPE_UPLEVEL: TRUSTED_DOMAIN_TRUST_TYPE = TRUSTED_DOMAIN_TRUST_TYPE(2u32);
18518 pub const TRUST_TYPE_MIT: TRUSTED_DOMAIN_TRUST_TYPE = TRUSTED_DOMAIN_TRUST_TYPE(3u32);
18519 pub const TRUST_TYPE_DCE: TRUSTED_DOMAIN_TRUST_TYPE = TRUSTED_DOMAIN_TRUST_TYPE(4u32);
18520 impl ::std::convert::From<u32> for TRUSTED_DOMAIN_TRUST_TYPE {
18521     fn from(value: u32) -> Self {
18522         Self(value)
18523     }
18524 }
18525 unsafe impl ::windows::runtime::Abi for TRUSTED_DOMAIN_TRUST_TYPE {
18526     type Abi = Self;
18527     type DefaultType = Self;
18528 }
18529 impl ::std::ops::BitOr for TRUSTED_DOMAIN_TRUST_TYPE {
18530     type Output = Self;
18531     fn bitor(self, rhs: Self) -> Self {
18532         Self(self.0 | rhs.0)
18533     }
18534 }
18535 impl ::std::ops::BitAnd for TRUSTED_DOMAIN_TRUST_TYPE {
18536     type Output = Self;
18537     fn bitand(self, rhs: Self) -> Self {
18538         Self(self.0 & rhs.0)
18539     }
18540 }
18541 impl ::std::ops::BitOrAssign for TRUSTED_DOMAIN_TRUST_TYPE {
18542     fn bitor_assign(&mut self, rhs: Self) {
18543         self.0.bitor_assign(rhs.0)
18544     }
18545 }
18546 impl ::std::ops::BitAndAssign for TRUSTED_DOMAIN_TRUST_TYPE {
18547     fn bitand_assign(&mut self, rhs: Self) {
18548         self.0.bitand_assign(rhs.0)
18549     }
18550 }
18551 impl ::std::ops::Not for TRUSTED_DOMAIN_TRUST_TYPE {
18552     type Output = Self;
18553     fn not(self) -> Self {
18554         Self(self.0.not())
18555     }
18556 }
18557 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
18558 #[repr(transparent)]
18559 pub struct TRUSTED_INFORMATION_CLASS(pub i32);
18560 pub const TrustedDomainNameInformation: TRUSTED_INFORMATION_CLASS = TRUSTED_INFORMATION_CLASS(1i32);
18561 pub const TrustedControllersInformation: TRUSTED_INFORMATION_CLASS = TRUSTED_INFORMATION_CLASS(2i32);
18562 pub const TrustedPosixOffsetInformation: TRUSTED_INFORMATION_CLASS = TRUSTED_INFORMATION_CLASS(3i32);
18563 pub const TrustedPasswordInformation: TRUSTED_INFORMATION_CLASS = TRUSTED_INFORMATION_CLASS(4i32);
18564 pub const TrustedDomainInformationBasic: TRUSTED_INFORMATION_CLASS = TRUSTED_INFORMATION_CLASS(5i32);
18565 pub const TrustedDomainInformationEx: TRUSTED_INFORMATION_CLASS = TRUSTED_INFORMATION_CLASS(6i32);
18566 pub const TrustedDomainAuthInformation: TRUSTED_INFORMATION_CLASS = TRUSTED_INFORMATION_CLASS(7i32);
18567 pub const TrustedDomainFullInformation: TRUSTED_INFORMATION_CLASS = TRUSTED_INFORMATION_CLASS(8i32);
18568 pub const TrustedDomainAuthInformationInternal: TRUSTED_INFORMATION_CLASS = TRUSTED_INFORMATION_CLASS(9i32);
18569 pub const TrustedDomainFullInformationInternal: TRUSTED_INFORMATION_CLASS = TRUSTED_INFORMATION_CLASS(10i32);
18570 pub const TrustedDomainInformationEx2Internal: TRUSTED_INFORMATION_CLASS = TRUSTED_INFORMATION_CLASS(11i32);
18571 pub const TrustedDomainFullInformation2Internal: TRUSTED_INFORMATION_CLASS = TRUSTED_INFORMATION_CLASS(12i32);
18572 pub const TrustedDomainSupportedEncryptionTypes: TRUSTED_INFORMATION_CLASS = TRUSTED_INFORMATION_CLASS(13i32);
18573 impl ::std::convert::From<i32> for TRUSTED_INFORMATION_CLASS {
18574     fn from(value: i32) -> Self {
18575         Self(value)
18576     }
18577 }
18578 unsafe impl ::windows::runtime::Abi for TRUSTED_INFORMATION_CLASS {
18579     type Abi = Self;
18580     type DefaultType = Self;
18581 }
18582 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18583 #[repr(C)]
18584 #[cfg(feature = "Win32_Foundation")]
18585 pub struct TRUSTED_PASSWORD_INFO {
18586     pub Password: super::super::super::Foundation::UNICODE_STRING,
18587     pub OldPassword: super::super::super::Foundation::UNICODE_STRING,
18588 }
18589 #[cfg(feature = "Win32_Foundation")]
18590 impl TRUSTED_PASSWORD_INFO {}
18591 #[cfg(feature = "Win32_Foundation")]
18592 impl ::std::default::Default for TRUSTED_PASSWORD_INFO {
18593     fn default() -> Self {
18594         unsafe { ::std::mem::zeroed() }
18595     }
18596 }
18597 #[cfg(feature = "Win32_Foundation")]
18598 impl ::std::fmt::Debug for TRUSTED_PASSWORD_INFO {
18599     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18600         fmt.debug_struct("TRUSTED_PASSWORD_INFO").field("Password", &self.Password).field("OldPassword", &self.OldPassword).finish()
18601     }
18602 }
18603 #[cfg(feature = "Win32_Foundation")]
18604 impl ::std::cmp::PartialEq for TRUSTED_PASSWORD_INFO {
18605     fn eq(&self, other: &Self) -> bool {
18606         self.Password == other.Password && self.OldPassword == other.OldPassword
18607     }
18608 }
18609 #[cfg(feature = "Win32_Foundation")]
18610 impl ::std::cmp::Eq for TRUSTED_PASSWORD_INFO {}
18611 #[cfg(feature = "Win32_Foundation")]
18612 unsafe impl ::windows::runtime::Abi for TRUSTED_PASSWORD_INFO {
18613     type Abi = Self;
18614     type DefaultType = Self;
18615 }
18616 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18617 #[repr(C)]
18618 pub struct TRUSTED_POSIX_OFFSET_INFO {
18619     pub Offset: u32,
18620 }
18621 impl TRUSTED_POSIX_OFFSET_INFO {}
18622 impl ::std::default::Default for TRUSTED_POSIX_OFFSET_INFO {
18623     fn default() -> Self {
18624         unsafe { ::std::mem::zeroed() }
18625     }
18626 }
18627 impl ::std::fmt::Debug for TRUSTED_POSIX_OFFSET_INFO {
18628     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18629         fmt.debug_struct("TRUSTED_POSIX_OFFSET_INFO").field("Offset", &self.Offset).finish()
18630     }
18631 }
18632 impl ::std::cmp::PartialEq for TRUSTED_POSIX_OFFSET_INFO {
18633     fn eq(&self, other: &Self) -> bool {
18634         self.Offset == other.Offset
18635     }
18636 }
18637 impl ::std::cmp::Eq for TRUSTED_POSIX_OFFSET_INFO {}
18638 unsafe impl ::windows::runtime::Abi for TRUSTED_POSIX_OFFSET_INFO {
18639     type Abi = Self;
18640     type DefaultType = Self;
18641 }
18642 pub const TRUSTED_QUERY_AUTH: i32 = 64i32;
18643 pub const TRUSTED_QUERY_CONTROLLERS: i32 = 2i32;
18644 pub const TRUSTED_QUERY_DOMAIN_NAME: i32 = 1i32;
18645 pub const TRUSTED_QUERY_POSIX: i32 = 8i32;
18646 pub const TRUSTED_SET_AUTH: i32 = 32i32;
18647 pub const TRUSTED_SET_CONTROLLERS: i32 = 4i32;
18648 pub const TRUSTED_SET_POSIX: i32 = 16i32;
18649 pub const TRUST_ATTRIBUTES_USER: u32 = 4278190080u32;
18650 pub const TRUST_ATTRIBUTES_VALID: u32 = 4278386687u32;
18651 pub const TRUST_ATTRIBUTE_CROSS_ORGANIZATION_ENABLE_TGT_DELEGATION: u32 = 2048u32;
18652 pub const TRUST_ATTRIBUTE_CROSS_ORGANIZATION_NO_TGT_DELEGATION: u32 = 512u32;
18653 pub const TRUST_ATTRIBUTE_PIM_TRUST: u32 = 1024u32;
18654 pub const TRUST_ATTRIBUTE_QUARANTINED_DOMAIN: u32 = 4u32;
18655 pub const TRUST_ATTRIBUTE_TREE_PARENT: u32 = 4194304u32;
18656 pub const TRUST_ATTRIBUTE_TREE_ROOT: u32 = 8388608u32;
18657 pub const TRUST_ATTRIBUTE_TRUST_USES_AES_KEYS: u32 = 256u32;
18658 pub const TRUST_ATTRIBUTE_TRUST_USES_RC4_ENCRYPTION: u32 = 128u32;
18659 #[inline]
18660 pub unsafe fn TokenBindingDeleteAllBindings() -> i32 {
18661     #[cfg(windows)]
18662     {
18663         #[link(name = "windows")]
18664         extern "system" {
18665             fn TokenBindingDeleteAllBindings() -> i32;
18666         }
18667         ::std::mem::transmute(TokenBindingDeleteAllBindings())
18668     }
18669     #[cfg(not(windows))]
18670     unimplemented!("Unsupported target OS");
18671 }
18672 #[cfg(feature = "Win32_Foundation")]
18673 #[inline]
18674 pub unsafe fn TokenBindingDeleteBinding<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(targeturl: Param0) -> i32 {
18675     #[cfg(windows)]
18676     {
18677         #[link(name = "windows")]
18678         extern "system" {
18679             fn TokenBindingDeleteBinding(targeturl: super::super::super::Foundation::PWSTR) -> i32;
18680         }
18681         ::std::mem::transmute(TokenBindingDeleteBinding(targeturl.into_param().abi()))
18682     }
18683     #[cfg(not(windows))]
18684     unimplemented!("Unsupported target OS");
18685 }
18686 #[cfg(feature = "Win32_Foundation")]
18687 #[inline]
18688 pub unsafe fn TokenBindingGenerateBinding<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(keytype: TOKENBINDING_KEY_PARAMETERS_TYPE, targeturl: Param1, bindingtype: TOKENBINDING_TYPE, tlsekm: *const ::std::ffi::c_void, tlsekmsize: u32, extensionformat: TOKENBINDING_EXTENSION_FORMAT, extensiondata: *const ::std::ffi::c_void, tokenbinding: *mut *mut ::std::ffi::c_void, tokenbindingsize: *mut u32, resultdata: *mut *mut TOKENBINDING_RESULT_DATA) -> i32 {
18689     #[cfg(windows)]
18690     {
18691         #[link(name = "windows")]
18692         extern "system" {
18693             fn TokenBindingGenerateBinding(keytype: TOKENBINDING_KEY_PARAMETERS_TYPE, targeturl: super::super::super::Foundation::PWSTR, bindingtype: TOKENBINDING_TYPE, tlsekm: *const ::std::ffi::c_void, tlsekmsize: u32, extensionformat: TOKENBINDING_EXTENSION_FORMAT, extensiondata: *const ::std::ffi::c_void, tokenbinding: *mut *mut ::std::ffi::c_void, tokenbindingsize: *mut u32, resultdata: *mut *mut TOKENBINDING_RESULT_DATA) -> i32;
18694         }
18695         ::std::mem::transmute(TokenBindingGenerateBinding(
18696             ::std::mem::transmute(keytype),
18697             targeturl.into_param().abi(),
18698             ::std::mem::transmute(bindingtype),
18699             ::std::mem::transmute(tlsekm),
18700             ::std::mem::transmute(tlsekmsize),
18701             ::std::mem::transmute(extensionformat),
18702             ::std::mem::transmute(extensiondata),
18703             ::std::mem::transmute(tokenbinding),
18704             ::std::mem::transmute(tokenbindingsize),
18705             ::std::mem::transmute(resultdata),
18706         ))
18707     }
18708     #[cfg(not(windows))]
18709     unimplemented!("Unsupported target OS");
18710 }
18711 #[inline]
18712 pub unsafe fn TokenBindingGenerateID(keytype: TOKENBINDING_KEY_PARAMETERS_TYPE, publickey: *const ::std::ffi::c_void, publickeysize: u32, resultdata: *mut *mut TOKENBINDING_RESULT_DATA) -> i32 {
18713     #[cfg(windows)]
18714     {
18715         #[link(name = "windows")]
18716         extern "system" {
18717             fn TokenBindingGenerateID(keytype: TOKENBINDING_KEY_PARAMETERS_TYPE, publickey: *const ::std::ffi::c_void, publickeysize: u32, resultdata: *mut *mut TOKENBINDING_RESULT_DATA) -> i32;
18718         }
18719         ::std::mem::transmute(TokenBindingGenerateID(::std::mem::transmute(keytype), ::std::mem::transmute(publickey), ::std::mem::transmute(publickeysize), ::std::mem::transmute(resultdata)))
18720     }
18721     #[cfg(not(windows))]
18722     unimplemented!("Unsupported target OS");
18723 }
18724 #[cfg(feature = "Win32_Foundation")]
18725 #[inline]
18726 pub unsafe fn TokenBindingGenerateIDForUri<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(keytype: TOKENBINDING_KEY_PARAMETERS_TYPE, targeturi: Param1, resultdata: *mut *mut TOKENBINDING_RESULT_DATA) -> i32 {
18727     #[cfg(windows)]
18728     {
18729         #[link(name = "windows")]
18730         extern "system" {
18731             fn TokenBindingGenerateIDForUri(keytype: TOKENBINDING_KEY_PARAMETERS_TYPE, targeturi: super::super::super::Foundation::PWSTR, resultdata: *mut *mut TOKENBINDING_RESULT_DATA) -> i32;
18732         }
18733         ::std::mem::transmute(TokenBindingGenerateIDForUri(::std::mem::transmute(keytype), targeturi.into_param().abi(), ::std::mem::transmute(resultdata)))
18734     }
18735     #[cfg(not(windows))]
18736     unimplemented!("Unsupported target OS");
18737 }
18738 #[inline]
18739 pub unsafe fn TokenBindingGenerateMessage(tokenbindings: *const *const ::std::ffi::c_void, tokenbindingssize: *const u32, tokenbindingscount: u32, tokenbindingmessage: *mut *mut ::std::ffi::c_void, tokenbindingmessagesize: *mut u32) -> i32 {
18740     #[cfg(windows)]
18741     {
18742         #[link(name = "windows")]
18743         extern "system" {
18744             fn TokenBindingGenerateMessage(tokenbindings: *const *const ::std::ffi::c_void, tokenbindingssize: *const u32, tokenbindingscount: u32, tokenbindingmessage: *mut *mut ::std::ffi::c_void, tokenbindingmessagesize: *mut u32) -> i32;
18745         }
18746         ::std::mem::transmute(TokenBindingGenerateMessage(::std::mem::transmute(tokenbindings), ::std::mem::transmute(tokenbindingssize), ::std::mem::transmute(tokenbindingscount), ::std::mem::transmute(tokenbindingmessage), ::std::mem::transmute(tokenbindingmessagesize)))
18747     }
18748     #[cfg(not(windows))]
18749     unimplemented!("Unsupported target OS");
18750 }
18751 #[inline]
18752 pub unsafe fn TokenBindingGetHighestSupportedVersion(majorversion: *mut u8, minorversion: *mut u8) -> i32 {
18753     #[cfg(windows)]
18754     {
18755         #[link(name = "windows")]
18756         extern "system" {
18757             fn TokenBindingGetHighestSupportedVersion(majorversion: *mut u8, minorversion: *mut u8) -> i32;
18758         }
18759         ::std::mem::transmute(TokenBindingGetHighestSupportedVersion(::std::mem::transmute(majorversion), ::std::mem::transmute(minorversion)))
18760     }
18761     #[cfg(not(windows))]
18762     unimplemented!("Unsupported target OS");
18763 }
18764 #[inline]
18765 pub unsafe fn TokenBindingGetKeyTypesClient(keytypes: *mut *mut TOKENBINDING_KEY_TYPES) -> i32 {
18766     #[cfg(windows)]
18767     {
18768         #[link(name = "windows")]
18769         extern "system" {
18770             fn TokenBindingGetKeyTypesClient(keytypes: *mut *mut TOKENBINDING_KEY_TYPES) -> i32;
18771         }
18772         ::std::mem::transmute(TokenBindingGetKeyTypesClient(::std::mem::transmute(keytypes)))
18773     }
18774     #[cfg(not(windows))]
18775     unimplemented!("Unsupported target OS");
18776 }
18777 #[inline]
18778 pub unsafe fn TokenBindingGetKeyTypesServer(keytypes: *mut *mut TOKENBINDING_KEY_TYPES) -> i32 {
18779     #[cfg(windows)]
18780     {
18781         #[link(name = "windows")]
18782         extern "system" {
18783             fn TokenBindingGetKeyTypesServer(keytypes: *mut *mut TOKENBINDING_KEY_TYPES) -> i32;
18784         }
18785         ::std::mem::transmute(TokenBindingGetKeyTypesServer(::std::mem::transmute(keytypes)))
18786     }
18787     #[cfg(not(windows))]
18788     unimplemented!("Unsupported target OS");
18789 }
18790 #[inline]
18791 pub unsafe fn TokenBindingVerifyMessage(tokenbindingmessage: *const ::std::ffi::c_void, tokenbindingmessagesize: u32, keytype: TOKENBINDING_KEY_PARAMETERS_TYPE, tlsekm: *const ::std::ffi::c_void, tlsekmsize: u32, resultlist: *mut *mut TOKENBINDING_RESULT_LIST) -> i32 {
18792     #[cfg(windows)]
18793     {
18794         #[link(name = "windows")]
18795         extern "system" {
18796             fn TokenBindingVerifyMessage(tokenbindingmessage: *const ::std::ffi::c_void, tokenbindingmessagesize: u32, keytype: TOKENBINDING_KEY_PARAMETERS_TYPE, tlsekm: *const ::std::ffi::c_void, tlsekmsize: u32, resultlist: *mut *mut TOKENBINDING_RESULT_LIST) -> i32;
18797         }
18798         ::std::mem::transmute(TokenBindingVerifyMessage(::std::mem::transmute(tokenbindingmessage), ::std::mem::transmute(tokenbindingmessagesize), ::std::mem::transmute(keytype), ::std::mem::transmute(tlsekm), ::std::mem::transmute(tlsekmsize), ::std::mem::transmute(resultlist)))
18799     }
18800     #[cfg(not(windows))]
18801     unimplemented!("Unsupported target OS");
18802 }
18803 #[cfg(feature = "Win32_Foundation")]
18804 #[inline]
18805 pub unsafe fn TranslateNameA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PSTR>>(lpaccountname: Param0, accountnameformat: EXTENDED_NAME_FORMAT, desirednameformat: EXTENDED_NAME_FORMAT, lptranslatedname: super::super::super::Foundation::PSTR, nsize: *mut u32) -> super::super::super::Foundation::BOOLEAN {
18806     #[cfg(windows)]
18807     {
18808         #[link(name = "windows")]
18809         extern "system" {
18810             fn TranslateNameA(lpaccountname: super::super::super::Foundation::PSTR, accountnameformat: EXTENDED_NAME_FORMAT, desirednameformat: EXTENDED_NAME_FORMAT, lptranslatedname: super::super::super::Foundation::PSTR, nsize: *mut u32) -> super::super::super::Foundation::BOOLEAN;
18811         }
18812         ::std::mem::transmute(TranslateNameA(lpaccountname.into_param().abi(), ::std::mem::transmute(accountnameformat), ::std::mem::transmute(desirednameformat), ::std::mem::transmute(lptranslatedname), ::std::mem::transmute(nsize)))
18813     }
18814     #[cfg(not(windows))]
18815     unimplemented!("Unsupported target OS");
18816 }
18817 #[cfg(feature = "Win32_Foundation")]
18818 #[inline]
18819 pub unsafe fn TranslateNameW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(lpaccountname: Param0, accountnameformat: EXTENDED_NAME_FORMAT, desirednameformat: EXTENDED_NAME_FORMAT, lptranslatedname: super::super::super::Foundation::PWSTR, nsize: *mut u32) -> super::super::super::Foundation::BOOLEAN {
18820     #[cfg(windows)]
18821     {
18822         #[link(name = "windows")]
18823         extern "system" {
18824             fn TranslateNameW(lpaccountname: super::super::super::Foundation::PWSTR, accountnameformat: EXTENDED_NAME_FORMAT, desirednameformat: EXTENDED_NAME_FORMAT, lptranslatedname: super::super::super::Foundation::PWSTR, nsize: *mut u32) -> super::super::super::Foundation::BOOLEAN;
18825         }
18826         ::std::mem::transmute(TranslateNameW(lpaccountname.into_param().abi(), ::std::mem::transmute(accountnameformat), ::std::mem::transmute(desirednameformat), ::std::mem::transmute(lptranslatedname), ::std::mem::transmute(nsize)))
18827     }
18828     #[cfg(not(windows))]
18829     unimplemented!("Unsupported target OS");
18830 }
18831 pub const UNDERSTANDS_LONG_NAMES: u32 = 1u32;
18832 pub const UNISP_RPC_ID: u32 = 14u32;
18833 pub const USER_ACCOUNT_AUTO_LOCKED: u32 = 1024u32;
18834 pub const USER_ACCOUNT_DISABLED: u32 = 1u32;
18835 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18836 #[repr(C, packed(4))]
18837 #[cfg(feature = "Win32_Foundation")]
18838 pub struct USER_ALL_INFORMATION {
18839     pub LastLogon: i64,
18840     pub LastLogoff: i64,
18841     pub PasswordLastSet: i64,
18842     pub AccountExpires: i64,
18843     pub PasswordCanChange: i64,
18844     pub PasswordMustChange: i64,
18845     pub UserName: super::super::super::Foundation::UNICODE_STRING,
18846     pub FullName: super::super::super::Foundation::UNICODE_STRING,
18847     pub HomeDirectory: super::super::super::Foundation::UNICODE_STRING,
18848     pub HomeDirectoryDrive: super::super::super::Foundation::UNICODE_STRING,
18849     pub ScriptPath: super::super::super::Foundation::UNICODE_STRING,
18850     pub ProfilePath: super::super::super::Foundation::UNICODE_STRING,
18851     pub AdminComment: super::super::super::Foundation::UNICODE_STRING,
18852     pub WorkStations: super::super::super::Foundation::UNICODE_STRING,
18853     pub UserComment: super::super::super::Foundation::UNICODE_STRING,
18854     pub Parameters: super::super::super::Foundation::UNICODE_STRING,
18855     pub LmPassword: super::super::super::Foundation::UNICODE_STRING,
18856     pub NtPassword: super::super::super::Foundation::UNICODE_STRING,
18857     pub PrivateData: super::super::super::Foundation::UNICODE_STRING,
18858     pub SecurityDescriptor: SR_SECURITY_DESCRIPTOR,
18859     pub UserId: u32,
18860     pub PrimaryGroupId: u32,
18861     pub UserAccountControl: u32,
18862     pub WhichFields: u32,
18863     pub LogonHours: LOGON_HOURS,
18864     pub BadPasswordCount: u16,
18865     pub LogonCount: u16,
18866     pub CountryCode: u16,
18867     pub CodePage: u16,
18868     pub LmPasswordPresent: super::super::super::Foundation::BOOLEAN,
18869     pub NtPasswordPresent: super::super::super::Foundation::BOOLEAN,
18870     pub PasswordExpired: super::super::super::Foundation::BOOLEAN,
18871     pub PrivateDataSensitive: super::super::super::Foundation::BOOLEAN,
18872 }
18873 #[cfg(feature = "Win32_Foundation")]
18874 impl USER_ALL_INFORMATION {}
18875 #[cfg(feature = "Win32_Foundation")]
18876 impl ::std::default::Default for USER_ALL_INFORMATION {
18877     fn default() -> Self {
18878         unsafe { ::std::mem::zeroed() }
18879     }
18880 }
18881 #[cfg(feature = "Win32_Foundation")]
18882 impl ::std::cmp::PartialEq for USER_ALL_INFORMATION {
18883     fn eq(&self, _other: &Self) -> bool {
18884         unimplemented!()
18885     }
18886 }
18887 #[cfg(feature = "Win32_Foundation")]
18888 impl ::std::cmp::Eq for USER_ALL_INFORMATION {}
18889 #[cfg(feature = "Win32_Foundation")]
18890 unsafe impl ::windows::runtime::Abi for USER_ALL_INFORMATION {
18891     type Abi = Self;
18892     type DefaultType = Self;
18893 }
18894 pub const USER_ALL_PARAMETERS: u32 = 2097152u32;
18895 pub const USER_DONT_EXPIRE_PASSWORD: u32 = 512u32;
18896 pub const USER_DONT_REQUIRE_PREAUTH: u32 = 65536u32;
18897 pub const USER_ENCRYPTED_TEXT_PASSWORD_ALLOWED: u32 = 2048u32;
18898 pub const USER_HOME_DIRECTORY_REQUIRED: u32 = 2u32;
18899 pub const USER_INTERDOMAIN_TRUST_ACCOUNT: u32 = 64u32;
18900 pub const USER_MNS_LOGON_ACCOUNT: u32 = 32u32;
18901 pub const USER_NORMAL_ACCOUNT: u32 = 16u32;
18902 pub const USER_NOT_DELEGATED: u32 = 16384u32;
18903 pub const USER_NO_AUTH_DATA_REQUIRED: u32 = 524288u32;
18904 pub const USER_PARTIAL_SECRETS_ACCOUNT: u32 = 1048576u32;
18905 pub const USER_PASSWORD_EXPIRED: u32 = 131072u32;
18906 pub const USER_PASSWORD_NOT_REQUIRED: u32 = 4u32;
18907 pub const USER_SERVER_TRUST_ACCOUNT: u32 = 256u32;
18908 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18909 #[repr(C)]
18910 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
18911 pub struct USER_SESSION_KEY {
18912     pub data: [super::super::super::System::PasswordManagement::CYPHER_BLOCK; 2],
18913 }
18914 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
18915 impl USER_SESSION_KEY {}
18916 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
18917 impl ::std::default::Default for USER_SESSION_KEY {
18918     fn default() -> Self {
18919         unsafe { ::std::mem::zeroed() }
18920     }
18921 }
18922 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
18923 impl ::std::fmt::Debug for USER_SESSION_KEY {
18924     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18925         fmt.debug_struct("USER_SESSION_KEY").field("data", &self.data).finish()
18926     }
18927 }
18928 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
18929 impl ::std::cmp::PartialEq for USER_SESSION_KEY {
18930     fn eq(&self, other: &Self) -> bool {
18931         self.data == other.data
18932     }
18933 }
18934 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
18935 impl ::std::cmp::Eq for USER_SESSION_KEY {}
18936 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_PasswordManagement"))]
18937 unsafe impl ::windows::runtime::Abi for USER_SESSION_KEY {
18938     type Abi = Self;
18939     type DefaultType = Self;
18940 }
18941 pub const USER_SMARTCARD_REQUIRED: u32 = 4096u32;
18942 pub const USER_TEMP_DUPLICATE_ACCOUNT: u32 = 8u32;
18943 pub const USER_TRUSTED_FOR_DELEGATION: u32 = 8192u32;
18944 pub const USER_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION: u32 = 262144u32;
18945 pub const USER_USE_AES_KEYS: u32 = 2097152u32;
18946 pub const USER_USE_DES_KEY_ONLY: u32 = 32768u32;
18947 pub const USER_WORKSTATION_TRUST_ACCOUNT: u32 = 128u32;
18948 #[cfg(feature = "Win32_Security_Credentials")]
18949 pub type VERIFY_SIGNATURE_FN = unsafe extern "system" fn(param0: *mut super::super::Credentials::SecHandle, param1: *mut SecBufferDesc, param2: u32, param3: *mut u32) -> i32;
18950 #[cfg(feature = "Win32_Security_Credentials")]
18951 #[inline]
18952 pub unsafe fn VerifySignature(phcontext: *const super::super::Credentials::SecHandle, pmessage: *const SecBufferDesc, messageseqno: u32, pfqop: *mut u32) -> i32 {
18953     #[cfg(windows)]
18954     {
18955         #[link(name = "windows")]
18956         extern "system" {
18957             fn VerifySignature(phcontext: *const super::super::Credentials::SecHandle, pmessage: *const SecBufferDesc, messageseqno: u32, pfqop: *mut u32) -> i32;
18958         }
18959         ::std::mem::transmute(VerifySignature(::std::mem::transmute(phcontext), ::std::mem::transmute(pmessage), ::std::mem::transmute(messageseqno), ::std::mem::transmute(pfqop)))
18960     }
18961     #[cfg(not(windows))]
18962     unimplemented!("Unsupported target OS");
18963 }
18964 pub const WINDOWS_SLID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1439246132, 54914, 19825, [152, 62, 214, 236, 63, 22, 5, 159]);
18965 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
18966 #[repr(C)]
18967 #[cfg(feature = "Win32_Foundation")]
18968 pub struct X509Certificate {
18969     pub Version: u32,
18970     pub SerialNumber: [u32; 4],
18971     pub SignatureAlgorithm: u32,
18972     pub ValidFrom: super::super::super::Foundation::FILETIME,
18973     pub ValidUntil: super::super::super::Foundation::FILETIME,
18974     pub pszIssuer: super::super::super::Foundation::PSTR,
18975     pub pszSubject: super::super::super::Foundation::PSTR,
18976     pub pPublicKey: *mut PctPublicKey,
18977 }
18978 #[cfg(feature = "Win32_Foundation")]
18979 impl X509Certificate {}
18980 #[cfg(feature = "Win32_Foundation")]
18981 impl ::std::default::Default for X509Certificate {
18982     fn default() -> Self {
18983         unsafe { ::std::mem::zeroed() }
18984     }
18985 }
18986 #[cfg(feature = "Win32_Foundation")]
18987 impl ::std::fmt::Debug for X509Certificate {
18988     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
18989         fmt.debug_struct("X509Certificate")
18990             .field("Version", &self.Version)
18991             .field("SerialNumber", &self.SerialNumber)
18992             .field("SignatureAlgorithm", &self.SignatureAlgorithm)
18993             .field("ValidFrom", &self.ValidFrom)
18994             .field("ValidUntil", &self.ValidUntil)
18995             .field("pszIssuer", &self.pszIssuer)
18996             .field("pszSubject", &self.pszSubject)
18997             .field("pPublicKey", &self.pPublicKey)
18998             .finish()
18999     }
19000 }
19001 #[cfg(feature = "Win32_Foundation")]
19002 impl ::std::cmp::PartialEq for X509Certificate {
19003     fn eq(&self, other: &Self) -> bool {
19004         self.Version == other.Version && self.SerialNumber == other.SerialNumber && self.SignatureAlgorithm == other.SignatureAlgorithm && self.ValidFrom == other.ValidFrom && self.ValidUntil == other.ValidUntil && self.pszIssuer == other.pszIssuer && self.pszSubject == other.pszSubject && self.pPublicKey == other.pPublicKey
19005     }
19006 }
19007 #[cfg(feature = "Win32_Foundation")]
19008 impl ::std::cmp::Eq for X509Certificate {}
19009 #[cfg(feature = "Win32_Foundation")]
19010 unsafe impl ::windows::runtime::Abi for X509Certificate {
19011     type Abi = Self;
19012     type DefaultType = Self;
19013 }
19014 pub const _FACILITY_WINDOWS_STORE: u32 = 63u32;
19015 #[repr(C)]
19016 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
19017 pub struct _HMAPPER(pub u8);
19018 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
19019 #[repr(transparent)]
19020 pub struct eTlsHashAlgorithm(pub i32);
19021 pub const TlsHashAlgorithm_None: eTlsHashAlgorithm = eTlsHashAlgorithm(0i32);
19022 pub const TlsHashAlgorithm_Md5: eTlsHashAlgorithm = eTlsHashAlgorithm(1i32);
19023 pub const TlsHashAlgorithm_Sha1: eTlsHashAlgorithm = eTlsHashAlgorithm(2i32);
19024 pub const TlsHashAlgorithm_Sha224: eTlsHashAlgorithm = eTlsHashAlgorithm(3i32);
19025 pub const TlsHashAlgorithm_Sha256: eTlsHashAlgorithm = eTlsHashAlgorithm(4i32);
19026 pub const TlsHashAlgorithm_Sha384: eTlsHashAlgorithm = eTlsHashAlgorithm(5i32);
19027 pub const TlsHashAlgorithm_Sha512: eTlsHashAlgorithm = eTlsHashAlgorithm(6i32);
19028 impl ::std::convert::From<i32> for eTlsHashAlgorithm {
19029     fn from(value: i32) -> Self {
19030         Self(value)
19031     }
19032 }
19033 unsafe impl ::windows::runtime::Abi for eTlsHashAlgorithm {
19034     type Abi = Self;
19035     type DefaultType = Self;
19036 }
19037 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
19038 #[repr(transparent)]
19039 pub struct eTlsSignatureAlgorithm(pub i32);
19040 pub const TlsSignatureAlgorithm_Anonymous: eTlsSignatureAlgorithm = eTlsSignatureAlgorithm(0i32);
19041 pub const TlsSignatureAlgorithm_Rsa: eTlsSignatureAlgorithm = eTlsSignatureAlgorithm(1i32);
19042 pub const TlsSignatureAlgorithm_Dsa: eTlsSignatureAlgorithm = eTlsSignatureAlgorithm(2i32);
19043 pub const TlsSignatureAlgorithm_Ecdsa: eTlsSignatureAlgorithm = eTlsSignatureAlgorithm(3i32);
19044 impl ::std::convert::From<i32> for eTlsSignatureAlgorithm {
19045     fn from(value: i32) -> Self {
19046         Self(value)
19047     }
19048 }
19049 unsafe impl ::windows::runtime::Abi for eTlsSignatureAlgorithm {
19050     type Abi = Self;
19051     type DefaultType = Self;
19052 }
19053