1 #![allow(non_snake_case, non_camel_case_types, non_upper_case_globals, clashing_extern_declarations, clippy::all)]
2 #[link(name = "windows")]
3 extern "system" {}
4 pub type CardAddedEventArgs = *mut ::core::ffi::c_void;
5 pub type CardRemovedEventArgs = *mut ::core::ffi::c_void;
6 pub type SmartCard = *mut ::core::ffi::c_void;
7 #[repr(transparent)]
8 pub struct SmartCardActivationPolicyChangeResult(pub i32);
9 impl SmartCardActivationPolicyChangeResult {
10     pub const Denied: Self = Self(0i32);
11     pub const Allowed: Self = Self(1i32);
12 }
13 impl ::core::marker::Copy for SmartCardActivationPolicyChangeResult {}
14 impl ::core::clone::Clone for SmartCardActivationPolicyChangeResult {
clone(&self) -> Self15     fn clone(&self) -> Self {
16         *self
17     }
18 }
19 pub type SmartCardAppletIdGroup = *mut ::core::ffi::c_void;
20 #[repr(transparent)]
21 pub struct SmartCardAppletIdGroupActivationPolicy(pub i32);
22 impl SmartCardAppletIdGroupActivationPolicy {
23     pub const Disabled: Self = Self(0i32);
24     pub const ForegroundOverride: Self = Self(1i32);
25     pub const Enabled: Self = Self(2i32);
26 }
27 impl ::core::marker::Copy for SmartCardAppletIdGroupActivationPolicy {}
28 impl ::core::clone::Clone for SmartCardAppletIdGroupActivationPolicy {
clone(&self) -> Self29     fn clone(&self) -> Self {
30         *self
31     }
32 }
33 pub type SmartCardAppletIdGroupRegistration = *mut ::core::ffi::c_void;
34 pub type SmartCardAutomaticResponseApdu = *mut ::core::ffi::c_void;
35 #[repr(transparent)]
36 pub struct SmartCardAutomaticResponseStatus(pub i32);
37 impl SmartCardAutomaticResponseStatus {
38     pub const None: Self = Self(0i32);
39     pub const Success: Self = Self(1i32);
40     pub const UnknownError: Self = Self(2i32);
41 }
42 impl ::core::marker::Copy for SmartCardAutomaticResponseStatus {}
43 impl ::core::clone::Clone for SmartCardAutomaticResponseStatus {
clone(&self) -> Self44     fn clone(&self) -> Self {
45         *self
46     }
47 }
48 pub type SmartCardChallengeContext = *mut ::core::ffi::c_void;
49 pub type SmartCardConnection = *mut ::core::ffi::c_void;
50 #[repr(transparent)]
51 pub struct SmartCardCryptogramAlgorithm(pub i32);
52 impl SmartCardCryptogramAlgorithm {
53     pub const None: Self = Self(0i32);
54     pub const CbcMac: Self = Self(1i32);
55     pub const Cvc3Umd: Self = Self(2i32);
56     pub const DecimalizedMsd: Self = Self(3i32);
57     pub const Cvc3MD: Self = Self(4i32);
58     pub const Sha1: Self = Self(5i32);
59     pub const SignedDynamicApplicationData: Self = Self(6i32);
60     pub const RsaPkcs1: Self = Self(7i32);
61     pub const Sha256Hmac: Self = Self(8i32);
62 }
63 impl ::core::marker::Copy for SmartCardCryptogramAlgorithm {}
64 impl ::core::clone::Clone for SmartCardCryptogramAlgorithm {
clone(&self) -> Self65     fn clone(&self) -> Self {
66         *self
67     }
68 }
69 pub type SmartCardCryptogramGenerator = *mut ::core::ffi::c_void;
70 #[repr(transparent)]
71 pub struct SmartCardCryptogramGeneratorOperationStatus(pub i32);
72 impl SmartCardCryptogramGeneratorOperationStatus {
73     pub const Success: Self = Self(0i32);
74     pub const AuthorizationFailed: Self = Self(1i32);
75     pub const AuthorizationCanceled: Self = Self(2i32);
76     pub const AuthorizationRequired: Self = Self(3i32);
77     pub const CryptogramMaterialPackageStorageKeyExists: Self = Self(4i32);
78     pub const NoCryptogramMaterialPackageStorageKey: Self = Self(5i32);
79     pub const NoCryptogramMaterialPackage: Self = Self(6i32);
80     pub const UnsupportedCryptogramMaterialPackage: Self = Self(7i32);
81     pub const UnknownCryptogramMaterialName: Self = Self(8i32);
82     pub const InvalidCryptogramMaterialUsage: Self = Self(9i32);
83     pub const ApduResponseNotSent: Self = Self(10i32);
84     pub const OtherError: Self = Self(11i32);
85     pub const ValidationFailed: Self = Self(12i32);
86     pub const NotSupported: Self = Self(13i32);
87 }
88 impl ::core::marker::Copy for SmartCardCryptogramGeneratorOperationStatus {}
89 impl ::core::clone::Clone for SmartCardCryptogramGeneratorOperationStatus {
clone(&self) -> Self90     fn clone(&self) -> Self {
91         *self
92     }
93 }
94 pub type SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult = *mut ::core::ffi::c_void;
95 pub type SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult = *mut ::core::ffi::c_void;
96 pub type SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult = *mut ::core::ffi::c_void;
97 pub type SmartCardCryptogramMaterialCharacteristics = *mut ::core::ffi::c_void;
98 pub type SmartCardCryptogramMaterialPackageCharacteristics = *mut ::core::ffi::c_void;
99 #[repr(transparent)]
100 pub struct SmartCardCryptogramMaterialPackageConfirmationResponseFormat(pub i32);
101 impl SmartCardCryptogramMaterialPackageConfirmationResponseFormat {
102     pub const None: Self = Self(0i32);
103     pub const VisaHmac: Self = Self(1i32);
104 }
105 impl ::core::marker::Copy for SmartCardCryptogramMaterialPackageConfirmationResponseFormat {}
106 impl ::core::clone::Clone for SmartCardCryptogramMaterialPackageConfirmationResponseFormat {
clone(&self) -> Self107     fn clone(&self) -> Self {
108         *self
109     }
110 }
111 #[repr(transparent)]
112 pub struct SmartCardCryptogramMaterialPackageFormat(pub i32);
113 impl SmartCardCryptogramMaterialPackageFormat {
114     pub const None: Self = Self(0i32);
115     pub const JweRsaPki: Self = Self(1i32);
116 }
117 impl ::core::marker::Copy for SmartCardCryptogramMaterialPackageFormat {}
118 impl ::core::clone::Clone for SmartCardCryptogramMaterialPackageFormat {
clone(&self) -> Self119     fn clone(&self) -> Self {
120         *self
121     }
122 }
123 pub type SmartCardCryptogramMaterialPossessionProof = *mut ::core::ffi::c_void;
124 #[repr(transparent)]
125 pub struct SmartCardCryptogramMaterialProtectionMethod(pub i32);
126 impl SmartCardCryptogramMaterialProtectionMethod {
127     pub const None: Self = Self(0i32);
128     pub const WhiteBoxing: Self = Self(1i32);
129 }
130 impl ::core::marker::Copy for SmartCardCryptogramMaterialProtectionMethod {}
131 impl ::core::clone::Clone for SmartCardCryptogramMaterialProtectionMethod {
clone(&self) -> Self132     fn clone(&self) -> Self {
133         *self
134     }
135 }
136 #[repr(transparent)]
137 pub struct SmartCardCryptogramMaterialType(pub i32);
138 impl SmartCardCryptogramMaterialType {
139     pub const None: Self = Self(0i32);
140     pub const StaticDataAuthentication: Self = Self(1i32);
141     pub const TripleDes112: Self = Self(2i32);
142     pub const Aes: Self = Self(3i32);
143     pub const RsaPkcs1: Self = Self(4i32);
144 }
145 impl ::core::marker::Copy for SmartCardCryptogramMaterialType {}
146 impl ::core::clone::Clone for SmartCardCryptogramMaterialType {
clone(&self) -> Self147     fn clone(&self) -> Self {
148         *self
149     }
150 }
151 #[repr(transparent)]
152 pub struct SmartCardCryptogramPlacementOptions(pub u32);
153 impl SmartCardCryptogramPlacementOptions {
154     pub const None: Self = Self(0u32);
155     pub const UnitsAreInNibbles: Self = Self(1u32);
156     pub const ChainOutput: Self = Self(2u32);
157 }
158 impl ::core::marker::Copy for SmartCardCryptogramPlacementOptions {}
159 impl ::core::clone::Clone for SmartCardCryptogramPlacementOptions {
clone(&self) -> Self160     fn clone(&self) -> Self {
161         *self
162     }
163 }
164 pub type SmartCardCryptogramPlacementStep = *mut ::core::ffi::c_void;
165 #[repr(transparent)]
166 pub struct SmartCardCryptogramStorageKeyAlgorithm(pub i32);
167 impl SmartCardCryptogramStorageKeyAlgorithm {
168     pub const None: Self = Self(0i32);
169     pub const Rsa2048: Self = Self(1i32);
170 }
171 impl ::core::marker::Copy for SmartCardCryptogramStorageKeyAlgorithm {}
172 impl ::core::clone::Clone for SmartCardCryptogramStorageKeyAlgorithm {
clone(&self) -> Self173     fn clone(&self) -> Self {
174         *self
175     }
176 }
177 #[repr(transparent)]
178 pub struct SmartCardCryptogramStorageKeyCapabilities(pub u32);
179 impl SmartCardCryptogramStorageKeyCapabilities {
180     pub const None: Self = Self(0u32);
181     pub const HardwareProtection: Self = Self(1u32);
182     pub const UnlockPrompt: Self = Self(2u32);
183 }
184 impl ::core::marker::Copy for SmartCardCryptogramStorageKeyCapabilities {}
185 impl ::core::clone::Clone for SmartCardCryptogramStorageKeyCapabilities {
clone(&self) -> Self186     fn clone(&self) -> Self {
187         *self
188     }
189 }
190 pub type SmartCardCryptogramStorageKeyCharacteristics = *mut ::core::ffi::c_void;
191 pub type SmartCardCryptogramStorageKeyInfo = *mut ::core::ffi::c_void;
192 #[repr(transparent)]
193 pub struct SmartCardCryptographicKeyAttestationStatus(pub i32);
194 impl SmartCardCryptographicKeyAttestationStatus {
195     pub const NoAttestation: Self = Self(0i32);
196     pub const SoftwareKeyWithoutTpm: Self = Self(1i32);
197     pub const SoftwareKeyWithTpm: Self = Self(2i32);
198     pub const TpmKeyUnknownAttestationStatus: Self = Self(3i32);
199     pub const TpmKeyWithoutAttestationCapability: Self = Self(4i32);
200     pub const TpmKeyWithTemporaryAttestationFailure: Self = Self(5i32);
201     pub const TpmKeyWithLongTermAttestationFailure: Self = Self(6i32);
202     pub const TpmKeyWithAttestation: Self = Self(7i32);
203 }
204 impl ::core::marker::Copy for SmartCardCryptographicKeyAttestationStatus {}
205 impl ::core::clone::Clone for SmartCardCryptographicKeyAttestationStatus {
clone(&self) -> Self206     fn clone(&self) -> Self {
207         *self
208     }
209 }
210 #[repr(transparent)]
211 pub struct SmartCardEmulationCategory(pub i32);
212 impl SmartCardEmulationCategory {
213     pub const Other: Self = Self(0i32);
214     pub const Payment: Self = Self(1i32);
215 }
216 impl ::core::marker::Copy for SmartCardEmulationCategory {}
217 impl ::core::clone::Clone for SmartCardEmulationCategory {
clone(&self) -> Self218     fn clone(&self) -> Self {
219         *self
220     }
221 }
222 #[repr(transparent)]
223 pub struct SmartCardEmulationType(pub i32);
224 impl SmartCardEmulationType {
225     pub const Host: Self = Self(0i32);
226     pub const Uicc: Self = Self(1i32);
227     pub const EmbeddedSE: Self = Self(2i32);
228 }
229 impl ::core::marker::Copy for SmartCardEmulationType {}
230 impl ::core::clone::Clone for SmartCardEmulationType {
clone(&self) -> Self231     fn clone(&self) -> Self {
232         *self
233     }
234 }
235 pub type SmartCardEmulator = *mut ::core::ffi::c_void;
236 pub type SmartCardEmulatorApduReceivedEventArgs = *mut ::core::ffi::c_void;
237 pub type SmartCardEmulatorConnectionDeactivatedEventArgs = *mut ::core::ffi::c_void;
238 #[repr(transparent)]
239 pub struct SmartCardEmulatorConnectionDeactivatedReason(pub i32);
240 impl SmartCardEmulatorConnectionDeactivatedReason {
241     pub const ConnectionLost: Self = Self(0i32);
242     pub const ConnectionRedirected: Self = Self(1i32);
243 }
244 impl ::core::marker::Copy for SmartCardEmulatorConnectionDeactivatedReason {}
245 impl ::core::clone::Clone for SmartCardEmulatorConnectionDeactivatedReason {
clone(&self) -> Self246     fn clone(&self) -> Self {
247         *self
248     }
249 }
250 pub type SmartCardEmulatorConnectionProperties = *mut ::core::ffi::c_void;
251 #[repr(transparent)]
252 pub struct SmartCardEmulatorConnectionSource(pub i32);
253 impl SmartCardEmulatorConnectionSource {
254     pub const Unknown: Self = Self(0i32);
255     pub const NfcReader: Self = Self(1i32);
256 }
257 impl ::core::marker::Copy for SmartCardEmulatorConnectionSource {}
258 impl ::core::clone::Clone for SmartCardEmulatorConnectionSource {
clone(&self) -> Self259     fn clone(&self) -> Self {
260         *self
261     }
262 }
263 #[repr(transparent)]
264 pub struct SmartCardEmulatorEnablementPolicy(pub i32);
265 impl SmartCardEmulatorEnablementPolicy {
266     pub const Never: Self = Self(0i32);
267     pub const Always: Self = Self(1i32);
268     pub const ScreenOn: Self = Self(2i32);
269     pub const ScreenUnlocked: Self = Self(3i32);
270 }
271 impl ::core::marker::Copy for SmartCardEmulatorEnablementPolicy {}
272 impl ::core::clone::Clone for SmartCardEmulatorEnablementPolicy {
clone(&self) -> Self273     fn clone(&self) -> Self {
274         *self
275     }
276 }
277 #[repr(transparent)]
278 pub struct SmartCardLaunchBehavior(pub i32);
279 impl SmartCardLaunchBehavior {
280     pub const Default: Self = Self(0i32);
281     pub const AboveLock: Self = Self(1i32);
282 }
283 impl ::core::marker::Copy for SmartCardLaunchBehavior {}
284 impl ::core::clone::Clone for SmartCardLaunchBehavior {
clone(&self) -> Self285     fn clone(&self) -> Self {
286         *self
287     }
288 }
289 #[repr(transparent)]
290 pub struct SmartCardPinCharacterPolicyOption(pub i32);
291 impl SmartCardPinCharacterPolicyOption {
292     pub const Allow: Self = Self(0i32);
293     pub const RequireAtLeastOne: Self = Self(1i32);
294     pub const Disallow: Self = Self(2i32);
295 }
296 impl ::core::marker::Copy for SmartCardPinCharacterPolicyOption {}
297 impl ::core::clone::Clone for SmartCardPinCharacterPolicyOption {
clone(&self) -> Self298     fn clone(&self) -> Self {
299         *self
300     }
301 }
302 pub type SmartCardPinPolicy = *mut ::core::ffi::c_void;
303 pub type SmartCardPinResetDeferral = *mut ::core::ffi::c_void;
304 pub type SmartCardPinResetHandler = *mut ::core::ffi::c_void;
305 pub type SmartCardPinResetRequest = *mut ::core::ffi::c_void;
306 pub type SmartCardProvisioning = *mut ::core::ffi::c_void;
307 pub type SmartCardReader = *mut ::core::ffi::c_void;
308 #[repr(transparent)]
309 pub struct SmartCardReaderKind(pub i32);
310 impl SmartCardReaderKind {
311     pub const Any: Self = Self(0i32);
312     pub const Generic: Self = Self(1i32);
313     pub const Tpm: Self = Self(2i32);
314     pub const Nfc: Self = Self(3i32);
315     pub const Uicc: Self = Self(4i32);
316     pub const EmbeddedSE: Self = Self(5i32);
317 }
318 impl ::core::marker::Copy for SmartCardReaderKind {}
319 impl ::core::clone::Clone for SmartCardReaderKind {
clone(&self) -> Self320     fn clone(&self) -> Self {
321         *self
322     }
323 }
324 #[repr(transparent)]
325 pub struct SmartCardReaderStatus(pub i32);
326 impl SmartCardReaderStatus {
327     pub const Disconnected: Self = Self(0i32);
328     pub const Ready: Self = Self(1i32);
329     pub const Exclusive: Self = Self(2i32);
330 }
331 impl ::core::marker::Copy for SmartCardReaderStatus {}
332 impl ::core::clone::Clone for SmartCardReaderStatus {
clone(&self) -> Self333     fn clone(&self) -> Self {
334         *self
335     }
336 }
337 #[repr(transparent)]
338 pub struct SmartCardStatus(pub i32);
339 impl SmartCardStatus {
340     pub const Disconnected: Self = Self(0i32);
341     pub const Ready: Self = Self(1i32);
342     pub const Shared: Self = Self(2i32);
343     pub const Exclusive: Self = Self(3i32);
344     pub const Unresponsive: Self = Self(4i32);
345 }
346 impl ::core::marker::Copy for SmartCardStatus {}
347 impl ::core::clone::Clone for SmartCardStatus {
clone(&self) -> Self348     fn clone(&self) -> Self {
349         *self
350     }
351 }
352 pub type SmartCardTriggerDetails = *mut ::core::ffi::c_void;
353 #[repr(transparent)]
354 pub struct SmartCardTriggerType(pub i32);
355 impl SmartCardTriggerType {
356     pub const EmulatorTransaction: Self = Self(0i32);
357     pub const EmulatorNearFieldEntry: Self = Self(1i32);
358     pub const EmulatorNearFieldExit: Self = Self(2i32);
359     pub const EmulatorHostApplicationActivated: Self = Self(3i32);
360     pub const EmulatorAppletIdGroupRegistrationChanged: Self = Self(4i32);
361     pub const ReaderCardAdded: Self = Self(5i32);
362 }
363 impl ::core::marker::Copy for SmartCardTriggerType {}
364 impl ::core::clone::Clone for SmartCardTriggerType {
clone(&self) -> Self365     fn clone(&self) -> Self {
366         *self
367     }
368 }
369 #[repr(transparent)]
370 pub struct SmartCardUnlockPromptingBehavior(pub i32);
371 impl SmartCardUnlockPromptingBehavior {
372     pub const AllowUnlockPrompt: Self = Self(0i32);
373     pub const RequireUnlockPrompt: Self = Self(1i32);
374     pub const PreventUnlockPrompt: Self = Self(2i32);
375 }
376 impl ::core::marker::Copy for SmartCardUnlockPromptingBehavior {}
377 impl ::core::clone::Clone for SmartCardUnlockPromptingBehavior {
clone(&self) -> Self378     fn clone(&self) -> Self {
379         *self
380     }
381 }
382