browser_protocol/smartcardemulation/
mod.rs

1use serde::{Serialize, Deserialize};
2use serde_json::Value as JsonValue;
3use std::borrow::Cow;
4
5/// Indicates the PC/SC error code.
6/// 
7/// This maps to:
8/// PC/SC Lite: <https://pcsclite.apdu.fr/api/group__ErrorCodes.html>
9/// Microsoft: <https://learn.microsoft.com/en-us/windows/win32/secauthn/authentication-return-values>
10
11#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
12pub enum ResultCode {
13    #[default]
14    #[serde(rename = "success")]
15    Success,
16    #[serde(rename = "removed-card")]
17    RemovedCard,
18    #[serde(rename = "reset-card")]
19    ResetCard,
20    #[serde(rename = "unpowered-card")]
21    UnpoweredCard,
22    #[serde(rename = "unresponsive-card")]
23    UnresponsiveCard,
24    #[serde(rename = "unsupported-card")]
25    UnsupportedCard,
26    #[serde(rename = "reader-unavailable")]
27    ReaderUnavailable,
28    #[serde(rename = "sharing-violation")]
29    SharingViolation,
30    #[serde(rename = "not-transacted")]
31    NotTransacted,
32    #[serde(rename = "no-smartcard")]
33    NoSmartcard,
34    #[serde(rename = "proto-mismatch")]
35    ProtoMismatch,
36    #[serde(rename = "system-cancelled")]
37    SystemCancelled,
38    #[serde(rename = "not-ready")]
39    NotReady,
40    #[serde(rename = "cancelled")]
41    Cancelled,
42    #[serde(rename = "insufficient-buffer")]
43    InsufficientBuffer,
44    #[serde(rename = "invalid-handle")]
45    InvalidHandle,
46    #[serde(rename = "invalid-parameter")]
47    InvalidParameter,
48    #[serde(rename = "invalid-value")]
49    InvalidValue,
50    #[serde(rename = "no-memory")]
51    NoMemory,
52    #[serde(rename = "timeout")]
53    Timeout,
54    #[serde(rename = "unknown-reader")]
55    UnknownReader,
56    #[serde(rename = "unsupported-feature")]
57    UnsupportedFeature,
58    #[serde(rename = "no-readers-available")]
59    NoReadersAvailable,
60    #[serde(rename = "service-stopped")]
61    ServiceStopped,
62    #[serde(rename = "no-service")]
63    NoService,
64    #[serde(rename = "comm-error")]
65    CommError,
66    #[serde(rename = "internal-error")]
67    InternalError,
68    #[serde(rename = "server-too-busy")]
69    ServerTooBusy,
70    #[serde(rename = "unexpected")]
71    Unexpected,
72    #[serde(rename = "shutdown")]
73    Shutdown,
74    #[serde(rename = "unknown-card")]
75    UnknownCard,
76    #[serde(rename = "unknown")]
77    Unknown,
78}
79
80/// Maps to the |SCARD_SHARE_*| values.
81
82#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
83pub enum ShareMode {
84    #[default]
85    #[serde(rename = "shared")]
86    Shared,
87    #[serde(rename = "exclusive")]
88    Exclusive,
89    #[serde(rename = "direct")]
90    Direct,
91}
92
93/// Indicates what the reader should do with the card.
94
95#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
96pub enum Disposition {
97    #[default]
98    #[serde(rename = "leave-card")]
99    LeaveCard,
100    #[serde(rename = "reset-card")]
101    ResetCard,
102    #[serde(rename = "unpower-card")]
103    UnpowerCard,
104    #[serde(rename = "eject-card")]
105    EjectCard,
106}
107
108/// Maps to |SCARD_*| connection state values.
109
110#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
111pub enum ConnectionState {
112    #[default]
113    #[serde(rename = "absent")]
114    Absent,
115    #[serde(rename = "present")]
116    Present,
117    #[serde(rename = "swallowed")]
118    Swallowed,
119    #[serde(rename = "powered")]
120    Powered,
121    #[serde(rename = "negotiable")]
122    Negotiable,
123    #[serde(rename = "specific")]
124    Specific,
125}
126
127/// Maps to the |SCARD_STATE_*| flags.
128
129#[derive(Debug, Clone, Serialize, Deserialize, Default)]
130#[serde(rename_all = "camelCase")]
131pub struct ReaderStateFlags {
132    #[serde(skip_serializing_if = "Option::is_none")]
133    unaware: Option<bool>,
134    #[serde(skip_serializing_if = "Option::is_none")]
135    ignore: Option<bool>,
136    #[serde(skip_serializing_if = "Option::is_none")]
137    changed: Option<bool>,
138    #[serde(skip_serializing_if = "Option::is_none")]
139    unknown: Option<bool>,
140    #[serde(skip_serializing_if = "Option::is_none")]
141    unavailable: Option<bool>,
142    #[serde(skip_serializing_if = "Option::is_none")]
143    empty: Option<bool>,
144    #[serde(skip_serializing_if = "Option::is_none")]
145    present: Option<bool>,
146    #[serde(skip_serializing_if = "Option::is_none")]
147    exclusive: Option<bool>,
148    #[serde(skip_serializing_if = "Option::is_none")]
149    inuse: Option<bool>,
150    #[serde(skip_serializing_if = "Option::is_none")]
151    mute: Option<bool>,
152    #[serde(skip_serializing_if = "Option::is_none")]
153    unpowered: Option<bool>,
154}
155
156impl ReaderStateFlags {
157    /// Creates a builder for this type.
158    pub fn builder() -> ReaderStateFlagsBuilder {
159        ReaderStateFlagsBuilder {
160            unaware: None,
161            ignore: None,
162            changed: None,
163            unknown: None,
164            unavailable: None,
165            empty: None,
166            present: None,
167            exclusive: None,
168            inuse: None,
169            mute: None,
170            unpowered: None,
171        }
172    }
173    pub fn unaware(&self) -> Option<bool> { self.unaware }
174    pub fn ignore(&self) -> Option<bool> { self.ignore }
175    pub fn changed(&self) -> Option<bool> { self.changed }
176    pub fn unknown(&self) -> Option<bool> { self.unknown }
177    pub fn unavailable(&self) -> Option<bool> { self.unavailable }
178    pub fn empty(&self) -> Option<bool> { self.empty }
179    pub fn present(&self) -> Option<bool> { self.present }
180    pub fn exclusive(&self) -> Option<bool> { self.exclusive }
181    pub fn inuse(&self) -> Option<bool> { self.inuse }
182    pub fn mute(&self) -> Option<bool> { self.mute }
183    pub fn unpowered(&self) -> Option<bool> { self.unpowered }
184}
185
186#[derive(Default)]
187pub struct ReaderStateFlagsBuilder {
188    unaware: Option<bool>,
189    ignore: Option<bool>,
190    changed: Option<bool>,
191    unknown: Option<bool>,
192    unavailable: Option<bool>,
193    empty: Option<bool>,
194    present: Option<bool>,
195    exclusive: Option<bool>,
196    inuse: Option<bool>,
197    mute: Option<bool>,
198    unpowered: Option<bool>,
199}
200
201impl ReaderStateFlagsBuilder {
202    pub fn unaware(mut self, unaware: bool) -> Self { self.unaware = Some(unaware); self }
203    pub fn ignore(mut self, ignore: bool) -> Self { self.ignore = Some(ignore); self }
204    pub fn changed(mut self, changed: bool) -> Self { self.changed = Some(changed); self }
205    pub fn unknown(mut self, unknown: bool) -> Self { self.unknown = Some(unknown); self }
206    pub fn unavailable(mut self, unavailable: bool) -> Self { self.unavailable = Some(unavailable); self }
207    pub fn empty(mut self, empty: bool) -> Self { self.empty = Some(empty); self }
208    pub fn present(mut self, present: bool) -> Self { self.present = Some(present); self }
209    pub fn exclusive(mut self, exclusive: bool) -> Self { self.exclusive = Some(exclusive); self }
210    pub fn inuse(mut self, inuse: bool) -> Self { self.inuse = Some(inuse); self }
211    pub fn mute(mut self, mute: bool) -> Self { self.mute = Some(mute); self }
212    pub fn unpowered(mut self, unpowered: bool) -> Self { self.unpowered = Some(unpowered); self }
213    pub fn build(self) -> ReaderStateFlags {
214        ReaderStateFlags {
215            unaware: self.unaware,
216            ignore: self.ignore,
217            changed: self.changed,
218            unknown: self.unknown,
219            unavailable: self.unavailable,
220            empty: self.empty,
221            present: self.present,
222            exclusive: self.exclusive,
223            inuse: self.inuse,
224            mute: self.mute,
225            unpowered: self.unpowered,
226        }
227    }
228}
229
230/// Maps to the |SCARD_PROTOCOL_*| flags.
231
232#[derive(Debug, Clone, Serialize, Deserialize, Default)]
233#[serde(rename_all = "camelCase")]
234pub struct ProtocolSet {
235    #[serde(skip_serializing_if = "Option::is_none")]
236    t0: Option<bool>,
237    #[serde(skip_serializing_if = "Option::is_none")]
238    t1: Option<bool>,
239    #[serde(skip_serializing_if = "Option::is_none")]
240    raw: Option<bool>,
241}
242
243impl ProtocolSet {
244    /// Creates a builder for this type.
245    pub fn builder() -> ProtocolSetBuilder {
246        ProtocolSetBuilder {
247            t0: None,
248            t1: None,
249            raw: None,
250        }
251    }
252    pub fn t0(&self) -> Option<bool> { self.t0 }
253    pub fn t1(&self) -> Option<bool> { self.t1 }
254    pub fn raw(&self) -> Option<bool> { self.raw }
255}
256
257#[derive(Default)]
258pub struct ProtocolSetBuilder {
259    t0: Option<bool>,
260    t1: Option<bool>,
261    raw: Option<bool>,
262}
263
264impl ProtocolSetBuilder {
265    pub fn t0(mut self, t0: bool) -> Self { self.t0 = Some(t0); self }
266    pub fn t1(mut self, t1: bool) -> Self { self.t1 = Some(t1); self }
267    pub fn raw(mut self, raw: bool) -> Self { self.raw = Some(raw); self }
268    pub fn build(self) -> ProtocolSet {
269        ProtocolSet {
270            t0: self.t0,
271            t1: self.t1,
272            raw: self.raw,
273        }
274    }
275}
276
277/// Maps to the |SCARD_PROTOCOL_*| values.
278
279#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
280pub enum Protocol {
281    #[default]
282    #[serde(rename = "t0")]
283    T0,
284    #[serde(rename = "t1")]
285    T1,
286    #[serde(rename = "raw")]
287    Raw,
288}
289
290
291#[derive(Debug, Clone, Serialize, Deserialize, Default)]
292#[serde(rename_all = "camelCase")]
293pub struct ReaderStateIn<'a> {
294    reader: Cow<'a, str>,
295    #[serde(rename = "currentState")]
296    current_state: ReaderStateFlags,
297    #[serde(rename = "currentInsertionCount")]
298    current_insertion_count: u64,
299}
300
301impl<'a> ReaderStateIn<'a> {
302    /// Creates a builder for this type with the required parameters:
303    /// * `reader`: 
304    /// * `current_state`: 
305    /// * `current_insertion_count`: 
306    pub fn builder(reader: impl Into<Cow<'a, str>>, current_state: ReaderStateFlags, current_insertion_count: u64) -> ReaderStateInBuilder<'a> {
307        ReaderStateInBuilder {
308            reader: reader.into(),
309            current_state: current_state,
310            current_insertion_count: current_insertion_count,
311        }
312    }
313    pub fn reader(&self) -> &str { self.reader.as_ref() }
314    pub fn current_state(&self) -> &ReaderStateFlags { &self.current_state }
315    pub fn current_insertion_count(&self) -> u64 { self.current_insertion_count }
316}
317
318
319pub struct ReaderStateInBuilder<'a> {
320    reader: Cow<'a, str>,
321    current_state: ReaderStateFlags,
322    current_insertion_count: u64,
323}
324
325impl<'a> ReaderStateInBuilder<'a> {
326    pub fn build(self) -> ReaderStateIn<'a> {
327        ReaderStateIn {
328            reader: self.reader,
329            current_state: self.current_state,
330            current_insertion_count: self.current_insertion_count,
331        }
332    }
333}
334
335
336#[derive(Debug, Clone, Serialize, Deserialize, Default)]
337#[serde(rename_all = "camelCase")]
338pub struct ReaderStateOut<'a> {
339    reader: Cow<'a, str>,
340    #[serde(rename = "eventState")]
341    event_state: ReaderStateFlags,
342    #[serde(rename = "eventCount")]
343    event_count: u64,
344    atr: Cow<'a, str>,
345}
346
347impl<'a> ReaderStateOut<'a> {
348    /// Creates a builder for this type with the required parameters:
349    /// * `reader`: 
350    /// * `event_state`: 
351    /// * `event_count`: 
352    /// * `atr`: 
353    pub fn builder(reader: impl Into<Cow<'a, str>>, event_state: ReaderStateFlags, event_count: u64, atr: impl Into<Cow<'a, str>>) -> ReaderStateOutBuilder<'a> {
354        ReaderStateOutBuilder {
355            reader: reader.into(),
356            event_state: event_state,
357            event_count: event_count,
358            atr: atr.into(),
359        }
360    }
361    pub fn reader(&self) -> &str { self.reader.as_ref() }
362    pub fn event_state(&self) -> &ReaderStateFlags { &self.event_state }
363    pub fn event_count(&self) -> u64 { self.event_count }
364    pub fn atr(&self) -> &str { self.atr.as_ref() }
365}
366
367
368pub struct ReaderStateOutBuilder<'a> {
369    reader: Cow<'a, str>,
370    event_state: ReaderStateFlags,
371    event_count: u64,
372    atr: Cow<'a, str>,
373}
374
375impl<'a> ReaderStateOutBuilder<'a> {
376    pub fn build(self) -> ReaderStateOut<'a> {
377        ReaderStateOut {
378            reader: self.reader,
379            event_state: self.event_state,
380            event_count: self.event_count,
381            atr: self.atr,
382        }
383    }
384}
385
386#[derive(Debug, Clone, Serialize, Deserialize, Default)]
387pub struct EnableParams {}
388
389impl EnableParams { pub const METHOD: &'static str = "SmartCardEmulation.enable"; }
390
391impl<'a> crate::CdpCommand<'a> for EnableParams {
392    const METHOD: &'static str = "SmartCardEmulation.enable";
393    type Response = crate::EmptyReturns;
394}
395
396#[derive(Debug, Clone, Serialize, Deserialize, Default)]
397pub struct DisableParams {}
398
399impl DisableParams { pub const METHOD: &'static str = "SmartCardEmulation.disable"; }
400
401impl<'a> crate::CdpCommand<'a> for DisableParams {
402    const METHOD: &'static str = "SmartCardEmulation.disable";
403    type Response = crate::EmptyReturns;
404}
405
406/// Reports the successful result of a |SCardEstablishContext| call.
407/// 
408/// This maps to:
409/// PC/SC Lite: <https://pcsclite.apdu.fr/api/group__API.html#gaa1b8970169fd4883a6dc4a8f43f19b67>
410/// Microsoft: <https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardestablishcontext>
411
412#[derive(Debug, Clone, Serialize, Deserialize, Default)]
413#[serde(rename_all = "camelCase")]
414pub struct ReportEstablishContextResultParams<'a> {
415    #[serde(rename = "requestId")]
416    request_id: Cow<'a, str>,
417    #[serde(rename = "contextId")]
418    context_id: u64,
419}
420
421impl<'a> ReportEstablishContextResultParams<'a> {
422    /// Creates a builder for this type with the required parameters:
423    /// * `request_id`: 
424    /// * `context_id`: 
425    pub fn builder(request_id: impl Into<Cow<'a, str>>, context_id: u64) -> ReportEstablishContextResultParamsBuilder<'a> {
426        ReportEstablishContextResultParamsBuilder {
427            request_id: request_id.into(),
428            context_id: context_id,
429        }
430    }
431    pub fn request_id(&self) -> &str { self.request_id.as_ref() }
432    pub fn context_id(&self) -> u64 { self.context_id }
433}
434
435
436pub struct ReportEstablishContextResultParamsBuilder<'a> {
437    request_id: Cow<'a, str>,
438    context_id: u64,
439}
440
441impl<'a> ReportEstablishContextResultParamsBuilder<'a> {
442    pub fn build(self) -> ReportEstablishContextResultParams<'a> {
443        ReportEstablishContextResultParams {
444            request_id: self.request_id,
445            context_id: self.context_id,
446        }
447    }
448}
449
450impl<'a> ReportEstablishContextResultParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportEstablishContextResult"; }
451
452impl<'a> crate::CdpCommand<'a> for ReportEstablishContextResultParams<'a> {
453    const METHOD: &'static str = "SmartCardEmulation.reportEstablishContextResult";
454    type Response = crate::EmptyReturns;
455}
456
457/// Reports the successful result of a |SCardReleaseContext| call.
458/// 
459/// This maps to:
460/// PC/SC Lite: <https://pcsclite.apdu.fr/api/group__API.html#ga6aabcba7744c5c9419fdd6404f73a934>
461/// Microsoft: <https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardreleasecontext>
462
463#[derive(Debug, Clone, Serialize, Deserialize, Default)]
464#[serde(rename_all = "camelCase")]
465pub struct ReportReleaseContextResultParams<'a> {
466    #[serde(rename = "requestId")]
467    request_id: Cow<'a, str>,
468}
469
470impl<'a> ReportReleaseContextResultParams<'a> {
471    /// Creates a builder for this type with the required parameters:
472    /// * `request_id`: 
473    pub fn builder(request_id: impl Into<Cow<'a, str>>) -> ReportReleaseContextResultParamsBuilder<'a> {
474        ReportReleaseContextResultParamsBuilder {
475            request_id: request_id.into(),
476        }
477    }
478    pub fn request_id(&self) -> &str { self.request_id.as_ref() }
479}
480
481
482pub struct ReportReleaseContextResultParamsBuilder<'a> {
483    request_id: Cow<'a, str>,
484}
485
486impl<'a> ReportReleaseContextResultParamsBuilder<'a> {
487    pub fn build(self) -> ReportReleaseContextResultParams<'a> {
488        ReportReleaseContextResultParams {
489            request_id: self.request_id,
490        }
491    }
492}
493
494impl<'a> ReportReleaseContextResultParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportReleaseContextResult"; }
495
496impl<'a> crate::CdpCommand<'a> for ReportReleaseContextResultParams<'a> {
497    const METHOD: &'static str = "SmartCardEmulation.reportReleaseContextResult";
498    type Response = crate::EmptyReturns;
499}
500
501/// Reports the successful result of a |SCardListReaders| call.
502/// 
503/// This maps to:
504/// PC/SC Lite: <https://pcsclite.apdu.fr/api/group__API.html#ga93b07815789b3cf2629d439ecf20f0d9>
505/// Microsoft: <https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardlistreadersa>
506
507#[derive(Debug, Clone, Serialize, Deserialize, Default)]
508#[serde(rename_all = "camelCase")]
509pub struct ReportListReadersResultParams<'a> {
510    #[serde(rename = "requestId")]
511    request_id: Cow<'a, str>,
512    readers: Vec<Cow<'a, str>>,
513}
514
515impl<'a> ReportListReadersResultParams<'a> {
516    /// Creates a builder for this type with the required parameters:
517    /// * `request_id`: 
518    /// * `readers`: 
519    pub fn builder(request_id: impl Into<Cow<'a, str>>, readers: Vec<Cow<'a, str>>) -> ReportListReadersResultParamsBuilder<'a> {
520        ReportListReadersResultParamsBuilder {
521            request_id: request_id.into(),
522            readers: readers,
523        }
524    }
525    pub fn request_id(&self) -> &str { self.request_id.as_ref() }
526    pub fn readers(&self) -> &[Cow<'a, str>] { &self.readers }
527}
528
529
530pub struct ReportListReadersResultParamsBuilder<'a> {
531    request_id: Cow<'a, str>,
532    readers: Vec<Cow<'a, str>>,
533}
534
535impl<'a> ReportListReadersResultParamsBuilder<'a> {
536    pub fn build(self) -> ReportListReadersResultParams<'a> {
537        ReportListReadersResultParams {
538            request_id: self.request_id,
539            readers: self.readers,
540        }
541    }
542}
543
544impl<'a> ReportListReadersResultParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportListReadersResult"; }
545
546impl<'a> crate::CdpCommand<'a> for ReportListReadersResultParams<'a> {
547    const METHOD: &'static str = "SmartCardEmulation.reportListReadersResult";
548    type Response = crate::EmptyReturns;
549}
550
551/// Reports the successful result of a |SCardGetStatusChange| call.
552/// 
553/// This maps to:
554/// PC/SC Lite: <https://pcsclite.apdu.fr/api/group__API.html#ga33247d5d1257d59e55647c3bb717db24>
555/// Microsoft: <https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardgetstatuschangea>
556
557#[derive(Debug, Clone, Serialize, Deserialize, Default)]
558#[serde(rename_all = "camelCase")]
559pub struct ReportGetStatusChangeResultParams<'a> {
560    #[serde(rename = "requestId")]
561    request_id: Cow<'a, str>,
562    #[serde(rename = "readerStates")]
563    reader_states: Vec<ReaderStateOut<'a>>,
564}
565
566impl<'a> ReportGetStatusChangeResultParams<'a> {
567    /// Creates a builder for this type with the required parameters:
568    /// * `request_id`: 
569    /// * `reader_states`: 
570    pub fn builder(request_id: impl Into<Cow<'a, str>>, reader_states: Vec<ReaderStateOut<'a>>) -> ReportGetStatusChangeResultParamsBuilder<'a> {
571        ReportGetStatusChangeResultParamsBuilder {
572            request_id: request_id.into(),
573            reader_states: reader_states,
574        }
575    }
576    pub fn request_id(&self) -> &str { self.request_id.as_ref() }
577    pub fn reader_states(&self) -> &[ReaderStateOut<'a>] { &self.reader_states }
578}
579
580
581pub struct ReportGetStatusChangeResultParamsBuilder<'a> {
582    request_id: Cow<'a, str>,
583    reader_states: Vec<ReaderStateOut<'a>>,
584}
585
586impl<'a> ReportGetStatusChangeResultParamsBuilder<'a> {
587    pub fn build(self) -> ReportGetStatusChangeResultParams<'a> {
588        ReportGetStatusChangeResultParams {
589            request_id: self.request_id,
590            reader_states: self.reader_states,
591        }
592    }
593}
594
595impl<'a> ReportGetStatusChangeResultParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportGetStatusChangeResult"; }
596
597impl<'a> crate::CdpCommand<'a> for ReportGetStatusChangeResultParams<'a> {
598    const METHOD: &'static str = "SmartCardEmulation.reportGetStatusChangeResult";
599    type Response = crate::EmptyReturns;
600}
601
602/// Reports the result of a |SCardBeginTransaction| call.
603/// On success, this creates a new transaction object.
604/// 
605/// This maps to:
606/// PC/SC Lite: <https://pcsclite.apdu.fr/api/group__API.html#gaddb835dce01a0da1d6ca02d33ee7d861>
607/// Microsoft: <https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardbegintransaction>
608
609#[derive(Debug, Clone, Serialize, Deserialize, Default)]
610#[serde(rename_all = "camelCase")]
611pub struct ReportBeginTransactionResultParams<'a> {
612    #[serde(rename = "requestId")]
613    request_id: Cow<'a, str>,
614    handle: i64,
615}
616
617impl<'a> ReportBeginTransactionResultParams<'a> {
618    /// Creates a builder for this type with the required parameters:
619    /// * `request_id`: 
620    /// * `handle`: 
621    pub fn builder(request_id: impl Into<Cow<'a, str>>, handle: i64) -> ReportBeginTransactionResultParamsBuilder<'a> {
622        ReportBeginTransactionResultParamsBuilder {
623            request_id: request_id.into(),
624            handle: handle,
625        }
626    }
627    pub fn request_id(&self) -> &str { self.request_id.as_ref() }
628    pub fn handle(&self) -> i64 { self.handle }
629}
630
631
632pub struct ReportBeginTransactionResultParamsBuilder<'a> {
633    request_id: Cow<'a, str>,
634    handle: i64,
635}
636
637impl<'a> ReportBeginTransactionResultParamsBuilder<'a> {
638    pub fn build(self) -> ReportBeginTransactionResultParams<'a> {
639        ReportBeginTransactionResultParams {
640            request_id: self.request_id,
641            handle: self.handle,
642        }
643    }
644}
645
646impl<'a> ReportBeginTransactionResultParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportBeginTransactionResult"; }
647
648impl<'a> crate::CdpCommand<'a> for ReportBeginTransactionResultParams<'a> {
649    const METHOD: &'static str = "SmartCardEmulation.reportBeginTransactionResult";
650    type Response = crate::EmptyReturns;
651}
652
653/// Reports the successful result of a call that returns only a result code.
654/// Used for: |SCardCancel|, |SCardDisconnect|, |SCardSetAttrib|, |SCardEndTransaction|.
655/// 
656/// This maps to:
657/// 1. SCardCancel
658/// PC/SC Lite: <https://pcsclite.apdu.fr/api/group__API.html#gaacbbc0c6d6c0cbbeb4f4debf6fbeeee6>
659/// Microsoft: <https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardcancel>
660/// 
661/// 2. SCardDisconnect
662/// PC/SC Lite: <https://pcsclite.apdu.fr/api/group__API.html#ga4be198045c73ec0deb79e66c0ca1738a>
663/// Microsoft: <https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scarddisconnect>
664/// 
665/// 3. SCardSetAttrib
666/// PC/SC Lite: <https://pcsclite.apdu.fr/api/group__API.html#ga060f0038a4ddfd5dd2b8fadf3c3a2e4f>
667/// Microsoft: <https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardsetattrib>
668/// 
669/// 4. SCardEndTransaction
670/// PC/SC Lite: <https://pcsclite.apdu.fr/api/group__API.html#gae8742473b404363e5c587f570d7e2f3b>
671/// Microsoft: <https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardendtransaction>
672
673#[derive(Debug, Clone, Serialize, Deserialize, Default)]
674#[serde(rename_all = "camelCase")]
675pub struct ReportPlainResultParams<'a> {
676    #[serde(rename = "requestId")]
677    request_id: Cow<'a, str>,
678}
679
680impl<'a> ReportPlainResultParams<'a> {
681    /// Creates a builder for this type with the required parameters:
682    /// * `request_id`: 
683    pub fn builder(request_id: impl Into<Cow<'a, str>>) -> ReportPlainResultParamsBuilder<'a> {
684        ReportPlainResultParamsBuilder {
685            request_id: request_id.into(),
686        }
687    }
688    pub fn request_id(&self) -> &str { self.request_id.as_ref() }
689}
690
691
692pub struct ReportPlainResultParamsBuilder<'a> {
693    request_id: Cow<'a, str>,
694}
695
696impl<'a> ReportPlainResultParamsBuilder<'a> {
697    pub fn build(self) -> ReportPlainResultParams<'a> {
698        ReportPlainResultParams {
699            request_id: self.request_id,
700        }
701    }
702}
703
704impl<'a> ReportPlainResultParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportPlainResult"; }
705
706impl<'a> crate::CdpCommand<'a> for ReportPlainResultParams<'a> {
707    const METHOD: &'static str = "SmartCardEmulation.reportPlainResult";
708    type Response = crate::EmptyReturns;
709}
710
711/// Reports the successful result of a |SCardConnect| call.
712/// 
713/// This maps to:
714/// PC/SC Lite: <https://pcsclite.apdu.fr/api/group__API.html#ga4e515829752e0a8dbc4d630696a8d6a5>
715/// Microsoft: <https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardconnecta>
716
717#[derive(Debug, Clone, Serialize, Deserialize, Default)]
718#[serde(rename_all = "camelCase")]
719pub struct ReportConnectResultParams<'a> {
720    #[serde(rename = "requestId")]
721    request_id: Cow<'a, str>,
722    handle: i64,
723    #[serde(skip_serializing_if = "Option::is_none", rename = "activeProtocol")]
724    active_protocol: Option<Protocol>,
725}
726
727impl<'a> ReportConnectResultParams<'a> {
728    /// Creates a builder for this type with the required parameters:
729    /// * `request_id`: 
730    /// * `handle`: 
731    pub fn builder(request_id: impl Into<Cow<'a, str>>, handle: i64) -> ReportConnectResultParamsBuilder<'a> {
732        ReportConnectResultParamsBuilder {
733            request_id: request_id.into(),
734            handle: handle,
735            active_protocol: None,
736        }
737    }
738    pub fn request_id(&self) -> &str { self.request_id.as_ref() }
739    pub fn handle(&self) -> i64 { self.handle }
740    pub fn active_protocol(&self) -> Option<&Protocol> { self.active_protocol.as_ref() }
741}
742
743
744pub struct ReportConnectResultParamsBuilder<'a> {
745    request_id: Cow<'a, str>,
746    handle: i64,
747    active_protocol: Option<Protocol>,
748}
749
750impl<'a> ReportConnectResultParamsBuilder<'a> {
751    pub fn active_protocol(mut self, active_protocol: impl Into<Protocol>) -> Self { self.active_protocol = Some(active_protocol.into()); self }
752    pub fn build(self) -> ReportConnectResultParams<'a> {
753        ReportConnectResultParams {
754            request_id: self.request_id,
755            handle: self.handle,
756            active_protocol: self.active_protocol,
757        }
758    }
759}
760
761impl<'a> ReportConnectResultParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportConnectResult"; }
762
763impl<'a> crate::CdpCommand<'a> for ReportConnectResultParams<'a> {
764    const METHOD: &'static str = "SmartCardEmulation.reportConnectResult";
765    type Response = crate::EmptyReturns;
766}
767
768/// Reports the successful result of a call that sends back data on success.
769/// Used for |SCardTransmit|, |SCardControl|, and |SCardGetAttrib|.
770/// 
771/// This maps to:
772/// 1. SCardTransmit
773/// PC/SC Lite: <https://pcsclite.apdu.fr/api/group__API.html#ga9a2d77242a271310269065e64633ab99>
774/// Microsoft: <https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardtransmit>
775/// 
776/// 2. SCardControl
777/// PC/SC Lite: <https://pcsclite.apdu.fr/api/group__API.html#gac3454d4657110fd7f753b2d3d8f4e32f>
778/// Microsoft: <https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardcontrol>
779/// 
780/// 3. SCardGetAttrib
781/// PC/SC Lite: <https://pcsclite.apdu.fr/api/group__API.html#gaacfec51917255b7a25b94c5104961602>
782/// Microsoft: <https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardgetattrib>
783
784#[derive(Debug, Clone, Serialize, Deserialize, Default)]
785#[serde(rename_all = "camelCase")]
786pub struct ReportDataResultParams<'a> {
787    #[serde(rename = "requestId")]
788    request_id: Cow<'a, str>,
789    data: Cow<'a, str>,
790}
791
792impl<'a> ReportDataResultParams<'a> {
793    /// Creates a builder for this type with the required parameters:
794    /// * `request_id`: 
795    /// * `data`: 
796    pub fn builder(request_id: impl Into<Cow<'a, str>>, data: impl Into<Cow<'a, str>>) -> ReportDataResultParamsBuilder<'a> {
797        ReportDataResultParamsBuilder {
798            request_id: request_id.into(),
799            data: data.into(),
800        }
801    }
802    pub fn request_id(&self) -> &str { self.request_id.as_ref() }
803    pub fn data(&self) -> &str { self.data.as_ref() }
804}
805
806
807pub struct ReportDataResultParamsBuilder<'a> {
808    request_id: Cow<'a, str>,
809    data: Cow<'a, str>,
810}
811
812impl<'a> ReportDataResultParamsBuilder<'a> {
813    pub fn build(self) -> ReportDataResultParams<'a> {
814        ReportDataResultParams {
815            request_id: self.request_id,
816            data: self.data,
817        }
818    }
819}
820
821impl<'a> ReportDataResultParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportDataResult"; }
822
823impl<'a> crate::CdpCommand<'a> for ReportDataResultParams<'a> {
824    const METHOD: &'static str = "SmartCardEmulation.reportDataResult";
825    type Response = crate::EmptyReturns;
826}
827
828/// Reports the successful result of a |SCardStatus| call.
829/// 
830/// This maps to:
831/// PC/SC Lite: <https://pcsclite.apdu.fr/api/group__API.html#gae49c3c894ad7ac12a5b896bde70d0382>
832/// Microsoft: <https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardstatusa>
833
834#[derive(Debug, Clone, Serialize, Deserialize, Default)]
835#[serde(rename_all = "camelCase")]
836pub struct ReportStatusResultParams<'a> {
837    #[serde(rename = "requestId")]
838    request_id: Cow<'a, str>,
839    #[serde(rename = "readerName")]
840    reader_name: Cow<'a, str>,
841    state: ConnectionState,
842    atr: Cow<'a, str>,
843    #[serde(skip_serializing_if = "Option::is_none")]
844    protocol: Option<Protocol>,
845}
846
847impl<'a> ReportStatusResultParams<'a> {
848    /// Creates a builder for this type with the required parameters:
849    /// * `request_id`: 
850    /// * `reader_name`: 
851    /// * `state`: 
852    /// * `atr`: 
853    pub fn builder(request_id: impl Into<Cow<'a, str>>, reader_name: impl Into<Cow<'a, str>>, state: impl Into<ConnectionState>, atr: impl Into<Cow<'a, str>>) -> ReportStatusResultParamsBuilder<'a> {
854        ReportStatusResultParamsBuilder {
855            request_id: request_id.into(),
856            reader_name: reader_name.into(),
857            state: state.into(),
858            atr: atr.into(),
859            protocol: None,
860        }
861    }
862    pub fn request_id(&self) -> &str { self.request_id.as_ref() }
863    pub fn reader_name(&self) -> &str { self.reader_name.as_ref() }
864    pub fn state(&self) -> &ConnectionState { &self.state }
865    pub fn atr(&self) -> &str { self.atr.as_ref() }
866    pub fn protocol(&self) -> Option<&Protocol> { self.protocol.as_ref() }
867}
868
869
870pub struct ReportStatusResultParamsBuilder<'a> {
871    request_id: Cow<'a, str>,
872    reader_name: Cow<'a, str>,
873    state: ConnectionState,
874    atr: Cow<'a, str>,
875    protocol: Option<Protocol>,
876}
877
878impl<'a> ReportStatusResultParamsBuilder<'a> {
879    pub fn protocol(mut self, protocol: impl Into<Protocol>) -> Self { self.protocol = Some(protocol.into()); self }
880    pub fn build(self) -> ReportStatusResultParams<'a> {
881        ReportStatusResultParams {
882            request_id: self.request_id,
883            reader_name: self.reader_name,
884            state: self.state,
885            atr: self.atr,
886            protocol: self.protocol,
887        }
888    }
889}
890
891impl<'a> ReportStatusResultParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportStatusResult"; }
892
893impl<'a> crate::CdpCommand<'a> for ReportStatusResultParams<'a> {
894    const METHOD: &'static str = "SmartCardEmulation.reportStatusResult";
895    type Response = crate::EmptyReturns;
896}
897
898/// Reports an error result for the given request.
899
900#[derive(Debug, Clone, Serialize, Deserialize, Default)]
901#[serde(rename_all = "camelCase")]
902pub struct ReportErrorParams<'a> {
903    #[serde(rename = "requestId")]
904    request_id: Cow<'a, str>,
905    #[serde(rename = "resultCode")]
906    result_code: ResultCode,
907}
908
909impl<'a> ReportErrorParams<'a> {
910    /// Creates a builder for this type with the required parameters:
911    /// * `request_id`: 
912    /// * `result_code`: 
913    pub fn builder(request_id: impl Into<Cow<'a, str>>, result_code: impl Into<ResultCode>) -> ReportErrorParamsBuilder<'a> {
914        ReportErrorParamsBuilder {
915            request_id: request_id.into(),
916            result_code: result_code.into(),
917        }
918    }
919    pub fn request_id(&self) -> &str { self.request_id.as_ref() }
920    pub fn result_code(&self) -> &ResultCode { &self.result_code }
921}
922
923
924pub struct ReportErrorParamsBuilder<'a> {
925    request_id: Cow<'a, str>,
926    result_code: ResultCode,
927}
928
929impl<'a> ReportErrorParamsBuilder<'a> {
930    pub fn build(self) -> ReportErrorParams<'a> {
931        ReportErrorParams {
932            request_id: self.request_id,
933            result_code: self.result_code,
934        }
935    }
936}
937
938impl<'a> ReportErrorParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportError"; }
939
940impl<'a> crate::CdpCommand<'a> for ReportErrorParams<'a> {
941    const METHOD: &'static str = "SmartCardEmulation.reportError";
942    type Response = crate::EmptyReturns;
943}
browser_protocol/smartcardemulation/mod.rs

browser_protocol/smartcardemulation/
mod.rs
